@stardeck-customer-apps/compose 0.8.0 → 0.10.0

package/dist/index.js

@@ -2027,16 +2027,20 @@ var require_semver2 = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BUILD_TSCONFIG_PATH: () => BUILD_TSCONFIG_PATH,
   COMPOSE_INPUTS_PATH: () => COMPOSE_INPUTS_PATH,
   assertSupportedTypescript: () => assertSupportedTypescript,
   compose: () => compose,
   escapeGitignore: () => escapeGitignore,
+  findModuleBoundaryViolations: () => findModuleBoundaryViolations,
+  findOptionalPeerViolations: () => findOptionalPeerViolations,
+  formatBoundaryViolations: () => formatBoundaryViolations,
   readComposeInputs: () => readComposeInputs
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_child_process2 = require("child_process");
-var import_node_fs2 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
 
 // ../../packages/lib/src/server/module-rail/local-fs-sandbox.ts
 var import_node_child_process = require("child_process");
@@ -2095,11 +2099,54 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
-// ../../packages/lib/src/shared/module-composition.ts
-var import_zod6 = require("zod");
+// ../../packages/lib/src/shared/compose-inputs.ts
+var import_zod = require("zod");
+var COMPOSE_INPUTS_PATH = "apps/web/stardeck.compose.json";
+var composeInputsSchema = import_zod.z.strictObject({
+  connectedStores: import_zod.z.array(
+    import_zod.z.strictObject({
+      storeId: import_zod.z.string().min(1),
+      slug: import_zod.z.string().min(1),
+      // A row with an empty binding key must not fail a deploy: the rail
+      // treats falsy as "no binding key", so normalise rather than reject.
+      bindingKey: import_zod.z.string().nullish().transform((value) => value || null),
+      accessLevel: import_zod.z.enum(["read", "write", "admin"]),
+      // Defaulted so a file written before the platform emitted store types
+      // (database rows only) still parses. The platform starts writing
+      // storage rows, with `type` set, once forks run a compose that reads it.
+      type: import_zod.z.enum(["database", "storage"]).default("database")
+    })
+  ).default([]),
+  installs: import_zod.z.record(
+    import_zod.z.string(),
+    import_zod.z.strictObject({
+      installedVersion: import_zod.z.string().min(1),
+      datastoreBindings: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).nullish()
+    })
+  ).default({})
+});
+var STUB_IGNORE_PATH = "apps/web/src/app/.gitignore";
+var STUB_IGNORE_HEADER = "# Generated by stardeck-compose \u2014 Module-rail stubs are build outputs; do not edit or commit them.";
+function escapeStubIgnorePattern(pattern) {
+  const escaped = pattern.replace(/[\\[\]*?]/g, (char) => `\\${char}`);
+  return /^[#!]/.test(escaped) ? `\\${escaped}` : escaped;
+}
+function buildStubIgnore(artifactPaths) {
+  const prefix = "apps/web/src/app/";
+  const entries = artifactPaths.filter((artifact) => artifact.startsWith(prefix)).map((artifact) => escapeStubIgnorePattern(`/${artifact.slice(prefix.length)}`)).sort();
+  return [STUB_IGNORE_HEADER, ...entries].join("\n") + "\n";
+}
+
+// ../../packages/lib/src/shared/module-enablement.ts
+function isModuleEnabledByList(raw, name, kindOf) {
+  if (!raw) return true;
+  const kind = kindOf(name);
+  if (kind != null && kind !== "feature") return true;
+  return raw.split(",").includes(name);
+}
 
 // ../../packages/module-contract/src/module-manifest.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 
 // ../../packages/module-contract/src/slug.ts
 function validateSlug(slug) {
@@ -2134,30 +2181,30 @@ var ROUTE_GROUP_REGEX = /^\([a-z0-9-]+\)$/;
 var ENDPOINT_STATIC_SEGMENT_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var ENDPOINT_PARAM_NAME_REGEX = /^[a-z][a-z0-9_-]*$/;
 var ENDPOINT_METHODS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
-var moduleNameSchema = import_zod.z.string().max(40).regex(KEBAB_SLUG_REGEX, "must be a kebab-case slug (lowercase letters, digits, hyphens)");
+var moduleNameSchema = import_zod2.z.string().max(40).regex(KEBAB_SLUG_REGEX, "must be a kebab-case slug (lowercase letters, digits, hyphens)");
 function isValidModuleName(value) {
   return moduleNameSchema.safeParse(value).success;
 }
-var projectSlugSchema = import_zod.z.string().refine((value) => validateSlug(value).valid, "must be a valid project slug");
-var moduleKindSchema = import_zod.z.enum(["feature", "library", "contract"]);
-var endpointMethodSchema = import_zod.z.enum(ENDPOINT_METHODS);
-function endpointPathValidationError(path3) {
-  if (!path3.startsWith("/api/")) {
+var projectSlugSchema = import_zod2.z.string().refine((value) => validateSlug(value).valid, "must be a valid project slug");
+var moduleKindSchema = import_zod2.z.enum(["feature", "library", "contract"]);
+var endpointMethodSchema = import_zod2.z.enum(ENDPOINT_METHODS);
+function endpointPathValidationError(path4) {
+  if (!path4.startsWith("/api/")) {
     return 'must begin with "/api/"';
   }
-  if (path3.endsWith("/")) {
+  if (path4.endsWith("/")) {
     return "must not end with a trailing slash";
   }
-  if (path3.includes("?") || path3.includes("#")) {
+  if (path4.includes("?") || path4.includes("#")) {
     return "must not include query or hash";
   }
-  if (path3.includes("\\")) {
+  if (path4.includes("\\")) {
     return "must not include backslashes";
   }
-  if (path3.includes("%")) {
+  if (path4.includes("%")) {
     return "must not include percent-encoded segments";
   }
-  const parts = path3.split("/");
+  const parts = path4.split("/");
   if (parts.length < 3 || parts[0] !== "" || parts[1] !== "api") {
     return 'must begin with "/api/"';
   }
@@ -2207,12 +2254,12 @@ function endpointPathValidationError(path3) {
   }
   return null;
 }
-function normalizeEndpointPathForCollision(path3) {
-  const error = endpointPathValidationError(path3);
+function normalizeEndpointPathForCollision(path4) {
+  const error = endpointPathValidationError(path4);
   if (error != null) {
     throw new Error(`invalid endpoint path: ${error}`);
   }
-  return path3.split("/").map((segment, index) => {
+  return path4.split("/").map((segment, index) => {
     if (index < 2) {
       return segment;
     }
@@ -2225,21 +2272,21 @@ function normalizeEndpointPathForCollision(path3) {
     return segment;
   }).join("/");
 }
-var endpointPathSchema = import_zod.z.string().superRefine((path3, ctx) => {
-  const error = endpointPathValidationError(path3);
+var endpointPathSchema = import_zod2.z.string().superRefine((path4, ctx) => {
+  const error = endpointPathValidationError(path4);
   if (error != null) {
-    ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: error });
+    ctx.addIssue({ code: import_zod2.z.ZodIssueCode.custom, message: error });
   }
 });
-var endpointClaimSchema = import_zod.z.object({
+var endpointClaimSchema = import_zod2.z.object({
   path: endpointPathSchema,
-  methods: import_zod.z.array(endpointMethodSchema).min(1, "methods must be non-empty").superRefine((methods, ctx) => {
+  methods: import_zod2.z.array(endpointMethodSchema).min(1, "methods must be non-empty").superRefine((methods, ctx) => {
     const seen = /* @__PURE__ */ new Set();
     for (let i = 0; i < methods.length; i += 1) {
       const method = methods[i];
       if (seen.has(method)) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `duplicate method "${method}"`,
           path: [i]
         });
@@ -2276,14 +2323,14 @@ function mountSegmentValidationError(segment) {
   }
   return null;
 }
-var mountSegmentSchema = import_zod.z.string().superRefine((segment, ctx) => {
+var mountSegmentSchema = import_zod2.z.string().superRefine((segment, ctx) => {
   const error = mountSegmentValidationError(segment);
   if (error != null) {
-    ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: error });
+    ctx.addIssue({ code: import_zod2.z.ZodIssueCode.custom, message: error });
   }
 });
-var mountSchema = import_zod.z.object({
-  group: import_zod.z.string().regex(ROUTE_GROUP_REGEX, 'must be a Next.js route group like "(admin)"'),
+var mountSchema = import_zod2.z.object({
+  group: import_zod2.z.string().regex(ROUTE_GROUP_REGEX, 'must be a Next.js route group like "(admin)"'),
   segment: mountSegmentSchema
 }).strict();
 function splitMountSegment(segment) {
@@ -2296,21 +2343,21 @@ function splitMountSegment(segment) {
   }
   return segment.split("/");
 }
-var tableNameSchema = import_zod.z.string().regex(SNAKE_TABLE_REGEX, "must be snake_case");
+var tableNameSchema = import_zod2.z.string().regex(SNAKE_TABLE_REGEX, "must be snake_case");
 var NPM_PACKAGE_NAME_REGEX = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
-var npmPackageNameSchema = import_zod.z.string().max(214).regex(NPM_PACKAGE_NAME_REGEX, "must be a valid npm package name");
-var descriptionSchema = import_zod.z.string().max(200, "must be at most 200 characters").refine((value) => value.trim().length > 0, "must be non-empty after trimming");
-var crossAppSchema = import_zod.z.object({
-  exposes: import_zod.z.array(import_zod.z.unknown()).max(0, "must be empty until cross-app contracts are defined"),
-  consumes: import_zod.z.array(import_zod.z.unknown()).max(0, "must be empty until cross-app contracts are defined")
+var npmPackageNameSchema = import_zod2.z.string().max(214).regex(NPM_PACKAGE_NAME_REGEX, "must be a valid npm package name");
+var descriptionSchema = import_zod2.z.string().max(200, "must be at most 200 characters").refine((value) => value.trim().length > 0, "must be non-empty after trimming");
+var crossAppSchema = import_zod2.z.object({
+  exposes: import_zod2.z.array(import_zod2.z.unknown()).max(0, "must be empty until cross-app contracts are defined"),
+  consumes: import_zod2.z.array(import_zod2.z.unknown()).max(0, "must be empty until cross-app contracts are defined")
 }).strict();
-var enhancementWorkflowsSchema = import_zod.z.record(moduleNameSchema, import_zod.z.array(import_zod.z.string().min(1))).default({});
-var enhancementEndpointsSchema = import_zod.z.record(moduleNameSchema, import_zod.z.array(endpointClaimSchema)).default({});
-var datastoreRequirementSchema = import_zod.z.object({
+var enhancementWorkflowsSchema = import_zod2.z.record(moduleNameSchema, import_zod2.z.array(import_zod2.z.string().min(1))).default({});
+var enhancementEndpointsSchema = import_zod2.z.record(moduleNameSchema, import_zod2.z.array(endpointClaimSchema)).default({});
+var datastoreRequirementSchema = import_zod2.z.object({
   /** Logical name, module-local, snake_case. Never a physical store key. */
   id: tableNameSchema,
   /** "app" = this project's app-local store; "org" = an org-level shared store. */
-  scope: import_zod.z.enum(["app", "org"]).default("app"),
+  scope: import_zod2.z.enum(["app", "org"]).default("app"),
   /**
    * Which kind of connected store satisfies this requirement. A "database"
    * requirement only ever binds to a database store and a "storage" one
@@ -2318,34 +2365,34 @@ var datastoreRequirementSchema = import_zod.z.object({
    * rail never crosses the two. Defaults to "database", the only kind the
    * rail resolved before this field existed.
    */
-  type: import_zod.z.enum(["database", "storage"]).default("database"),
+  type: import_zod2.z.enum(["database", "storage"]).default("database"),
   /** true → install fails when no store resolves; false → binding omitted, module degrades. */
-  required: import_zod.z.boolean().default(true),
+  required: import_zod2.z.boolean().default(true),
   /** Checked against the connected store's accessLevel at install. */
-  access: import_zod.z.enum(["read", "write", "admin"]).default("write")
+  access: import_zod2.z.enum(["read", "write", "admin"]).default("write")
 }).strict();
-var permissionClaimSchema = import_zod.z.object({
+var permissionClaimSchema = import_zod2.z.object({
   /**
    * Lowercase resource:action with one colon and no underscores. This grammar
    * is deliberately narrower than the platform permission tool's charset.
    */
-  key: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*$/, "must be a lowercase resource:action key").max(100, "must be at most 100 characters (platform permission tool limit)"),
+  key: import_zod2.z.string().regex(/^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*$/, "must be a lowercase resource:action key").max(100, "must be at most 100 characters (platform permission tool limit)"),
   /** Human label for the deployment auth config row. */
   description: descriptionSchema
 }).strict();
-var seedBundleSchema = import_zod.z.object({
+var seedBundleSchema = import_zod2.z.object({
   table: tableNameSchema,
   /** Columns forming the ON CONFLICT key — must appear in every row. */
-  conflictTarget: import_zod.z.array(import_zod.z.string().min(1)).min(1),
+  conflictTarget: import_zod2.z.array(import_zod2.z.string().min(1)).min(1),
   /** Scalar JSON values only (no nested objects/arrays). */
-  rows: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]))).min(1)
+  rows: import_zod2.z.array(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean(), import_zod2.z.null()]))).min(1)
 }).strict().superRefine((bundle, ctx) => {
   const rowKeys = bundle.rows.map((row) => Object.keys(row).sort().join("\0"));
   const canonical = rowKeys[0];
   for (let i = 1; i < rowKeys.length; i += 1) {
     if (rowKeys[i] !== canonical) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: "all rows in a seed bundle must have identical key sets",
         path: ["rows", i]
       });
@@ -2357,7 +2404,7 @@ var seedBundleSchema = import_zod.z.object({
     for (const col of bundle.conflictTarget) {
       if (!keys.has(col)) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `conflictTarget column "${col}" must be present in every row`,
           path: ["rows", i]
         });
@@ -2365,35 +2412,35 @@ var seedBundleSchema = import_zod.z.object({
     }
   }
 });
-var moduleManifestSchema = import_zod.z.object({
+var moduleManifestSchema = import_zod2.z.object({
   name: moduleNameSchema,
   kind: moduleKindSchema,
   // Release versions are platform-owned in module_versions. Accept this
   // legacy field while existing Module source ages out, but strip it from the
   // parsed contract so no runtime can treat module.json as version authority.
-  version: import_zod.z.unknown().optional(),
+  version: import_zod2.z.unknown().optional(),
   home: projectSlugSchema,
   /** Machine-checkable purpose line — required, ≤200 code units, non-blank when trimmed. */
   description: descriptionSchema,
-  uses: import_zod.z.array(moduleNameSchema).default([]),
+  uses: import_zod2.z.array(moduleNameSchema).default([]),
   /**
    * Soft peers: this module ships `enhancements/<peer>/` directories that are
    * composition-pruned — the installer includes them only when the peer is
    * present, so the peer is NOT an install-time requirement. Disjoint from
    * `uses`; entries may name modules absent from the composition.
    */
-  enhancements: import_zod.z.array(moduleNameSchema).default([]),
-  tables: import_zod.z.array(tableNameSchema).default([]),
-  mounts: import_zod.z.array(mountSchema).default([]),
-  integration: import_zod.z.array(import_zod.z.string()).default([]),
-  workflows: import_zod.z.array(import_zod.z.string().min(1)).default([]),
+  enhancements: import_zod2.z.array(moduleNameSchema).default([]),
+  tables: import_zod2.z.array(tableNameSchema).default([]),
+  mounts: import_zod2.z.array(mountSchema).default([]),
+  integration: import_zod2.z.array(import_zod2.z.string()).default([]),
+  workflows: import_zod2.z.array(import_zod2.z.string().min(1)).default([]),
   /**
    * Slice-scoped workflow names keyed by peer. Keys must be ⊆ `enhancements`;
    * names must be unique across root `workflows` and every slice list.
    */
   enhancementWorkflows: enhancementWorkflowsSchema,
   /** Root API endpoint path claims. */
-  endpoints: import_zod.z.array(endpointClaimSchema).default([]),
+  endpoints: import_zod2.z.array(endpointClaimSchema).default([]),
   /**
    * Slice-scoped endpoint claims keyed by peer. Keys must be ⊆ `enhancements`;
    * normalized paths must be unique across root and every slice.
@@ -2409,38 +2456,38 @@ var moduleManifestSchema = import_zod.z.object({
    * to a physical connected store and generates module-datastores.gen.ts;
    * unlike seeds, this field drives generated output.
    */
-  datastores: import_zod.z.array(datastoreRequirementSchema).optional(),
+  datastores: import_zod2.z.array(datastoreRequirementSchema).optional(),
   /**
    * Keys this module's guards enforce. Install registers them in deployment
    * auth config; registration only — declaring is never granting.
    */
-  permissions: import_zod.z.array(permissionClaimSchema).optional(),
+  permissions: import_zod2.z.array(permissionClaimSchema).optional(),
   /**
    * Optional starter rows for tables this module owns. Replay is
    * `INSERT ... ON CONFLICT (conflictTarget) DO NOTHING` — idempotent by
    * construction; the rail (not this schema) performs the replay.
    */
-  seeds: import_zod.z.array(seedBundleSchema).optional(),
+  seeds: import_zod2.z.array(seedBundleSchema).optional(),
   /** npm packages the source imports beyond the base app. Names only; the rail installs each at the home app's range. */
-  packages: import_zod.z.array(npmPackageNameSchema).optional(),
+  packages: import_zod2.z.array(npmPackageNameSchema).optional(),
   /**
    * UI-layer contract. `separable: true` asserts the Module's components/ and
    * routes/ hold presentation only — the Blueprint's
    * `module-boundaries/ui-layer` lint rule enforces it — so a fork may
    * soft-eject them. See docs/module-ui-soft-eject-plan.md.
    */
-  ui: import_zod.z.object({ separable: import_zod.z.boolean() }).strict().optional()
+  ui: import_zod2.z.object({ separable: import_zod2.z.boolean() }).strict().optional()
 }).strict().superRefine((manifest, ctx) => {
   if (manifest.uses.includes(manifest.name)) {
     ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
+      code: import_zod2.z.ZodIssueCode.custom,
       message: "a module cannot list itself in uses",
       path: ["uses"]
     });
   }
   if (manifest.enhancements.includes(manifest.name)) {
     ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
+      code: import_zod2.z.ZodIssueCode.custom,
       message: "a module cannot list itself in enhancements",
       path: ["enhancements"]
     });
@@ -2448,7 +2495,7 @@ var moduleManifestSchema = import_zod.z.object({
   const hardAndSoft = manifest.enhancements.filter((peer) => manifest.uses.includes(peer));
   if (hardAndSoft.length > 0) {
     ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
+      code: import_zod2.z.ZodIssueCode.custom,
       message: `uses and enhancements must be disjoint (a peer is either a hard dep or a soft one): ${hardAndSoft.join(", ")}`,
       path: ["enhancements"]
     });
@@ -2457,7 +2504,7 @@ var moduleManifestSchema = import_zod.z.object({
   for (const peer of Object.keys(manifest.enhancementWorkflows)) {
     if (!enhancementPeers.has(peer)) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: `enhancementWorkflows key "${peer}" must be listed in enhancements`,
         path: ["enhancementWorkflows", peer]
       });
@@ -2466,23 +2513,23 @@ var moduleManifestSchema = import_zod.z.object({
   for (const peer of Object.keys(manifest.enhancementEndpoints)) {
     if (!enhancementPeers.has(peer)) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: `enhancementEndpoints key "${peer}" must be listed in enhancements`,
         path: ["enhancementEndpoints", peer]
       });
     }
   }
   const seenWorkflows = /* @__PURE__ */ new Map();
-  const noteWorkflow = (name, path3) => {
+  const noteWorkflow = (name, path4) => {
     const existing = seenWorkflows.get(name);
     if (existing != null) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: `duplicate workflow name "${name}" (also at ${existing})`,
-        path: path3
+        path: path4
       });
     } else {
-      seenWorkflows.set(name, path3.join("."));
+      seenWorkflows.set(name, path4.join("."));
     }
   };
   for (let i = 0; i < manifest.workflows.length; i += 1) {
@@ -2494,7 +2541,7 @@ var moduleManifestSchema = import_zod.z.object({
     }
   }
   const seenEndpointKeys = /* @__PURE__ */ new Map();
-  const noteEndpoint = (claim, path3) => {
+  const noteEndpoint = (claim, path4) => {
     let key;
     try {
       key = normalizeEndpointPathForCollision(claim.path);
@@ -2504,12 +2551,12 @@ var moduleManifestSchema = import_zod.z.object({
     const existing = seenEndpointKeys.get(key);
     if (existing != null) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: `duplicate normalized endpoint path "${key}" (also at ${existing})`,
-        path: path3
+        path: path4
       });
     } else {
-      seenEndpointKeys.set(key, path3.join("."));
+      seenEndpointKeys.set(key, path4.join("."));
     }
   };
   for (let i = 0; i < manifest.endpoints.length; i += 1) {
@@ -2526,7 +2573,7 @@ var moduleManifestSchema = import_zod.z.object({
       const id = manifest.datastores[i].id;
       if (seenDatastoreIds.has(id)) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `duplicate datastore id "${id}"`,
           path: ["datastores", i, "id"]
         });
@@ -2541,7 +2588,7 @@ var moduleManifestSchema = import_zod.z.object({
       const key = manifest.permissions[i].key;
       if (seenPermissionKeys.has(key)) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `duplicate permission key "${key}"`,
           path: ["permissions", i, "key"]
         });
@@ -2553,35 +2600,35 @@ var moduleManifestSchema = import_zod.z.object({
   if (manifest.kind === "library") {
     if (manifest.tables.length > 0) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: "library modules must not declare tables",
         path: ["tables"]
       });
     }
     if (manifest.mounts.length > 0) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: "library modules must not declare mounts",
         path: ["mounts"]
       });
     }
     if (manifest.seeds != null && manifest.seeds.length > 0) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: "library modules must not declare seeds",
         path: ["seeds"]
       });
     }
     if (manifest.datastores != null && manifest.datastores.length > 0) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: "library modules must not declare datastores",
         path: ["datastores"]
       });
     }
     if (manifest.permissions != null && manifest.permissions.length > 0) {
       ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
+        code: import_zod2.z.ZodIssueCode.custom,
         message: "library modules must not declare permissions",
         path: ["permissions"]
       });
@@ -2589,7 +2636,7 @@ var moduleManifestSchema = import_zod.z.object({
   }
   if (manifest.kind === "contract" && manifest.mounts.length > 0) {
     ctx.addIssue({
-      code: import_zod.z.ZodIssueCode.custom,
+      code: import_zod2.z.ZodIssueCode.custom,
       message: "contract modules must not declare mounts",
       path: ["mounts"]
     });
@@ -2600,7 +2647,7 @@ var moduleManifestSchema = import_zod.z.object({
       const bundle = manifest.seeds[i];
       if (!ownedTables.has(bundle.table)) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `seeds may only target tables listed in tables (got "${bundle.table}")`,
           path: ["seeds", i, "table"]
         });
@@ -2610,8 +2657,8 @@ var moduleManifestSchema = import_zod.z.object({
 }).transform(({ version: _legacyVersion, ...manifest }) => manifest);
 function formatZodErrors(error) {
   return error.issues.map((issue) => {
-    const path3 = issue.path.length > 0 ? issue.path.join(".") : "root";
-    return `${path3}: ${issue.message}`;
+    const path4 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `${path4}: ${issue.message}`;
   });
 }
 function parseModuleManifest(raw) {
@@ -2651,10 +2698,10 @@ var MANDATORY_MODULE_CHECK_DESCRIPTORS = Object.freeze([
 ]);
 
 // ../../packages/module-contract/src/module-structure.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // ../../packages/module-contract/src/module-e2e-manifest.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 function e2eSpecFileValidationError(file) {
   if (file.length === 0) {
     return "must be a non-empty relative path ending in .spec.ts";
@@ -2682,22 +2729,22 @@ function e2eSpecFileValidationError(file) {
   }
   return null;
 }
-var e2eSpecFileSchema = import_zod2.z.string().superRefine((file, ctx) => {
+var e2eSpecFileSchema = import_zod3.z.string().superRefine((file, ctx) => {
   const error = e2eSpecFileValidationError(file);
   if (error != null) {
-    ctx.addIssue({ code: import_zod2.z.ZodIssueCode.custom, message: error });
+    ctx.addIssue({ code: import_zod3.z.ZodIssueCode.custom, message: error });
   }
 });
-var e2eSpecSchema = import_zod2.z.object({
+var e2eSpecSchema = import_zod3.z.object({
   file: e2eSpecFileSchema,
-  requires: import_zod2.z.array(moduleNameSchema).min(1, "requires must be non-empty")
+  requires: import_zod3.z.array(moduleNameSchema).min(1, "requires must be non-empty")
 }).strict().superRefine((spec, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < spec.requires.length; i += 1) {
     const name = spec.requires[i];
     if (seen.has(name)) {
       ctx.addIssue({
-        code: import_zod2.z.ZodIssueCode.custom,
+        code: import_zod3.z.ZodIssueCode.custom,
         message: `duplicate requirement "${name}"`,
         path: ["requires", i]
       });
@@ -2706,15 +2753,15 @@ var e2eSpecSchema = import_zod2.z.object({
     }
   }
 });
-var moduleE2eManifestSchema = import_zod2.z.object({
-  specs: import_zod2.z.array(e2eSpecSchema).min(1, "specs must contain at least one entry")
+var moduleE2eManifestSchema = import_zod3.z.object({
+  specs: import_zod3.z.array(e2eSpecSchema).min(1, "specs must contain at least one entry")
 }).strict().superRefine((manifest, ctx) => {
   const seenFiles = /* @__PURE__ */ new Set();
   for (let i = 0; i < manifest.specs.length; i += 1) {
     const file = manifest.specs[i].file;
     if (seenFiles.has(file)) {
       ctx.addIssue({
-        code: import_zod2.z.ZodIssueCode.custom,
+        code: import_zod3.z.ZodIssueCode.custom,
         message: `duplicate file "${file}"`,
         path: ["specs", i, "file"]
       });
@@ -2956,7 +3003,7 @@ function compareCodeUnit(a, b) {
 // ../../packages/module-contract/src/module-structure.ts
 var MODULE_STRUCTURE_JSON_BYTE_CAP = 64 * 1024;
 function uniqueSortedStringArray(label) {
-  return import_zod3.z.array(import_zod3.z.string()).superRefine((arr, ctx) => {
+  return import_zod4.z.array(import_zod4.z.string()).superRefine((arr, ctx) => {
     if (new Set(arr).size !== arr.length) {
       ctx.addIssue({ code: "custom", message: `${label} must be unique` });
       return;
@@ -2972,10 +3019,10 @@ function uniqueSortedStringArray(label) {
   });
 }
 function contributionPermissionsSchema(label) {
-  return import_zod3.z.array(
-    import_zod3.z.object({
-      contributionId: import_zod3.z.string().min(1),
-      permission: import_zod3.z.string().min(1)
+  return import_zod4.z.array(
+    import_zod4.z.object({
+      contributionId: import_zod4.z.string().min(1),
+      permission: import_zod4.z.string().min(1)
     }).strict()
   ).superRefine((entries, ctx) => {
     const keys = entries.map((entry) => `${entry.contributionId}\0${entry.permission}`);
@@ -2993,17 +3040,17 @@ function contributionPermissionsSchema(label) {
     }
   }).optional();
 }
-var collectedFilePayloadSchema = import_zod3.z.discriminatedUnion("status", [
-  import_zod3.z.object({ status: import_zod3.z.literal("ok"), text: import_zod3.z.string() }).strict(),
-  import_zod3.z.object({ status: import_zod3.z.literal("missing") }).strict(),
-  import_zod3.z.object({ status: import_zod3.z.literal("too-large") }).strict(),
-  import_zod3.z.object({ status: import_zod3.z.literal("unreadable") }).strict()
+var collectedFilePayloadSchema = import_zod4.z.discriminatedUnion("status", [
+  import_zod4.z.object({ status: import_zod4.z.literal("ok"), text: import_zod4.z.string() }).strict(),
+  import_zod4.z.object({ status: import_zod4.z.literal("missing") }).strict(),
+  import_zod4.z.object({ status: import_zod4.z.literal("too-large") }).strict(),
+  import_zod4.z.object({ status: import_zod4.z.literal("unreadable") }).strict()
 ]);
-var collectedLocaleFileSchema = import_zod3.z.object({
-  locale: import_zod3.z.string().min(1),
+var collectedLocaleFileSchema = import_zod4.z.object({
+  locale: import_zod4.z.string().min(1),
   payload: collectedFilePayloadSchema
 }).strict();
-var collectedE2eFactsSchema = import_zod3.z.object({
+var collectedE2eFactsSchema = import_zod4.z.object({
   manifest: collectedFilePayloadSchema,
   specFiles: uniqueSortedStringArray("specFiles"),
   escapingSymlinks: uniqueSortedStringArray("escapingSymlinks")
@@ -3011,34 +3058,34 @@ var collectedE2eFactsSchema = import_zod3.z.object({
 function validateRouteExportEvidenceCongruence(input) {
   const entrySet = new Set(input.routeEntries);
   const exportPaths = input.routePageExports.map((e) => e.nextRelativePath);
-  for (const path3 of exportPaths) {
-    if (!entrySet.has(path3)) {
-      input.onIssue(`routePageExports path "${path3}" is not listed in routeEntries`);
+  for (const path4 of exportPaths) {
+    if (!entrySet.has(path4)) {
+      input.onIssue(`routePageExports path "${path4}" is not listed in routeEntries`);
     }
   }
   if (input.routeCollectionErrors.length === 0) {
     const exportSet = new Set(exportPaths);
-    for (const path3 of input.routeEntries) {
-      if (!exportSet.has(path3)) {
-        input.onIssue(`routeEntries path "${path3}" is missing from routePageExports`);
+    for (const path4 of input.routeEntries) {
+      if (!exportSet.has(path4)) {
+        input.onIssue(`routeEntries path "${path4}" is missing from routePageExports`);
       }
     }
   }
 }
-var collectedEnhancementFactsSchema = import_zod3.z.object({
-  peer: import_zod3.z.string().min(1),
-  hasContributionsTs: import_zod3.z.boolean(),
+var collectedEnhancementFactsSchema = import_zod4.z.object({
+  peer: import_zod4.z.string().min(1),
+  hasContributionsTs: import_zod4.z.boolean(),
   contributionPermissions: contributionPermissionsSchema("enhancement contributionPermissions"),
-  hasInitializeServerTs: import_zod3.z.boolean(),
+  hasInitializeServerTs: import_zod4.z.boolean(),
   contributionsCollectionErrors: uniqueSortedStringArray(
     "enhancement contributionsCollectionErrors"
   ),
   initializeServerCollectionErrors: uniqueSortedStringArray(
     "enhancement initializeServerCollectionErrors"
   ),
-  hasRoutesDir: import_zod3.z.boolean(),
+  hasRoutesDir: import_zod4.z.boolean(),
   routeCollectionErrors: uniqueSortedStringArray("enhancement routeCollectionErrors"),
-  locales: import_zod3.z.array(collectedLocaleFileSchema).superRefine((locales, ctx) => {
+  locales: import_zod4.z.array(collectedLocaleFileSchema).superRefine((locales, ctx) => {
     const names = locales.map((l) => l.locale);
     if (new Set(names).size !== names.length) {
       ctx.addIssue({ code: "custom", message: "enhancement locales must be unique by locale" });
@@ -3053,27 +3100,27 @@ var collectedEnhancementFactsSchema = import_zod3.z.object({
   }),
   e2e: collectedE2eFactsSchema.nullable()
 }).strict();
-var moduleStructureFactsSchema = import_zod3.z.object({
-  collected: import_zod3.z.literal(true),
-  dirName: import_zod3.z.string().min(1),
-  hasIndexTs: import_zod3.z.boolean(),
-  hasContributionsTs: import_zod3.z.boolean(),
+var moduleStructureFactsSchema = import_zod4.z.object({
+  collected: import_zod4.z.literal(true),
+  dirName: import_zod4.z.string().min(1),
+  hasIndexTs: import_zod4.z.boolean(),
+  hasContributionsTs: import_zod4.z.boolean(),
   contributionPermissions: contributionPermissionsSchema("contributionPermissions"),
-  hasSlotsTs: import_zod3.z.boolean(),
+  hasSlotsTs: import_zod4.z.boolean(),
   contributionsCollectionErrors: uniqueSortedStringArray("contributionsCollectionErrors"),
   slotsCollectionErrors: uniqueSortedStringArray("slotsCollectionErrors"),
-  hasTestsDir: import_zod3.z.boolean(),
-  hasDatastoreDir: import_zod3.z.boolean(),
-  datastoreFileCount: import_zod3.z.number().int().nonnegative(),
-  hasServerIndexTs: import_zod3.z.boolean(),
-  hasOtherServerTs: import_zod3.z.boolean(),
-  hasE2eDir: import_zod3.z.boolean(),
-  hasRoutesDir: import_zod3.z.boolean(),
+  hasTestsDir: import_zod4.z.boolean(),
+  hasDatastoreDir: import_zod4.z.boolean(),
+  datastoreFileCount: import_zod4.z.number().int().nonnegative(),
+  hasServerIndexTs: import_zod4.z.boolean(),
+  hasOtherServerTs: import_zod4.z.boolean(),
+  hasE2eDir: import_zod4.z.boolean(),
+  hasRoutesDir: import_zod4.z.boolean(),
   routeEntries: uniqueSortedStringArray("routeEntries"),
-  routePageExports: import_zod3.z.array(
-    import_zod3.z.object({
-      nextRelativePath: import_zod3.z.string().min(1),
-      hasGenerateMetadata: import_zod3.z.boolean()
+  routePageExports: import_zod4.z.array(
+    import_zod4.z.object({
+      nextRelativePath: import_zod4.z.string().min(1),
+      hasGenerateMetadata: import_zod4.z.boolean()
     }).strict()
   ).superRefine((entries, ctx) => {
     const paths = entries.map((e) => e.nextRelativePath);
@@ -3095,7 +3142,7 @@ var moduleStructureFactsSchema = import_zod3.z.object({
     }
   }),
   routeCollectionErrors: uniqueSortedStringArray("routeCollectionErrors"),
-  rootLocales: import_zod3.z.array(collectedLocaleFileSchema).superRefine((locales, ctx) => {
+  rootLocales: import_zod4.z.array(collectedLocaleFileSchema).superRefine((locales, ctx) => {
     const names = locales.map((l) => l.locale);
     if (new Set(names).size !== names.length) {
       ctx.addIssue({ code: "custom", message: "rootLocales must be unique by locale" });
@@ -3109,7 +3156,7 @@ var moduleStructureFactsSchema = import_zod3.z.object({
     }
   }),
   rootE2e: collectedE2eFactsSchema.nullable(),
-  enhancements: import_zod3.z.array(collectedEnhancementFactsSchema).superRefine((enhancements, ctx) => {
+  enhancements: import_zod4.z.array(collectedEnhancementFactsSchema).superRefine((enhancements, ctx) => {
     const peers = enhancements.map((e) => e.peer);
     if (new Set(peers).size !== peers.length) {
       ctx.addIssue({ code: "custom", message: "enhancement peers must be unique" });
@@ -3130,10 +3177,10 @@ var moduleStructureFactsSchema = import_zod3.z.object({
     onIssue: (message) => ctx.addIssue({ code: "custom", message })
   });
 });
-var moduleStructureCollectionSchema = import_zod3.z.object({
+var moduleStructureCollectionSchema = import_zod4.z.object({
   homeLocales: uniqueSortedStringArray("homeLocales"),
-  modules: import_zod3.z.array(moduleStructureFactsSchema),
-  truncated: import_zod3.z.boolean().optional(),
+  modules: import_zod4.z.array(moduleStructureFactsSchema),
+  truncated: import_zod4.z.boolean().optional(),
   collectionErrors: uniqueSortedStringArray("collectionErrors").optional()
 }).strict().superRefine((collection, ctx) => {
   const dirs = collection.modules.map((m) => m.dirName);
@@ -3150,9 +3197,9 @@ var moduleStructureCollectionSchema = import_zod3.z.object({
 });
 
 // ../../packages/module-contract/src/locale.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var LOCALE_BASENAME_REGEX = /^[a-z]{2,3}(-[A-Za-z0-9]+)*$/;
-var localeBasenameSchema = import_zod4.z.string().max(35).regex(LOCALE_BASENAME_REGEX, "must be a BCP47-like locale tag (e.g. en, th, en-US)");
+var localeBasenameSchema = import_zod5.z.string().max(35).regex(LOCALE_BASENAME_REGEX, "must be a BCP47-like locale tag (e.g. en, th, en-US)");
 function isValidLocaleBasename(value) {
   return localeBasenameSchema.safeParse(value).success;
 }
@@ -3555,43 +3602,43 @@ function formatRoutePageExportErrors(nextRelativePath, validation) {
 var import_typescript2 = __toESM(require("typescript"), 1);
 
 // ../../packages/module-contract/src/module-registry.ts
-var import_zod5 = require("zod");
-var projectSlugSchema2 = import_zod5.z.string().refine((value) => validateSlug(value).valid, "must be a valid project slug");
-var registryEnhancementSchema = import_zod5.z.object({
+var import_zod6 = require("zod");
+var projectSlugSchema2 = import_zod6.z.string().refine((value) => validateSlug(value).valid, "must be a valid project slug");
+var registryEnhancementSchema = import_zod6.z.object({
   peer: moduleNameSchema,
-  active: import_zod5.z.boolean()
+  active: import_zod6.z.boolean()
 }).strict();
-var registryModuleSchema = import_zod5.z.object({
+var registryModuleSchema = import_zod6.z.object({
   name: moduleNameSchema,
   /** Installed version as recorded by the rail (non-empty string). */
-  version: import_zod5.z.string().min(1),
+  version: import_zod6.z.string().min(1),
   home: projectSlugSchema2,
   kind: moduleKindSchema,
-  mounts: import_zod5.z.array(mountSchema),
-  enhancements: import_zod5.z.array(registryEnhancementSchema)
+  mounts: import_zod6.z.array(mountSchema),
+  enhancements: import_zod6.z.array(registryEnhancementSchema)
 }).strict().superRefine((mod, ctx) => {
   for (let i = 0; i < mod.enhancements.length; i += 1) {
     if (mod.enhancements[i].peer === mod.name) {
       ctx.addIssue({
-        code: import_zod5.z.ZodIssueCode.custom,
+        code: import_zod6.z.ZodIssueCode.custom,
         message: "enhancement peer must not equal the module's own name",
         path: ["enhancements", i, "peer"]
       });
     }
   }
 });
-var generatedModuleRegistrySchema = import_zod5.z.object({
-  registryVersion: import_zod5.z.literal(1),
+var generatedModuleRegistrySchema = import_zod6.z.object({
+  registryVersion: import_zod6.z.literal(1),
   /** Rail run id, or `"manual"` for fixtures. */
-  generatedBy: import_zod5.z.string().min(1),
-  modules: import_zod5.z.array(registryModuleSchema)
+  generatedBy: import_zod6.z.string().min(1),
+  modules: import_zod6.z.array(registryModuleSchema)
 }).strict().superRefine((registry, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < registry.modules.length; i += 1) {
     const name = registry.modules[i].name;
     if (seen.has(name)) {
       ctx.addIssue({
-        code: import_zod5.z.ZodIssueCode.custom,
+        code: import_zod6.z.ZodIssueCode.custom,
         message: `duplicate module name "${name}"`,
         path: ["modules", i, "name"]
       });
@@ -3962,169 +4009,6 @@ function analyzeClientSafeEntryImports(sourceText, fileName) {
   return analyzeClientSafeEntryImportsWithTs(import_typescript3.default, sourceText, fileName);
 }
 
-// ../../packages/lib/src/shared/module-composition.ts
-var moduleRefSchema = import_zod6.z.object({
-  homeProjectId: import_zod6.z.string().uuid(),
-  moduleName: moduleNameSchema
-});
-var creationSourceBlankSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("blank")
-});
-var creationSourceBlueprintSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("blueprint"),
-  /** Internal template/fork project id — keep template naming in identifiers. */
-  blueprintProjectId: import_zod6.z.string().uuid(),
-  /**
-   * `null`/absent means every feature Module. `[]` is refused: the platform
-   * serialises it to an empty `NEXT_PUBLIC_STARDECK_ENABLED_MODULES`, which the
-   * enablement parser reads back as "all" (`module-enablement.ts`) — the
-   * opposite of what an empty selection means.
-   */
-  enabledModules: import_zod6.z.array(moduleNameSchema).min(1, "Enable at least one Module").max(100).nullable().optional()
-});
-var creationSourceModulesSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("modules"),
-  requested: import_zod6.z.array(moduleRefSchema).min(1)
-});
-var creationSourceSchema = import_zod6.z.discriminatedUnion("type", [
-  creationSourceBlankSchema,
-  creationSourceBlueprintSchema,
-  creationSourceModulesSchema
-]);
-var moduleCompositionStatusSchema = import_zod6.z.enum([
-  "pending",
-  "installing",
-  "ready",
-  "partial",
-  "failed"
-]);
-var resolvedModuleSnapshotSchema = moduleRefSchema.extend({
-  version: import_zod6.z.string().min(1),
-  homeCommitSha: import_zod6.z.string().min(1)
-});
-var moduleInstallHandoffSchema = import_zod6.z.object({
-  moduleName: import_zod6.z.string().min(1),
-  homeProjectId: import_zod6.z.string().uuid(),
-  installedVersion: import_zod6.z.string().min(1),
-  baselineSha: import_zod6.z.string().min(1),
-  mounts: import_zod6.z.array(
-    import_zod6.z.object({
-      group: import_zod6.z.string(),
-      segment: import_zod6.z.string()
-    })
-  ),
-  integration: import_zod6.z.array(import_zod6.z.string()),
-  workflows: import_zod6.z.array(import_zod6.z.string()),
-  prunedEnhancements: import_zod6.z.array(import_zod6.z.string()),
-  restoredEnhancements: import_zod6.z.array(import_zod6.z.string()).optional(),
-  permissions: import_zod6.z.array(
-    import_zod6.z.object({
-      key: import_zod6.z.string().min(1),
-      description: import_zod6.z.string().min(1)
-    })
-  ).optional()
-});
-var moduleCompositionRunAttemptSchema = import_zod6.z.object({
-  module: moduleRefSchema,
-  runId: import_zod6.z.string().min(1),
-  status: import_zod6.z.string().min(1),
-  schemaApplied: import_zod6.z.boolean(),
-  error: import_zod6.z.string().optional(),
-  /** Prefer full ModuleInstallHandoff; identity fields optional for older rows. */
-  handoff: moduleInstallHandoffSchema.partial({ moduleName: true, homeProjectId: true }).optional()
-});
-var initialModuleCompositionSchema = import_zod6.z.object({
-  version: import_zod6.z.literal(1),
-  status: moduleCompositionStatusSchema,
-  requested: import_zod6.z.array(moduleRefSchema).min(1),
-  resolved: import_zod6.z.array(resolvedModuleSnapshotSchema),
-  installOrder: import_zod6.z.array(moduleRefSchema),
-  runs: import_zod6.z.array(moduleCompositionRunAttemptSchema).default([]),
-  /**
-   * True when any failed/partial attempt applied schema before failing.
-   * Never claim transactional rollback across git/schema.
-   */
-  schemaApplied: import_zod6.z.boolean().default(false),
-  /**
-   * Present when retry would silently change pinned home SHAs — caller must
-   * reconfirm the new plan rather than continue.
-   */
-  reconfirmationRequired: import_zod6.z.object({
-    reason: import_zod6.z.string(),
-    previous: import_zod6.z.array(resolvedModuleSnapshotSchema),
-    next: import_zod6.z.array(resolvedModuleSnapshotSchema)
-  }).optional(),
-  error: import_zod6.z.string().optional(),
-  /**
-   * First-turn system handoff lifecycle. Absent/`pending` means inject when
-   * status is ready; `consumed` means a successful agent turn already used it.
-   */
-  systemHandoffStatus: import_zod6.z.enum(["pending", "consumed"]).optional(),
-  /**
-   * CAS ownership token for concurrent retry attempts. Only the attempt that
-   * currently owns this value may reset or compensate durable composition state.
-   */
-  retryAttemptId: import_zod6.z.string().min(1).optional(),
-  /**
-   * When the current `installing` attempt was claimed. A setup run that dies
-   * with its host (a killed Vercel instance) leaves the composition `installing`
-   * forever, and the creating page's poll only stops on ready/partial/failed —
-   * so staleness, not a queue's stall detector, is what settles it. Absent on
-   * rows claimed before this field existed; treated as stale.
-   */
-  attemptStartedAt: import_zod6.z.string().datetime().optional(),
-  /** Outside-module files the agent changed during connection work. */
-  integrationFiles: import_zod6.z.array(import_zod6.z.string()).optional(),
-  verificationSummary: import_zod6.z.string().optional()
-});
-var MODULE_SETUP_ATTEMPT_STALE_MS = 10 * 60 * 1e3;
-
-// ../../packages/lib/src/shared/compose-inputs.ts
-var import_zod7 = require("zod");
-var COMPOSE_INPUTS_PATH = "apps/web/stardeck.compose.json";
-var composeInputsSchema = import_zod7.z.strictObject({
-  connectedStores: import_zod7.z.array(
-    import_zod7.z.strictObject({
-      storeId: import_zod7.z.string().min(1),
-      slug: import_zod7.z.string().min(1),
-      // A row with an empty binding key must not fail a deploy: the rail
-      // treats falsy as "no binding key", so normalise rather than reject.
-      bindingKey: import_zod7.z.string().nullish().transform((value) => value || null),
-      accessLevel: import_zod7.z.enum(["read", "write", "admin"]),
-      // Defaulted so a file written before the platform emitted store types
-      // (database rows only) still parses. The platform starts writing
-      // storage rows, with `type` set, once forks run a compose that reads it.
-      type: import_zod7.z.enum(["database", "storage"]).default("database")
-    })
-  ).default([]),
-  installs: import_zod7.z.record(
-    import_zod7.z.string(),
-    import_zod7.z.strictObject({
-      installedVersion: import_zod7.z.string().min(1),
-      datastoreBindings: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).nullish()
-    })
-  ).default({})
-});
-var STUB_IGNORE_PATH = "apps/web/src/app/.gitignore";
-var STUB_IGNORE_HEADER = "# Generated by stardeck-compose \u2014 Module-rail stubs are build outputs; do not edit or commit them.";
-function escapeStubIgnorePattern(pattern) {
-  const escaped = pattern.replace(/[\\[\]*?]/g, (char) => `\\${char}`);
-  return /^[#!]/.test(escaped) ? `\\${escaped}` : escaped;
-}
-function buildStubIgnore(artifactPaths) {
-  const prefix = "apps/web/src/app/";
-  const entries = artifactPaths.filter((artifact) => artifact.startsWith(prefix)).map((artifact) => escapeStubIgnorePattern(`/${artifact.slice(prefix.length)}`)).sort();
-  return [STUB_IGNORE_HEADER, ...entries].join("\n") + "\n";
-}
-
-// ../../packages/lib/src/shared/module-enablement.ts
-function isModuleEnabledByList(raw, name, kindOf) {
-  if (!raw) return true;
-  const kind = kindOf(name);
-  if (kind != null && kind !== "feature") return true;
-  return raw.split(",").includes(name);
-}
-
 // ../../packages/lib/src/shared/platform-owned-paths.ts
 var APP_WEB_PREFIX = "apps/web/";
 var MODULE_STUB_MARKER = "@stardeck-module-rail-generated";
@@ -4271,13 +4155,13 @@ function assertClientSafeConventionalEntryImports(source, pathLabel, kind) {
 function createMessageTree() {
   return /* @__PURE__ */ Object.create(null);
 }
-function assertMessageTree(value, path3) {
+function assertMessageTree(value, path4) {
   if (typeof value === "string") return;
   if (value === null || Array.isArray(value) || typeof value !== "object") {
-    throw new Error(`Invalid message at ${path3}: expected string or nested object`);
+    throw new Error(`Invalid message at ${path4}: expected string or nested object`);
   }
   for (const [key, child] of Object.entries(value)) {
-    assertMessageTree(child, `${path3}.${key}`);
+    assertMessageTree(child, `${path4}.${key}`);
   }
 }
 function cloneTree(value) {
@@ -4287,17 +4171,17 @@ function cloneTree(value) {
   }
   return clone;
 }
-function collectLeafPaths(value, path3, out) {
+function collectLeafPaths(value, path4, out) {
   if (typeof value === "string") {
-    out.push(path3);
+    out.push(path4);
     return;
   }
-  assertMessageTree(value, path3);
-  for (const [key, child] of Object.entries(value)) collectLeafPaths(child, `${path3}.${key}`, out);
+  assertMessageTree(value, path4);
+  for (const [key, child] of Object.entries(value)) collectLeafPaths(child, `${path4}.${key}`, out);
 }
-function overrideInto(target, source, owner, path3, missing) {
+function overrideInto(target, source, owner, path4, missing) {
   for (const [key, value] of Object.entries(source)) {
-    const nextPath = path3 ? `${path3}.${key}` : key;
+    const nextPath = path4 ? `${path4}.${key}` : key;
     if (!Object.prototype.hasOwnProperty.call(target, key)) {
       collectLeafPaths(value, nextPath, missing);
       continue;
@@ -4324,9 +4208,9 @@ function overrideInto(target, source, owner, path3, missing) {
 function composeLocaleMessagesForPlan(layers) {
   const result = createMessageTree();
   const leafOwners = /* @__PURE__ */ new Map();
-  function mergeInto(target, source, owner, path3) {
+  function mergeInto(target, source, owner, path4) {
     for (const [key, value] of Object.entries(source)) {
-      const nextPath = path3 ? `${path3}.${key}` : key;
+      const nextPath = path4 ? `${path4}.${key}` : key;
       const hasExisting = Object.prototype.hasOwnProperty.call(target, key);
       const existing = hasExisting ? target[key] : void 0;
       if (typeof value === "string") {
@@ -4870,8 +4754,8 @@ var METHOD_ORDER = {
 function compareNames2(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
-function endpointPairKey(method, path3) {
-  return `${method} ${path3}`;
+function endpointPairKey(method, path4) {
+  return `${method} ${path4}`;
 }
 function apiPathToRouteFile(apiPath) {
   if (!apiPath.startsWith("/api/")) {
@@ -4885,11 +4769,11 @@ function routeEntryToAppPageFile(nextRelativePath) {
 }
 var APP_ROUTE_FILE_PREFIX = `${APP_PACKAGE_DIR}/src/app/`;
 var API_ROUTE_FILE_SUFFIXES = ["/route.ts", "/route.tsx", "/route.jsx", "/route.js"];
-function appRouteFileToNextRelativePath(path3) {
-  const pagePath = appPageFileToNextRelativePath(path3, APP_PACKAGE_DIR);
+function appRouteFileToNextRelativePath(path4) {
+  const pagePath = appPageFileToNextRelativePath(path4, APP_PACKAGE_DIR);
   if (pagePath != null) return pagePath;
-  if (!path3.startsWith(APP_ROUTE_FILE_PREFIX)) return null;
-  const relative = path3.slice(APP_ROUTE_FILE_PREFIX.length);
+  if (!path4.startsWith(APP_ROUTE_FILE_PREFIX)) return null;
+  const relative = path4.slice(APP_ROUTE_FILE_PREFIX.length);
   if (!relative.startsWith("api/")) return null;
   const suffix = API_ROUTE_FILE_SUFFIXES.find((candidate) => relative.endsWith(candidate));
   if (!suffix) return null;
@@ -4981,9 +4865,9 @@ function legacyHandlerPropertyMatchesPath(property, method, physicalPath, bindin
   const expectedTokens = knownAliases[`${binding} ${method} ${physicalPath}`] ?? pathTokens;
   return handlerTokens.length === expectedTokens.length && handlerTokens.every((token, index) => token === expectedTokens[index]);
 }
-function parseLegacyApiAdapter(path3, source) {
-  const physicalPath = appRouteFileToNextRelativePath(path3);
-  if (expectedMarkerKindForPath(path3) !== "endpoint" || physicalPath == null) return null;
+function parseLegacyApiAdapter(path4, source) {
+  const physicalPath = appRouteFileToNextRelativePath(path4);
+  if (expectedMarkerKindForPath(path4) !== "endpoint" || physicalPath == null) return null;
   const firstLine = source.split(/\r?\n/, 1)[0]?.trim() ?? "";
   const match = firstLine.match(
     new RegExp(
@@ -4993,7 +4877,7 @@ function parseLegacyApiAdapter(path3, source) {
   if (!match || match[2] !== physicalPath) return null;
   const owner = match[1];
   if (!isValidModuleName(owner)) return null;
-  const file = import_typescript4.default.createSourceFile(path3, source, import_typescript4.default.ScriptTarget.Latest, false, import_typescript4.default.ScriptKind.TS);
+  const file = import_typescript4.default.createSourceFile(path4, source, import_typescript4.default.ScriptTarget.Latest, false, import_typescript4.default.ScriptKind.TS);
   if (file.parseDiagnostics.length > 0) {
     return null;
   }
@@ -5035,9 +4919,9 @@ function parseLegacyApiAdapter(path3, source) {
   }
   return handlerBinding != null && methods.size > 0 ? { owner, methods: [...methods] } : null;
 }
-function parseLegacyRouteAdapter(path3, source) {
-  const physicalPath = appRouteFileToNextRelativePath(path3);
-  if (expectedMarkerKindForPath(path3) !== "route" || physicalPath == null) return null;
+function parseLegacyRouteAdapter(path4, source) {
+  const physicalPath = appRouteFileToNextRelativePath(path4);
+  if (expectedMarkerKindForPath(path4) !== "route" || physicalPath == null) return null;
   const normalized = source.replace(/\r\n/g, "\n");
   const match = normalized.match(
     new RegExp(
@@ -5049,30 +4933,30 @@ function parseLegacyRouteAdapter(path3, source) {
   const nextRelativePath = match[2];
   return isValidModuleName(owner) && nextRelativePath === physicalPath ? { owner, nextRelativePath } : null;
 }
-function legacyRouteAdapterMatchesStub(path3, source, stub) {
-  const legacy = parseLegacyRouteAdapter(path3, source);
+function legacyRouteAdapterMatchesStub(path4, source, stub) {
+  const legacy = parseLegacyRouteAdapter(path4, source);
   return legacy != null && legacy.owner === stub.owner;
 }
 var API_ROUTE_DIR_PREFIX = `${APP_PACKAGE_DIR}/src/app/api/`;
 var APP_DIR_PREFIX = `${APP_PACKAGE_DIR}/src/app/`;
 var PAGE_FILE_SUFFIXES = ["/page.tsx", "/page.ts", "/page.jsx", "/page.js"];
-function expectedMarkerKindForPath(path3) {
-  if (path3 === MODULES_GEN_PATH) return "registry";
-  if (path3 === MODULE_CONTRIBUTIONS_GEN_PATH) return "contributions";
-  if (path3 === MODULE_DATASTORES_GEN_PATH) return "datastores";
-  if (path3 === MODULE_I18N_GEN_PATH) return "i18n";
-  if (path3 === MODULE_INIT_SERVER_GEN_PATH) return "init";
-  if (path3 === MODULE_SERVER_GEN_PATH) return "server";
-  if (path3.startsWith(API_ROUTE_DIR_PREFIX) && path3.endsWith("/route.ts")) return "endpoint";
-  if (path3.startsWith(APP_DIR_PREFIX) && !path3.startsWith(API_ROUTE_DIR_PREFIX) && PAGE_FILE_SUFFIXES.some((suffix) => path3.endsWith(suffix))) {
+function expectedMarkerKindForPath(path4) {
+  if (path4 === MODULES_GEN_PATH) return "registry";
+  if (path4 === MODULE_CONTRIBUTIONS_GEN_PATH) return "contributions";
+  if (path4 === MODULE_DATASTORES_GEN_PATH) return "datastores";
+  if (path4 === MODULE_I18N_GEN_PATH) return "i18n";
+  if (path4 === MODULE_INIT_SERVER_GEN_PATH) return "init";
+  if (path4 === MODULE_SERVER_GEN_PATH) return "server";
+  if (path4.startsWith(API_ROUTE_DIR_PREFIX) && path4.endsWith("/route.ts")) return "endpoint";
+  if (path4.startsWith(APP_DIR_PREFIX) && !path4.startsWith(API_ROUTE_DIR_PREFIX) && PAGE_FILE_SUFFIXES.some((suffix) => path4.endsWith(suffix))) {
     return "route";
   }
   return null;
 }
-function markerCongruentWithPath(path3, marker) {
-  if (expectedMarkerKindForPath(path3) !== marker.kind) return false;
+function markerCongruentWithPath(path4, marker) {
+  if (expectedMarkerKindForPath(path4) !== marker.kind) return false;
   if (marker.kind === "route") {
-    const derived = appPageFileToNextRelativePath(path3, APP_PACKAGE_DIR);
+    const derived = appPageFileToNextRelativePath(path4, APP_PACKAGE_DIR);
     return derived != null && derived === marker.nextRelativePath;
   }
   return true;
@@ -5343,8 +5227,8 @@ function buildGeneratedModuleRegistry(input) {
 function activeEnhancementPeers(registryModule) {
   return new Set(registryModule.enhancements.filter((e) => e.active).map((e) => e.peer));
 }
-function endpointBucketKey(path3, owner, scope) {
-  return `${path3}\0${owner}\0${scopeLabel(scope)}`;
+function endpointBucketKey(path4, owner, scope) {
+  return `${path4}\0${owner}\0${scopeLabel(scope)}`;
 }
 function planRouteStubs(input) {
   const endpointBuckets = /* @__PURE__ */ new Map();
@@ -5468,7 +5352,7 @@ function planRouteStubs(input) {
     for (const entry of entries) {
       const nextRelativePath = entry.nextRelativePath;
       const destination = normalizeAppRouterDestinationPattern(nextRelativePath);
-      const path3 = routeEntryToAppPageFile(nextRelativePath);
+      const path4 = routeEntryToAppPageFile(nextRelativePath);
       const existing = routeDestinationOwners.get(destination);
       if (existing) {
         throw new Error(
@@ -5478,13 +5362,13 @@ function planRouteStubs(input) {
       routeDestinationOwners.set(destination, {
         owner: regMod.name,
         nextRelativePath,
-        path: path3
+        path: path4
       });
       const importModule = routeEntryImport(regMod.name, nextRelativePath);
       const analyzed = analyzeRouteEntryPath(nextRelativePath);
       const mount = mounts.find((claim) => routeEntryCoveredByMountClaim(analyzed, claim));
       routeStubs.push({
-        path: path3,
+        path: path4,
         owner: regMod.name,
         nextRelativePath,
         importModule,
@@ -5545,16 +5429,16 @@ function planCompositionArtifacts(input) {
     ...stubs.routeStubs.map((stub) => stub.path)
   ]);
   const existingGeneratedPathSet = new Set(input.existingGeneratedPaths);
-  const isProvenStaleDeletionCandidate = (path3, content) => {
-    if (path3 === MODULES_GEN_PATH) return false;
-    if (COMPOSITION_RUNTIME_GEN_PATHS.includes(path3)) return false;
-    if (desiredPaths.has(path3)) return false;
-    if (!existingGeneratedPathSet.has(path3)) return false;
-    const legacy = parseLegacyApiAdapter(path3, content);
+  const isProvenStaleDeletionCandidate = (path4, content) => {
+    if (path4 === MODULES_GEN_PATH) return false;
+    if (COMPOSITION_RUNTIME_GEN_PATHS.includes(path4)) return false;
+    if (desiredPaths.has(path4)) return false;
+    if (!existingGeneratedPathSet.has(path4)) return false;
+    const legacy = parseLegacyApiAdapter(path4, content);
     if (legacy) return true;
-    if (parseLegacyRouteAdapter(path3, content)) return true;
+    if (parseLegacyRouteAdapter(path4, content)) return true;
     const marker = parseCompositionArtifactMarker(content);
-    return marker != null && markerCongruentWithPath(path3, marker);
+    return marker != null && markerCongruentWithPath(path4, marker);
   };
   const plannedByDestination = /* @__PURE__ */ new Map();
   for (const stub of stubs.routeStubs) {
@@ -5708,13 +5592,13 @@ function planCompositionArtifacts(input) {
   for (const stub of stubs.routeStubs) desired.set(stub.path, stub.content);
   const endpointStubByPath = new Map(stubs.endpointStubs.map((stub) => [stub.path, stub]));
   const routeStubByPath = new Map(stubs.routeStubs.map((stub) => [stub.path, stub]));
-  for (const [path3] of desired) {
-    const existing = input.existingFiles[path3];
+  for (const [path4] of desired) {
+    const existing = input.existingFiles[path4];
     if (existing == null) continue;
     let marker = parseCompositionArtifactMarker(existing);
-    const plannedEndpoint = endpointStubByPath.get(path3);
-    const plannedRoute = routeStubByPath.get(path3);
-    const legacy = parseLegacyApiAdapter(path3, existing);
+    const plannedEndpoint = endpointStubByPath.get(path4);
+    const plannedRoute = routeStubByPath.get(path4);
+    const legacy = parseLegacyApiAdapter(path4, existing);
     if (legacy && plannedEndpoint) {
       marker = {
         kind: "endpoint",
@@ -5722,66 +5606,66 @@ function planCompositionArtifacts(input) {
         scope: plannedEndpoint.scope
       };
     }
-    if (!marker && plannedRoute && legacyRouteAdapterMatchesStub(path3, existing, plannedRoute)) {
+    if (!marker && plannedRoute && legacyRouteAdapterMatchesStub(path4, existing, plannedRoute)) {
       marker = {
         kind: "route",
         owner: plannedRoute.owner,
         nextRelativePath: plannedRoute.nextRelativePath
       };
     }
-    const isGenRuntimePath = COMPOSITION_RUNTIME_GEN_PATHS.includes(path3);
+    const isGenRuntimePath = COMPOSITION_RUNTIME_GEN_PATHS.includes(path4);
     if (!marker) {
       return {
         ok: false,
-        error: path3 === MODULES_GEN_PATH ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged registry at ${path3}` : isGenRuntimePath ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged generated file at ${path3}` : `[ModuleRail] composition artifacts: refusing to overwrite unmanaged route at ${path3}`,
-        path: path3
+        error: path4 === MODULES_GEN_PATH ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged registry at ${path4}` : isGenRuntimePath ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged generated file at ${path4}` : `[ModuleRail] composition artifacts: refusing to overwrite unmanaged route at ${path4}`,
+        path: path4
       };
     }
-    const expectedKind = expectedMarkerKindForPath(path3);
+    const expectedKind = expectedMarkerKindForPath(path4);
     if (marker.kind !== expectedKind) {
       return {
         ok: false,
-        error: path3 === MODULES_GEN_PATH ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged registry at ${path3} (incongruent marker ownership: found ${marker.kind} marker)` : isGenRuntimePath ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged generated file at ${path3} (incongruent marker ownership: found ${marker.kind} marker)` : `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path3} (expected ${expectedKind ?? "no"} marker, found ${marker.kind} marker)`,
-        path: path3
+        error: path4 === MODULES_GEN_PATH ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged registry at ${path4} (incongruent marker ownership: found ${marker.kind} marker)` : isGenRuntimePath ? `[ModuleRail] composition artifacts: refusing to overwrite unmanaged generated file at ${path4} (incongruent marker ownership: found ${marker.kind} marker)` : `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path4} (expected ${expectedKind ?? "no"} marker, found ${marker.kind} marker)`,
+        path: path4
       };
     }
     if (marker.kind === "endpoint") {
-      const stub = endpointStubByPath.get(path3);
+      const stub = endpointStubByPath.get(path4);
       const ownerMatches = stub != null && marker.owner === stub.owner;
       const scopeMatches = stub != null && scopeLabel(marker.scope) === scopeLabel(stub.scope);
       if (!ownerMatches || !scopeMatches) {
         return {
           ok: false,
-          error: `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path3} (existing owner=${marker.owner} scope=${scopeLabel(marker.scope)} vs planned owner=${stub?.owner ?? "?"} scope=${stub ? scopeLabel(stub.scope) : "?"})`,
-          path: path3,
+          error: `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path4} (existing owner=${marker.owner} scope=${scopeLabel(marker.scope)} vs planned owner=${stub?.owner ?? "?"} scope=${stub ? scopeLabel(stub.scope) : "?"})`,
+          path: path4,
           owner: stub?.owner
         };
       }
     } else if (marker.kind === "route") {
-      const stub = routeStubByPath.get(path3);
+      const stub = routeStubByPath.get(path4);
       const ownerMatches = stub != null && marker.owner === stub.owner;
       const pathMatches = stub != null && marker.nextRelativePath === stub.nextRelativePath;
       if (!ownerMatches || !pathMatches) {
         return {
           ok: false,
-          error: `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path3} (existing owner=${marker.owner} path=${marker.nextRelativePath} vs planned owner=${stub?.owner ?? "?"} path=${stub?.nextRelativePath ?? "?"})`,
-          path: path3,
+          error: `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path4} (existing owner=${marker.owner} path=${marker.nextRelativePath} vs planned owner=${stub?.owner ?? "?"} path=${stub?.nextRelativePath ?? "?"})`,
+          path: path4,
           owner: stub?.owner
         };
       }
     }
   }
   const deletes = [];
-  for (const path3 of input.existingGeneratedPaths) {
-    const existing = input.existingFiles[path3];
+  for (const path4 of input.existingGeneratedPaths) {
+    const existing = input.existingFiles[path4];
     if (existing == null) continue;
-    if (!isProvenStaleDeletionCandidate(path3, existing)) {
+    if (!isProvenStaleDeletionCandidate(path4, existing)) {
       continue;
     }
-    deletes.push(path3);
+    deletes.push(path4);
   }
   deletes.sort(compareNames2);
-  const writes = [...desired.entries()].filter(([path3, content]) => input.existingFiles[path3] !== content).map(([path3, content]) => ({ path: path3, content })).sort((a, b) => compareNames2(a.path, b.path));
+  const writes = [...desired.entries()].filter(([path4, content]) => input.existingFiles[path4] !== content).map(([path4, content]) => ({ path: path4, content })).sort((a, b) => compareNames2(a.path, b.path));
   return {
     ok: true,
     plan: {
@@ -5810,8 +5694,16 @@ async function checkoutParsesTypedStores(sandbox) {
   try {
     if (!await sandbox.fileExists(APP_PACKAGE_JSON_PATH)) return false;
     const pkg = JSON.parse(await sandbox.readFile(APP_PACKAGE_JSON_PATH));
-    const range = pkg.devDependencies?.[COMPOSE_PACKAGE] ?? pkg.dependencies?.[COMPOSE_PACKAGE];
-    if (!range) return false;
+    return composeRangeParsesTypedStores(
+      pkg.devDependencies?.[COMPOSE_PACKAGE] ?? pkg.dependencies?.[COMPOSE_PACKAGE]
+    );
+  } catch {
+    return false;
+  }
+}
+function composeRangeParsesTypedStores(range) {
+  if (!range) return false;
+  try {
     const lowest = import_semver.default.minVersion(range);
     return lowest != null && import_semver.default.gte(lowest, TYPED_STORES_MIN_COMPOSE_VERSION);
   } catch {
@@ -6043,6 +5935,50 @@ function rejectPseudoModuleEntries(entries, parentDir, label) {
   return dirs;
 }
 
+// ../../packages/lib/src/shared/module-composition.ts
+var import_zod7 = require("zod");
+var creationSourceBlankSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("blank")
+});
+var creationSourceBlueprintSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("blueprint"),
+  /** Internal template/fork project id — keep template naming in identifiers. */
+  blueprintProjectId: import_zod7.z.string().uuid(),
+  /**
+   * `null`/absent means every feature Module. `[]` is refused: the platform
+   * serialises it to an empty `NEXT_PUBLIC_STARDECK_ENABLED_MODULES`, which the
+   * enablement parser reads back as "all" (`module-enablement.ts`) — the
+   * opposite of what an empty selection means.
+   */
+  enabledModules: import_zod7.z.array(moduleNameSchema).min(1, "Enable at least one Module").max(100).nullable().optional()
+});
+var creationSourceSchema = import_zod7.z.discriminatedUnion("type", [
+  creationSourceBlankSchema,
+  creationSourceBlueprintSchema
+]);
+var moduleInstallHandoffSchema = import_zod7.z.object({
+  moduleName: import_zod7.z.string().min(1),
+  homeProjectId: import_zod7.z.string().uuid(),
+  installedVersion: import_zod7.z.string().min(1),
+  baselineSha: import_zod7.z.string().min(1),
+  mounts: import_zod7.z.array(
+    import_zod7.z.object({
+      group: import_zod7.z.string(),
+      segment: import_zod7.z.string()
+    })
+  ),
+  integration: import_zod7.z.array(import_zod7.z.string()),
+  workflows: import_zod7.z.array(import_zod7.z.string()),
+  prunedEnhancements: import_zod7.z.array(import_zod7.z.string()),
+  restoredEnhancements: import_zod7.z.array(import_zod7.z.string()).optional(),
+  permissions: import_zod7.z.array(
+    import_zod7.z.object({
+      key: import_zod7.z.string().min(1),
+      description: import_zod7.z.string().min(1)
+    })
+  ).optional()
+});
+
 // ../../packages/lib/src/shared/schema-ops.ts
 var import_zod8 = require("zod");
 var columnSpecSchema = import_zod8.z.object({
@@ -6256,11 +6192,11 @@ function countedCompositionContext(context) {
           counts.sandboxExecs += 1;
           return context.sandbox.exec(...args);
         },
-        readFile: (path3) => {
+        readFile: (path4) => {
           counts.sandboxReads += 1;
-          return context.sandbox.readFile(path3);
+          return context.sandbox.readFile(path4);
         },
-        fileExists: (path3) => context.sandbox.fileExists(path3),
+        fileExists: (path4) => context.sandbox.fileExists(path4),
         fetchRemoteRef: (...args) => context.sandbox.fetchRemoteRef(...args),
         addDependencies: (specs) => context.sandbox.addDependencies(specs)
       }
@@ -6472,14 +6408,14 @@ async function discoverModuleRouteEntries(context, moduleName) {
   }
   return pages.sort((a, b) => a.nextRelativePath.localeCompare(b.nextRelativePath));
 }
-async function writeSandboxFileAtomic(target, path3, content) {
-  const dir = dirnamePosix(path3);
-  const tmp = `${path3}.tmp.${target.runId}`;
+async function writeSandboxFileAtomic(target, path4, content) {
+  const dir = dirnamePosix(path4);
+  const tmp = `${path4}.tmp.${target.runId}`;
   const b64 = Buffer.from(content, "utf8").toString("base64");
   const cmd = [
     `mkdir -p ${shellQuote(dir)}`,
     `printf '%s' ${shellQuote(b64)} | base64 -d > ${shellQuote(tmp)}`,
-    `mv -f ${shellQuote(tmp)} ${shellQuote(path3)}`
+    `mv -f ${shellQuote(tmp)} ${shellQuote(path4)}`
   ].join(" && ");
   const result = await target.sandbox.exec(cmd, { raiseOnError: false });
   if (result.exitCode !== 0) {
@@ -6494,14 +6430,14 @@ async function writeSandboxFileAtomic(target, path3, content) {
     }
     const detail = typeof result.error === "string" && result.error.trim() || result.output.trim() || `exit ${result.exitCode}`;
     throw new Error(
-      `[ModuleRail] composition artifacts: failed to write ${redactSecrets(path3)}: ${redactSecrets(detail)}`
+      `[ModuleRail] composition artifacts: failed to write ${redactSecrets(path4)}: ${redactSecrets(detail)}`
     );
   }
 }
 async function collectAbsentWriteParentDirs(context, writePaths) {
   const absent = /* @__PURE__ */ new Set();
-  for (const path3 of writePaths) {
-    let dir = dirnamePosix(path3);
+  for (const path4 of writePaths) {
+    let dir = dirnamePosix(path4);
     while (dir !== "." && dir !== "") {
       if (absent.has(dir)) {
         dir = dirnamePosix(dir);
@@ -6538,12 +6474,12 @@ async function removeAbsentWriteParentDirsOnRollback(context, dirsDeepestFirst)
     );
   }
 }
-async function deleteSandboxFile(context, path3) {
-  const result = await context.sandbox.exec(`rm -f ${shellQuote(path3)}`, { raiseOnError: false });
+async function deleteSandboxFile(context, path4) {
+  const result = await context.sandbox.exec(`rm -f ${shellQuote(path4)}`, { raiseOnError: false });
   if (result.exitCode !== 0) {
     const detail = typeof result.error === "string" && result.error.trim() || result.output.trim() || `exit ${result.exitCode}`;
     throw new Error(
-      `[ModuleRail] composition artifacts: failed to delete ${redactSecrets(path3)}: ${redactSecrets(detail)}`
+      `[ModuleRail] composition artifacts: failed to delete ${redactSecrets(path4)}: ${redactSecrets(detail)}`
     );
   }
 }
@@ -6610,37 +6546,37 @@ async function applyCompositionArtifactMutations(context, plan, existingFiles) {
       await writeSandboxFileAtomic(context, write.path, write.content);
       appliedWrites.push({ path: write.path, previous });
     }
-    for (const path3 of plan.deletes) {
-      const previous = existingFiles[path3];
+    for (const path4 of plan.deletes) {
+      const previous = existingFiles[path4];
       if (previous == null) continue;
-      await deleteSandboxFile(context, path3);
-      appliedDeletes.push({ path: path3, previous });
+      await deleteSandboxFile(context, path4);
+      appliedDeletes.push({ path: path4, previous });
     }
   } catch (error) {
     console.log(
       `[ModuleRail] runId=${context.runId} composition artifacts mid-apply failure; rolling back writes=${appliedWrites.length} deletes=${appliedDeletes.length} newDirs=${newlyCreatedParentDirs.length}`
     );
-    for (const { path: path3, previous } of [...appliedDeletes].reverse()) {
+    for (const { path: path4, previous } of [...appliedDeletes].reverse()) {
       try {
-        await writeSandboxFileAtomic(context, path3, previous);
+        await writeSandboxFileAtomic(context, path4, previous);
       } catch (rollbackError) {
         console.log(
-          `[ModuleRail] runId=${context.runId} composition artifacts rollback restore failed for ${redactSecrets(path3)}: ${redactSecrets(
+          `[ModuleRail] runId=${context.runId} composition artifacts rollback restore failed for ${redactSecrets(path4)}: ${redactSecrets(
             rollbackError instanceof Error ? rollbackError.message : String(rollbackError)
           )}`
         );
       }
     }
-    for (const { path: path3, previous } of [...appliedWrites].reverse()) {
+    for (const { path: path4, previous } of [...appliedWrites].reverse()) {
       try {
         if (previous == null) {
-          await deleteSandboxFile(context, path3);
+          await deleteSandboxFile(context, path4);
         } else {
-          await writeSandboxFileAtomic(context, path3, previous);
+          await writeSandboxFileAtomic(context, path4, previous);
         }
       } catch (rollbackError) {
         console.log(
-          `[ModuleRail] runId=${context.runId} composition artifacts rollback write failed for ${redactSecrets(path3)}: ${redactSecrets(
+          `[ModuleRail] runId=${context.runId} composition artifacts rollback write failed for ${redactSecrets(path4)}: ${redactSecrets(
             rollbackError instanceof Error ? rollbackError.message : String(rollbackError)
           )}`
         );
@@ -6674,39 +6610,39 @@ async function listExistingGeneratedStubPaths(context) {
     COMPOSITION_ARTIFACT_KIND_PROBE_TOKEN
   );
   const presentPaths = [];
-  for (const path3 of candidates) {
+  for (const path4 of candidates) {
     const presence = assertRealCompositionArtifactFilePresence(
-      path3,
-      kinds.get(path3) ?? "unreadable"
+      path4,
+      kinds.get(path4) ?? "unreadable"
     );
-    if (presence === "file") presentPaths.push(path3);
+    if (presence === "file") presentPaths.push(path4);
   }
   let contents;
   try {
     contents = await readFilesMany(context, presentPaths);
   } catch (error) {
-    const path3 = readFailurePath(error);
+    const path4 = readFailurePath(error);
     throw new Error(
-      `[ModuleRail] composition artifacts: cannot read candidate stub ${redactSecrets(path3)}: ${redactSecrets(
+      `[ModuleRail] composition artifacts: cannot read candidate stub ${redactSecrets(path4)}: ${redactSecrets(
         error instanceof Error ? error.message : String(error)
       )}`
     );
   }
   const owned = [];
-  for (const path3 of presentPaths) {
-    const content = contents.get(path3);
+  for (const path4 of presentPaths) {
+    const content = contents.get(path4);
     const marker = parseCompositionArtifactMarker(content);
-    if (parseLegacyApiAdapter(path3, content) || parseLegacyRouteAdapter(path3, content)) {
-      owned.push(path3);
+    if (parseLegacyApiAdapter(path4, content) || parseLegacyRouteAdapter(path4, content)) {
+      owned.push(path4);
       continue;
     }
     if (marker == null) continue;
-    if (!markerCongruentWithPath(path3, marker)) {
+    if (!markerCongruentWithPath(path4, marker)) {
       throw new Error(
-        `[ModuleRail] composition artifacts: incongruent marker at ${redactSecrets(path3)} (found ${marker.kind} marker on a path shaped for ${expectedMarkerKindForPath(path3) ?? "no"} artifacts; refusing to reconcile a swapped marker)`
+        `[ModuleRail] composition artifacts: incongruent marker at ${redactSecrets(path4)} (found ${marker.kind} marker on a path shaped for ${expectedMarkerKindForPath(path4) ?? "no"} artifacts; refusing to reconcile a swapped marker)`
       );
     }
-    owned.push(path3);
+    owned.push(path4);
   }
   return owned;
 }
@@ -6839,7 +6775,7 @@ async function classifySandboxPathPresenceKindMany(context, paths, probeToken) {
       { raiseOnError: false }
     );
     if (result.exitCode !== 0) {
-      for (const path3 of chunk) kinds.set(path3, "unreadable");
+      for (const path4 of chunk) kinds.set(path4, "unreadable");
       continue;
     }
     const lines = result.output.split("\n").filter(Boolean);
@@ -6850,31 +6786,31 @@ async function classifySandboxPathPresenceKindMany(context, paths, probeToken) {
       }
     } else {
       for (const line of lines) {
-        const [rawKind, path3] = line.split("	", 2);
+        const [rawKind, path4] = line.split("	", 2);
         const kind = rawKind?.replace(/^entry-kind:/, "");
-        if (path3 && chunk.includes(path3) && CONVENTIONAL_ENTRY_PRESENCE_KINDS.includes(kind ?? "")) {
-          kinds.set(path3, kind);
+        if (path4 && chunk.includes(path4) && CONVENTIONAL_ENTRY_PRESENCE_KINDS.includes(kind ?? "")) {
+          kinds.set(path4, kind);
         }
       }
     }
-    for (const path3 of chunk) {
-      if (!kinds.has(path3)) kinds.set(path3, "unreadable");
+    for (const path4 of chunk) {
+      if (!kinds.has(path4)) kinds.set(path4, "unreadable");
     }
   }
   return kinds;
 }
-async function classifySandboxPathPresenceKind(context, path3, probeToken) {
-  return (await classifySandboxPathPresenceKindMany(context, [path3], probeToken)).get(path3);
+async function classifySandboxPathPresenceKind(context, path4, probeToken) {
+  return (await classifySandboxPathPresenceKindMany(context, [path4], probeToken)).get(path4);
 }
 var LOCALE_JSON_KIND_PROBE_TOKEN = "locale-json-kind";
-function assertRealLocaleJsonFilePresence(path3, presence) {
+function assertRealLocaleJsonFilePresence(path4, presence) {
   if (presence === "file") return;
   if (presence === "absent") {
-    throw new Error(`[ModuleRail] composition artifacts: locale file missing at ${path3}`);
+    throw new Error(`[ModuleRail] composition artifacts: locale file missing at ${path4}`);
   }
-  const presenceError = formatConventionalEntryPresenceError(path3, presence);
+  const presenceError = formatConventionalEntryPresenceError(path4, presence);
   throw new Error(
-    `[ModuleRail] composition artifacts: ${presenceError ?? `${path3} is not a real locale JSON file`}`
+    `[ModuleRail] composition artifacts: ${presenceError ?? `${path4} is not a real locale JSON file`}`
   );
 }
 function splitTaggedLine(line) {
@@ -6949,11 +6885,11 @@ async function listLocaleBasenamesIfDirMany(context, dirs) {
 }
 async function readFilesMany(context, paths) {
   const sortedPaths = [...paths].sort((a, b) => a.localeCompare(b));
-  const settled = await mapConcurrent(sortedPaths, SANDBOX_READ_CONCURRENCY, async (path3) => {
+  const settled = await mapConcurrent(sortedPaths, SANDBOX_READ_CONCURRENCY, async (path4) => {
     try {
-      return { path: path3, value: await context.sandbox.readFile(path3) };
+      return { path: path4, value: await context.sandbox.readFile(path4) };
     } catch (error) {
-      return { path: path3, error };
+      return { path: path4, error };
     }
   });
   const files = /* @__PURE__ */ new Map();
@@ -6976,58 +6912,58 @@ function readFailurePath(error) {
 var CONVENTIONAL_ENTRY_KIND_PROBE_TOKEN = "conventional-entry-kind";
 var SERVER_REGISTRATIONS_FILE = "server/registrations.ts";
 var COMPOSITION_ARTIFACT_KIND_PROBE_TOKEN = "composition-artifact-kind";
-async function classifyCompositionArtifactPathKind(context, path3) {
-  return classifySandboxPathPresenceKind(context, path3, COMPOSITION_ARTIFACT_KIND_PROBE_TOKEN);
+async function classifyCompositionArtifactPathKind(context, path4) {
+  return classifySandboxPathPresenceKind(context, path4, COMPOSITION_ARTIFACT_KIND_PROBE_TOKEN);
 }
-function assertRealCompositionArtifactFilePresence(path3, presence) {
+function assertRealCompositionArtifactFilePresence(path4, presence) {
   if (presence === "file") return "file";
   if (presence === "absent") return "absent";
-  const presenceError = formatConventionalEntryPresenceError(path3, presence);
+  const presenceError = formatConventionalEntryPresenceError(path4, presence);
   throw new Error(
-    `[ModuleRail] composition artifacts: ${presenceError ?? `${path3} is not a real composition artifact file`}`
+    `[ModuleRail] composition artifacts: ${presenceError ?? `${path4} is not a real composition artifact file`}`
   );
 }
-async function readConventionalEntryIfRealFile(path3, kind, presences, files) {
-  const presence = presences.get(path3) ?? "unreadable";
-  const presenceError = formatConventionalEntryPresenceError(path3, presence);
+async function readConventionalEntryIfRealFile(path4, kind, presences, files) {
+  const presence = presences.get(path4) ?? "unreadable";
+  const presenceError = formatConventionalEntryPresenceError(path4, presence);
   if (presenceError) {
     throw new Error(`[ModuleRail] composition artifacts: ${presenceError}`);
   }
   if (presence === "absent") {
     return null;
   }
-  const source = files.get(path3);
+  const source = files.get(path4);
   switch (kind) {
     case "contributions":
-      assertContributionsExport(source, path3);
-      assertClientSafeConventionalEntryImports(source, path3, "contributions");
+      assertContributionsExport(source, path4);
+      assertClientSafeConventionalEntryImports(source, path4, "contributions");
       break;
     case "slotCatalogs":
-      assertSlotCatalogsExport(source, path3);
-      assertClientSafeConventionalEntryImports(source, path3, "slotCatalogs");
+      assertSlotCatalogsExport(source, path4);
+      assertClientSafeConventionalEntryImports(source, path4, "slotCatalogs");
       break;
     case "initializeEnhancement":
-      assertInitializeEnhancementExport(source, path3);
+      assertInitializeEnhancementExport(source, path4);
       break;
   }
   return source;
 }
 function hasRealServerRegistrations(modulePath, presences) {
-  const path3 = `${modulePath}/${SERVER_REGISTRATIONS_FILE}`;
-  return assertRealCompositionArtifactFilePresence(path3, presences.get(path3) ?? "unreadable") === "file";
+  const path4 = `${modulePath}/${SERVER_REGISTRATIONS_FILE}`;
+  return assertRealCompositionArtifactFilePresence(path4, presences.get(path4) ?? "unreadable") === "file";
 }
-async function readJsonObjectFile(path3, files) {
-  const raw = files.get(path3);
+async function readJsonObjectFile(path4, files) {
+  const raw = files.get(path4);
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (error) {
     throw new Error(
-      `[ModuleRail] composition artifacts: invalid JSON at ${path3}: ${error instanceof Error ? error.message : String(error)}`
+      `[ModuleRail] composition artifacts: invalid JSON at ${path4}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   if (parsed === null || Array.isArray(parsed) || typeof parsed !== "object") {
-    throw new Error(`[ModuleRail] composition artifacts: ${path3} root must be an object`);
+    throw new Error(`[ModuleRail] composition artifacts: ${path4} root must be an object`);
   }
   return parsed;
 }
@@ -7076,11 +7012,11 @@ async function collectCompositionEntryFacts(context, registry) {
     classifySandboxPathPresenceKindMany(context, localePaths, LOCALE_JSON_KIND_PROBE_TOKEN)
   ]);
   const presentConventionalPaths = [];
-  for (const path3 of conventionalPaths) {
-    const presence = conventionalPresences.get(path3) ?? "unreadable";
-    if (presence === "file") presentConventionalPaths.push(path3);
+  for (const path4 of conventionalPaths) {
+    const presence = conventionalPresences.get(path4) ?? "unreadable";
+    if (presence === "file") presentConventionalPaths.push(path4);
   }
-  const presentLocalePaths = localePaths.filter((path3) => localePresences.get(path3) === "file");
+  const presentLocalePaths = localePaths.filter((path4) => localePresences.get(path4) === "file");
   const files = await readFilesMany(context, [...presentConventionalPaths, ...presentLocalePaths]);
   const substrateLocales = [];
   for (const locale of substrateNames) {
@@ -7178,8 +7114,8 @@ async function collectCompositionEntryFacts(context, registry) {
     });
     if (rootLocales.length > 0) {
       for (const locale of rootLocales) {
-        const path3 = `${modulePath}/i18n/${locale}.json`;
-        assertRealLocaleJsonFilePresence(path3, localePresences.get(path3) ?? "unreadable");
+        const path4 = `${modulePath}/i18n/${locale}.json`;
+        assertRealLocaleJsonFilePresence(path4, localePresences.get(path4) ?? "unreadable");
       }
       const enMessages = await readJsonObjectFile(`${modulePath}/i18n/en.json`, files);
       const localeMessages = { en: enMessages };
@@ -7203,8 +7139,8 @@ async function collectCompositionEntryFacts(context, registry) {
       if (!enh.active || enh.locales.length === 0) continue;
       const peerDir = `${modulePath}/enhancements/${enh.peer}`;
       for (const locale of enh.locales) {
-        const path3 = `${peerDir}/i18n/${locale}.json`;
-        assertRealLocaleJsonFilePresence(path3, localePresences.get(path3) ?? "unreadable");
+        const path4 = `${peerDir}/i18n/${locale}.json`;
+        assertRealLocaleJsonFilePresence(path4, localePresences.get(path4) ?? "unreadable");
       }
       const enMessages = await readJsonObjectFile(`${peerDir}/i18n/en.json`, files);
       const localeMessages = { en: enMessages };
@@ -7405,16 +7341,16 @@ async function reconcileCompositionArtifacts(context, options = {}) {
   for (const stub of probePlan.plan.routeStubs) candidatePaths.add(stub.path);
   const existingFiles = {};
   const remainingCandidatePaths = [];
-  for (const path3 of [...candidatePaths].sort((a, b) => a.localeCompare(b))) {
-    if (Object.prototype.hasOwnProperty.call(existingAppPages, path3)) {
-      existingFiles[path3] = existingAppPages[path3];
+  for (const path4 of [...candidatePaths].sort((a, b) => a.localeCompare(b))) {
+    if (Object.prototype.hasOwnProperty.call(existingAppPages, path4)) {
+      existingFiles[path4] = existingAppPages[path4];
       continue;
     }
-    if (Object.prototype.hasOwnProperty.call(existingAppRoutes, path3)) {
-      existingFiles[path3] = existingAppRoutes[path3];
+    if (Object.prototype.hasOwnProperty.call(existingAppRoutes, path4)) {
+      existingFiles[path4] = existingAppRoutes[path4];
       continue;
     }
-    remainingCandidatePaths.push(path3);
+    remainingCandidatePaths.push(path4);
   }
   const candidateKinds = await classifySandboxPathPresenceKindMany(
     context,
@@ -7422,12 +7358,12 @@ async function reconcileCompositionArtifacts(context, options = {}) {
     COMPOSITION_ARTIFACT_KIND_PROBE_TOKEN
   );
   const presentCandidatePaths = [];
-  for (const path3 of remainingCandidatePaths) {
+  for (const path4 of remainingCandidatePaths) {
     const presence = assertRealCompositionArtifactFilePresence(
-      path3,
-      candidateKinds.get(path3) ?? "unreadable"
+      path4,
+      candidateKinds.get(path4) ?? "unreadable"
     );
-    if (presence === "file") presentCandidatePaths.push(path3);
+    if (presence === "file") presentCandidatePaths.push(path4);
   }
   try {
     Object.assign(
@@ -7435,9 +7371,9 @@ async function reconcileCompositionArtifacts(context, options = {}) {
       Object.fromEntries(await readFilesMany(context, presentCandidatePaths))
     );
   } catch (error) {
-    const path3 = readFailurePath(error);
+    const path4 = readFailurePath(error);
     throw new Error(
-      `[ModuleRail] composition artifacts: cannot read ${redactSecrets(path3)} during preflight: ${redactSecrets(
+      `[ModuleRail] composition artifacts: cannot read ${redactSecrets(path4)} during preflight: ${redactSecrets(
         error instanceof Error ? error.message : String(error)
       )}`
     );
@@ -7506,14 +7442,142 @@ async function reconcileCompositionArtifacts(context, options = {}) {
 var HOME_I18N_SUBSTRATE_DIR = `${APP_PACKAGE_DIR}/src/lib/i18n/substrate`;
 var HOME_I18N_MESSAGES_DIR = `${APP_PACKAGE_DIR}/src/lib/i18n/messages`;
 
+// src/index.ts
+var import_typescript6 = __toESM(require("typescript"));
+
+// src/module-boundaries.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_typescript5 = __toESM(require("typescript"));
+var SOURCE_FILE = /\.[cm]?[jt]sx?$/;
+var RESOLVE_SUFFIXES = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+var DATA_FILE = /\.(?:sql|json)$/;
+function dataPathsIn(fileName, source) {
+  if (!/\.(?:sql|json)["'`]/.test(source)) return [];
+  const paths = [];
+  const visit = (node) => {
+    if ((import_typescript5.default.isStringLiteralLike(node) || import_typescript5.default.isTemplateTail(node)) && DATA_FILE.test(node.text)) {
+      paths.push(node.text);
+    }
+    import_typescript5.default.forEachChild(node, visit);
+  };
+  visit(import_typescript5.default.createSourceFile(fileName, source, import_typescript5.default.ScriptTarget.Latest, false));
+  return paths;
+}
+function scanModule(modulesDir, module2) {
+  const scanned = /* @__PURE__ */ new Map();
+  const moduleDir = import_node_path2.default.join(modulesDir, module2);
+  if (!import_node_fs2.default.existsSync(moduleDir)) return scanned;
+  const files = import_node_fs2.default.readdirSync(moduleDir, { recursive: true, encoding: "utf8" }).filter((relative) => SOURCE_FILE.test(relative) && !relative.includes("node_modules"));
+  for (const relative of files) {
+    const absolute = import_node_path2.default.join(moduleDir, relative);
+    if (!import_node_fs2.default.statSync(absolute).isFile()) continue;
+    const source = import_node_fs2.default.readFileSync(absolute, "utf8");
+    const specifiers = import_typescript5.default.preProcessFile(source, true, true).importedFiles.map((f) => f.fileName);
+    const dataPaths = dataPathsIn(absolute, source);
+    const targets = [...specifiers, ...dataPaths].flatMap((spec) => {
+      if (spec.startsWith("@/modules/"))
+        return [import_node_path2.default.join(modulesDir, spec.slice("@/modules/".length))];
+      if (spec.startsWith("./") || spec.startsWith("../")) {
+        return [import_node_path2.default.resolve(import_node_path2.default.dirname(absolute), spec)];
+      }
+      return [];
+    });
+    scanned.set(absolute, {
+      module: module2,
+      relative: relative.split(import_node_path2.default.sep).join("/"),
+      targets,
+      dataPaths
+    });
+  }
+  return scanned;
+}
+function findModuleBoundaryViolations(modulesDir, peersByModule, { pruning = false } = {}) {
+  const files = /* @__PURE__ */ new Map();
+  for (const [module2, peers] of Object.entries(peersByModule)) {
+    if (peers.length === 0) continue;
+    for (const [absolute, file] of scanModule(modulesDir, module2)) files.set(absolute, file);
+  }
+  const exempt = (file, peer) => (pruning ? peersByModule[file.module] ?? [] : [peer]).some(
+    (q) => file.relative.startsWith(`enhancements/${q}/`)
+  );
+  const goneWith = (target, peer) => {
+    const relative = import_node_path2.default.relative(modulesDir, target).split(import_node_path2.default.sep).join("/");
+    return relative === peer || relative.startsWith(`${peer}/`) || new RegExp(`^[^/]+/enhancements/${peer}(/|$)`).test(relative);
+  };
+  const tainted = /* @__PURE__ */ new Map();
+  const queue = [];
+  const taint = (absolute, peer) => {
+    const peers = tainted.get(absolute) ?? /* @__PURE__ */ new Set();
+    if (peers.has(peer)) return;
+    peers.add(peer);
+    tainted.set(absolute, peers);
+    queue.push([absolute, peer]);
+  };
+  const importers = /* @__PURE__ */ new Map();
+  for (const [absolute, file] of files) {
+    for (const target of file.targets) {
+      const hit = RESOLVE_SUFFIXES.map((suffix) => target + suffix).find((c) => files.has(c));
+      if (hit) importers.set(hit, [...importers.get(hit) ?? [], absolute]);
+    }
+    for (const peer of peersByModule[file.module] ?? []) {
+      if (exempt(file, peer)) continue;
+      if (file.targets.some((target) => goneWith(target, peer)) || file.dataPaths.some(
+        (p) => p.startsWith(`modules/${peer}/`) || p.includes(`/modules/${peer}/`)
+      )) {
+        taint(absolute, peer);
+      }
+    }
+  }
+  for (let next = queue.shift(); next; next = queue.shift()) {
+    const [target, peer] = next;
+    for (const importer of importers.get(target) ?? []) {
+      const file = files.get(importer);
+      if ((peersByModule[file.module] ?? []).includes(peer) && !exempt(file, peer)) {
+        taint(importer, peer);
+      }
+    }
+  }
+  const violations = [];
+  for (const [absolute, peers] of tainted) {
+    const file = files.get(absolute);
+    for (const peer of peers) {
+      violations.push({ file: `${file.module}/${file.relative}`, module: file.module, peer });
+    }
+  }
+  return violations.sort((a, b) => a.file.localeCompare(b.file) || a.peer.localeCompare(b.peer));
+}
+function findOptionalPeerViolations(modulesDir) {
+  if (!import_node_fs2.default.existsSync(modulesDir)) return [];
+  const manifests = {};
+  for (const name of import_node_fs2.default.readdirSync(modulesDir)) {
+    const manifestPath = import_node_path2.default.join(modulesDir, name, "module.json");
+    if (!import_node_fs2.default.existsSync(manifestPath)) continue;
+    manifests[name] = JSON.parse(import_node_fs2.default.readFileSync(manifestPath, "utf8"));
+  }
+  const features = Object.keys(manifests).filter((name) => manifests[name].kind === "feature");
+  const peersByModule = {};
+  for (const [name, manifest] of Object.entries(manifests)) {
+    const uses = new Set(manifest.uses ?? []);
+    peersByModule[name] = features.filter((peer) => peer !== name && !uses.has(peer));
+  }
+  return findModuleBoundaryViolations(modulesDir, peersByModule);
+}
+function formatBoundaryViolations(modulesDirLabel, violations) {
+  const files = new Set(violations.map((v) => v.file)).size;
+  return `${files} Module file(s) import a peer Module that may be absent (not in the Module's \`uses\`, or excluded by --enabled).
+\`next build\` type-checks them after the peer is gone. For each line, move the file into ${modulesDirLabel}/<module>/enhancements/<peer>/ or declare <peer> in the module's module.json \`uses\` (and enable it).
+` + violations.map((v) => `${modulesDirLabel}/${v.file}: ${v.peer}`).join("\n");
+}
+
 // src/index.ts
 var MODULES_DIR2 = MODULES_SANDBOX_DIR;
 function readComposeInputs(cwd) {
-  const file = import_node_path2.default.join(cwd, COMPOSE_INPUTS_PATH);
-  if (!import_node_fs2.default.existsSync(file)) return { connectedStores: [], installs: {} };
+  const file = import_node_path3.default.join(cwd, COMPOSE_INPUTS_PATH);
+  if (!import_node_fs3.default.existsSync(file)) return { connectedStores: [], installs: {} };
   let raw;
   try {
-    raw = JSON.parse(import_node_fs2.default.readFileSync(file, "utf8"));
+    raw = JSON.parse(import_node_fs3.default.readFileSync(file, "utf8"));
   } catch (error) {
     throw new Error(
       `[compose] ${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
@@ -7555,18 +7619,18 @@ function stubGitignoreEntries(artifactPaths) {
 function writeStubGitignore(cwd, artifactPaths) {
   const entries = stubGitignoreEntries(artifactPaths);
   const content = [STUB_GITIGNORE_HEADER, ...entries].join("\n") + "\n";
-  const file = import_node_path2.default.join(cwd, STUB_GITIGNORE_PATH);
-  const existing = import_node_fs2.default.existsSync(file) ? import_node_fs2.default.readFileSync(file, "utf8") : null;
+  const file = import_node_path3.default.join(cwd, STUB_GITIGNORE_PATH);
+  const existing = import_node_fs3.default.existsSync(file) ? import_node_fs3.default.readFileSync(file, "utf8") : null;
   if (existing !== content) {
-    import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
-    import_node_fs2.default.writeFileSync(file, content);
+    import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+    import_node_fs3.default.writeFileSync(file, content);
   }
   return entries.length;
 }
 function assertStubGitignoreOwned(cwd) {
-  const file = import_node_path2.default.join(cwd, STUB_GITIGNORE_PATH);
-  if (!import_node_fs2.default.existsSync(file)) return;
-  const firstLine = import_node_fs2.default.readFileSync(file, "utf8").split("\n", 1)[0] ?? "";
+  const file = import_node_path3.default.join(cwd, STUB_GITIGNORE_PATH);
+  if (!import_node_fs3.default.existsSync(file)) return;
+  const firstLine = import_node_fs3.default.readFileSync(file, "utf8").split("\n", 1)[0] ?? "";
   if (firstLine !== STUB_GITIGNORE_HEADER) {
     throw new Error(
       `[compose] refusing to overwrite ${STUB_GITIGNORE_PATH}: it is not compose-generated (line 1 is not the generated header)`
@@ -7574,8 +7638,8 @@ function assertStubGitignoreOwned(cwd) {
   }
 }
 function assertAppRoot(cwd) {
-  const appPath = import_node_path2.default.join(cwd, APP_PACKAGE_JSON);
-  if (!import_node_fs2.default.existsSync(appPath)) {
+  const appPath = import_node_path3.default.join(cwd, APP_PACKAGE_JSON);
+  if (!import_node_fs3.default.existsSync(appPath)) {
     throw new Error(
       `[compose] ${appPath} not found \u2014 run this from the repo root of a Stardeck app`
     );
@@ -7621,9 +7685,9 @@ ${porcelain.trim()}`
 }
 var APP_SRC_DIR = "apps/web/src";
 function walkSources(dir, skip, out) {
-  if (!import_node_fs2.default.existsSync(dir)) return;
-  for (const entry of import_node_fs2.default.readdirSync(dir, { withFileTypes: true })) {
-    const full = import_node_path2.default.join(dir, entry.name);
+  if (!import_node_fs3.default.existsSync(dir)) return;
+  for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+    const full = import_node_path3.default.join(dir, entry.name);
     if (full === skip) continue;
     if (entry.isDirectory()) walkSources(full, skip, out);
     else if (/\.[cm]?[jt]sx?$/.test(entry.name)) out.push(full);
@@ -7632,13 +7696,13 @@ function walkSources(dir, skip, out) {
 function assertNoAppLayerImporters(cwd, excluded) {
   if (excluded.length === 0) return;
   const files = [];
-  walkSources(import_node_path2.default.join(cwd, APP_SRC_DIR), import_node_path2.default.join(cwd, MODULES_DIR2), files);
+  walkSources(import_node_path3.default.join(cwd, APP_SRC_DIR), import_node_path3.default.join(cwd, MODULES_DIR2), files);
   const offenders = [];
   for (const file of files) {
-    const source = import_node_fs2.default.readFileSync(file, "utf8");
+    const source = import_node_fs3.default.readFileSync(file, "utf8");
     for (const name of excluded) {
       if (new RegExp(`@/modules/${name}(?=["'\`/])`).test(source)) {
-        offenders.push(`${import_node_path2.default.relative(cwd, file)}: ${name}`);
+        offenders.push(`${import_node_path3.default.relative(cwd, file)}: ${name}`);
       }
     }
   }
@@ -7650,9 +7714,44 @@ function assertNoAppLayerImporters(cwd, excluded) {
     );
   }
 }
+var TSCONFIG_PATH = "apps/web/tsconfig.json";
+var BUILD_TSCONFIG_PATH = "apps/web/tsconfig.build.gen.json";
+var BUILD_TSCONFIG_HEADER = "// Generated by stardeck-compose \u2014 the tsconfig `next build` type-checks. Do not edit or commit.";
+function writeBuildTsconfig(cwd, excluded) {
+  const baseFile = import_node_path3.default.join(cwd, TSCONFIG_PATH);
+  if (!import_node_fs3.default.existsSync(import_node_path3.default.join(cwd, MODULES_DIR2)) || !import_node_fs3.default.existsSync(baseFile)) return;
+  const base = import_typescript6.default.readConfigFile(baseFile, import_typescript6.default.sys.readFile);
+  if (base.error) {
+    throw new Error(
+      `[compose] cannot read ${TSCONFIG_PATH}: ${import_typescript6.default.flattenDiagnosticMessageText(base.error.messageText, "\n")}`
+    );
+  }
+  const baseExclude = base.config?.exclude ?? ["node_modules"];
+  const modulesDir = import_node_path3.default.posix.relative("apps/web", MODULES_DIR2);
+  const config = {
+    extends: "./tsconfig.json",
+    exclude: [
+      ...baseExclude,
+      ...excluded.flatMap((name) => [
+        `${modulesDir}/${name}`,
+        `${modulesDir}/*/enhancements/${name}`
+      ])
+    ]
+  };
+  const content = `${BUILD_TSCONFIG_HEADER}
+${JSON.stringify(config, null, 2)}
+`;
+  const file = import_node_path3.default.join(cwd, BUILD_TSCONFIG_PATH);
+  if (!import_node_fs3.default.existsSync(file) || import_node_fs3.default.readFileSync(file, "utf8") !== content) {
+    import_node_fs3.default.writeFileSync(file, content);
+  }
+  console.log(
+    `[compose] ${BUILD_TSCONFIG_PATH} excludes ${excluded.length} Module(s): ${excluded.join(",") || "none"}`
+  );
+}
 function removeDir(absolute) {
-  if (!import_node_fs2.default.existsSync(absolute)) return false;
-  import_node_fs2.default.rmSync(absolute, { recursive: true, force: true });
+  if (!import_node_fs3.default.existsSync(absolute)) return false;
+  import_node_fs3.default.rmSync(absolute, { recursive: true, force: true });
   return true;
 }
 async function compose(options) {
@@ -7679,6 +7778,16 @@ async function compose(options) {
       dryRun: true
     });
     assertNoAppLayerImporters(options.cwd, preview.excludedModules);
+    const violations = findModuleBoundaryViolations(
+      import_node_path3.default.join(options.cwd, MODULES_DIR2),
+      Object.fromEntries(preview.composedModules.map((name) => [name, preview.excludedModules])),
+      { pruning: true }
+    );
+    if (violations.length > 0) {
+      throw new Error(
+        `[compose] refusing --prune: ${formatBoundaryViolations(MODULES_DIR2, violations)}`
+      );
+    }
   }
   const result = await reconcileCompositionArtifacts(context, {
     enabledModulesRaw: options.enabled,
@@ -7687,14 +7796,15 @@ async function compose(options) {
     skipComposeInputs: true
   });
   const gitignoreEntries = options.enabled ? null : writeStubGitignore(options.cwd, result.artifactPaths);
+  writeBuildTsconfig(options.cwd, result.excludedModules);
   let pruned = 0;
   if (options.prune) {
     for (const name of result.excludedModules) {
-      if (removeDir(import_node_path2.default.join(options.cwd, MODULES_DIR2, name))) pruned++;
+      if (removeDir(import_node_path3.default.join(options.cwd, MODULES_DIR2, name))) pruned++;
     }
     for (const owner of result.composedModules) {
       for (const peer of result.excludedModules) {
-        if (removeDir(import_node_path2.default.join(options.cwd, MODULES_DIR2, owner, "enhancements", peer))) pruned++;
+        if (removeDir(import_node_path3.default.join(options.cwd, MODULES_DIR2, owner, "enhancements", peer))) pruned++;
       }
     }
   }
@@ -7709,9 +7819,13 @@ async function compose(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BUILD_TSCONFIG_PATH,
   COMPOSE_INPUTS_PATH,
   assertSupportedTypescript,
   compose,
   escapeGitignore,
+  findModuleBoundaryViolations,
+  findOptionalPeerViolations,
+  formatBoundaryViolations,
   readComposeInputs
 });