Build Camino packages from explicit contract inputs

Project source-free capability contracts and keep exact source provenance in package assembly. Reuse compiled groups across unrelated graph and dependency implementation edits. Keep React public inputs separate from workspace query lowering and retain explicit type-companion dependencies.

Allow independent execution-package checks, scope resource compilation to declared dependencies, and memoize source closure traversal. Document generic-specialization limits and measured Reader rebuild behavior.

Verified protocol, artifact, package, React, and managed activation checks; retained-Git independent/workspace artifact equality and incompatible type dependency rejection; nix fmt -- --check and lint. One-off Reader measurements recompiled 1 of 13 groups for a child edit and 0 for a workspace QX default edit.

src/execution-world/plan.ts

@@ -11,13 +11,12 @@ import type {
   OperationId,
 } from "../capability-model/types.js";
 import { validateWorkspaceRevision } from "../capability-model/validation.js";
-import { moduleContract } from "../capability-model/modules.js";
 import { canonicalJson, contentDigest } from "../capability-model/evolution.js";
 import { resolveForwardedBinding } from "../capability-model/forwarding.js";
 import { linkQueries, type LinkedQuery } from "../query/link.js";
 import { type BindingSchema } from "../bindings/index.js";
 import { unsupportedQueryOperator } from "./query-operators.js";
-import { moduleTypeContext } from "./module-contracts.js";
+import { packageBuildContexts } from "./build-contract.js";
 
 export class ExecutionPlanError extends Error {
   constructor(
@@ -78,30 +77,6 @@ export interface PlanPackage {
   exports: { id: string; execution: ExecutionContract }[];
 }
 
-/** React consumes these module contracts; other contracts remain metadata until
- * an artifact consumer exists. This does not make modules callable operations. */
-function componentDeclarations(workspace: WorkspaceRevision, pkg: WorkspaceRevision["packageImports"][number]) {
-  return [
-    ...(pkg.modules ?? []).flatMap((module) => {
-      const contract = moduleContract(workspace.interfaceImports, module)!;
-      if (
-        !["org.quixos.react.component/1", "org.quixos.react.component/2", "org.quixos.react.subject-only/1"].includes(
-          contract.contract,
-        ) ||
-        contract.subject?.kind !== "interface"
-      )
-        return [];
-      return [
-        {
-          id: module.id,
-          displayName: module.displayName,
-          subject: contract.subject.interfaceRevisionId,
-          runtime: "react" as const,
-        },
-      ];
-    }),
-  ];
-}
 export interface ExecutionPlanDefinition {
   presentations?: NonNullable<WorkspaceRevision["presentations"]>;
   codec: "camino-execution-plan-v1";
@@ -543,37 +518,21 @@ export function compileExecutionPlan(
     packages: sorted(workspace.packageImports, (p) => p.revisionId),
   };
   const normalizedSchema = JSON.parse(canonicalJson(schema)) as BindingSchema;
+  const buildContexts = packageBuildContexts(normalizedSchema);
   const definition: ExecutionPlanDefinition = {
     codec: "camino-execution-plan-v1",
     workspace,
     bindingSchema: normalizedSchema,
     ...(workspace.presentations?.length ? { presentations: sorted(workspace.presentations, (p) => p.id) } : {}),
-    packages: sorted(workspace.packageImports, (p) => p.revisionId).map((p) => ({
-      revision: p.revisionId,
-      source: p.source,
-      sourceDigest: hexDigest({ revision: p.revisionId, source: p.source }),
-      bindingDigest: hexDigest(normalizedSchema),
-      ...(p.modules?.length
-        ? {
-            modules: sorted(p.modules, (module) => module.id).map((module) => {
-              const contract = moduleContract(workspace.interfaceImports, module)!;
-              return {
-                ...module,
-                contract: contract.contract,
-                ...(contract.subject ? { subject: contract.subject } : {}),
-                ...moduleTypeContext(
-                  workspace.interfaceImports.find((iface) => iface.revisionId === module.interfaceRevisionId)!,
-                ),
-              };
-            }),
-          }
-        : {}),
-      ...(p.controllers?.length ? { controllers: sorted(p.controllers, (controller) => controller.id) } : {}),
-      ...(componentDeclarations(workspace, p).length
-        ? { components: sorted(componentDeclarations(workspace, p), (component) => component.id) }
-        : {}),
-      exports: sorted(p.exports, (e) => e.id).map((e) => ({ id: e.id, execution: e.execution ?? { kind: "remote" } })),
-    })),
+    packages: sorted(workspace.packageImports, (p) => p.revisionId).map((p) => {
+      const contract = buildContexts[p.revisionId]!.contract;
+      return {
+        ...contract.definition.package,
+        source: p.source,
+        sourceDigest: hexDigest({ revision: p.revisionId, source: p.source }),
+        bindingDigest: contract.digest,
+      };
+    }),
     owners: sorted(workspace.conformances, (c) => c.id ?? "").map((c) => {
       if (!c.id)
         throw new ExecutionPlanError(