@stardeck-customer-apps/compose 0.2.0 → 0.3.0

package/SKILL.md

@@ -23,10 +23,13 @@ Compose turns that declaration into the code Next.js actually builds:
 npx stardeck-compose [--enabled=a,b,c] [--prune] [--cwd=<repo root>]
 ```
 
-Run it from the repo root (the directory holding `apps/web`). Today you invoke
-it manually — `npx stardeck-compose` before `next dev` / `next build` / your
-typecheck — after changing any `module.json`. The `predev` / `prebuild` /
-`pretypecheck` / `pretest` wiring that makes this automatic has not landed yet.
+Run it from the repo root (the directory holding `apps/web`). The Blueprint
+island wires `predev`, `prebuild`, `prebuild:check`, `prelint`, `pretypecheck`
+and `pretest` in `apps/web/package.json` to `stardeck-compose --cwd ../..`, and
+a platform migration adds the same hooks to every app, so every
+`npm run dev|build|lint|typecheck|test` composes first. A repo with no
+`apps/web/src/modules` is a valid app: it composes to empty registries and a
+header-only stub ignore list.
 
 Needs `typescript` >=5 <7 (it parses your route entries with the compiler API).
 
@@ -45,8 +48,9 @@ from `apps/web/stardeck.compose.json` instead:
 }
 ```
 
-The platform writes it at deploy time; write it by hand to compose locally
-against real stores. It is an input, not a result — compose still resolves and
+The platform writes it before every deploy, every dev-server start or restart,
+and every rail reconcile; write it by hand to compose locally against real
+stores. It is an input, not a result — compose still resolves and
 validates the bindings itself. Without the file, `module-datastores.gen.ts`
 composes empty and every registry version reads `unreleased`, so an app with
 bound stores must not compose without it. A malformed file is a hard error, never

package/dist/cli.js

@@ -2069,6 +2069,29 @@ var initialModuleCompositionSchema = import_zod6.z.object({
 });
 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"])
+    })
+  ).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({})
+});
+
 // ../../packages/lib/src/shared/module-enablement.ts
 function isModuleEnabledByList(raw, name, kindOf) {
   if (!raw) return true;
@@ -3559,6 +3582,27 @@ function dirnamePosix(filePath) {
   return idx <= 0 ? "." : filePath.slice(0, idx);
 }
 
+// ../../packages/lib/src/server/module-rail/compose-inputs.ts
+async function buildComposeInputs(input) {
+  const { db, projectId, deps } = input;
+  const connectedStores = await deps.listDatabaseStoresForProject(db, projectId);
+  const installRows = await Promise.all(
+    input.moduleNames.map(async (moduleName) => ({
+      moduleName,
+      install: await deps.getModuleInstall(db, projectId, moduleName)
+    }))
+  );
+  const installs = {};
+  for (const { moduleName, install } of installRows) {
+    if (!install) continue;
+    installs[moduleName] = {
+      installedVersion: install.installedVersion,
+      datastoreBindings: install.datastoreBindings ?? null
+    };
+  }
+  return composeInputsSchema.parse({ connectedStores, installs });
+}
+
 // ../../packages/lib/src/shared/data-store-manifest.ts
 function dataStoreSlug(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
@@ -3755,162 +3799,162 @@ function rejectPseudoModuleEntries(entries, parentDir, label) {
 }
 
 // ../../packages/lib/src/shared/schema-ops.ts
-var import_zod7 = require("zod");
-var columnSpecSchema = import_zod7.z.object({
-  name: import_zod7.z.string().min(1).max(63),
-  pgType: import_zod7.z.string().min(1),
-  nullable: import_zod7.z.boolean(),
+var import_zod8 = require("zod");
+var columnSpecSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1).max(63),
+  pgType: import_zod8.z.string().min(1),
+  nullable: import_zod8.z.boolean(),
   /**
    * A SQL expression used as the column default, as a raw string (e.g. `'t'`,
    * `0`, `now()`, `gen_random_uuid()`). `null` or omitted means no default.
    * NOT a JS literal — must already be a valid SQL expression.
    */
-  default: import_zod7.z.string().nullable().optional(),
-  fieldType: import_zod7.z.string().optional(),
-  fieldConfig: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional()
+  default: import_zod8.z.string().nullable().optional(),
+  fieldType: import_zod8.z.string().optional(),
+  fieldConfig: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional()
 });
-var referentialActionSchema = import_zod7.z.enum([
+var referentialActionSchema = import_zod8.z.enum([
   "cascade",
   "set null",
   "set default",
   "restrict",
   "no action"
 ]);
-var schemaOpSchema = import_zod7.z.discriminatedUnion("type", [
+var schemaOpSchema = import_zod8.z.discriminatedUnion("type", [
   // Tables
-  import_zod7.z.object({
-    type: import_zod7.z.literal("createTable"),
-    table: import_zod7.z.string().min(1).max(63),
-    columns: import_zod7.z.array(columnSpecSchema).min(1),
-    primaryKey: import_zod7.z.array(import_zod7.z.string()).optional(),
-    ifNotExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("createTable"),
+    table: import_zod8.z.string().min(1).max(63),
+    columns: import_zod8.z.array(columnSpecSchema).min(1),
+    primaryKey: import_zod8.z.array(import_zod8.z.string()).optional(),
+    ifNotExists: import_zod8.z.boolean().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("dropTable"),
-    table: import_zod7.z.string().min(1).max(63),
-    cascade: import_zod7.z.boolean().optional(),
-    ifExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("dropTable"),
+    table: import_zod8.z.string().min(1).max(63),
+    cascade: import_zod8.z.boolean().optional(),
+    ifExists: import_zod8.z.boolean().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("renameTable"),
-    from: import_zod7.z.string().min(1).max(63),
-    to: import_zod7.z.string().min(1).max(63)
+  import_zod8.z.object({
+    type: import_zod8.z.literal("renameTable"),
+    from: import_zod8.z.string().min(1).max(63),
+    to: import_zod8.z.string().min(1).max(63)
   }),
   // Columns
-  import_zod7.z.object({
-    type: import_zod7.z.literal("addColumn"),
-    table: import_zod7.z.string().min(1).max(63),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("addColumn"),
+    table: import_zod8.z.string().min(1).max(63),
     column: columnSpecSchema,
-    ifNotExists: import_zod7.z.boolean().optional()
+    ifNotExists: import_zod8.z.boolean().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("dropColumn"),
-    table: import_zod7.z.string().min(1).max(63),
-    column: import_zod7.z.string().min(1).max(63),
-    cascade: import_zod7.z.boolean().optional(),
-    ifExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("dropColumn"),
+    table: import_zod8.z.string().min(1).max(63),
+    column: import_zod8.z.string().min(1).max(63),
+    cascade: import_zod8.z.boolean().optional(),
+    ifExists: import_zod8.z.boolean().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("renameColumn"),
-    table: import_zod7.z.string().min(1).max(63),
-    from: import_zod7.z.string().min(1).max(63),
-    to: import_zod7.z.string().min(1).max(63)
+  import_zod8.z.object({
+    type: import_zod8.z.literal("renameColumn"),
+    table: import_zod8.z.string().min(1).max(63),
+    from: import_zod8.z.string().min(1).max(63),
+    to: import_zod8.z.string().min(1).max(63)
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("alterColumnType"),
-    table: import_zod7.z.string().min(1).max(63),
-    column: import_zod7.z.string().min(1).max(63),
-    newType: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("alterColumnType"),
+    table: import_zod8.z.string().min(1).max(63),
+    column: import_zod8.z.string().min(1).max(63),
+    newType: import_zod8.z.string().min(1),
     /** Optional USING expression for potentially-lossy casts */
-    using: import_zod7.z.string().optional()
+    using: import_zod8.z.string().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("alterColumnNullable"),
-    table: import_zod7.z.string().min(1).max(63),
-    column: import_zod7.z.string().min(1).max(63),
-    nullable: import_zod7.z.boolean()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("alterColumnNullable"),
+    table: import_zod8.z.string().min(1).max(63),
+    column: import_zod8.z.string().min(1).max(63),
+    nullable: import_zod8.z.boolean()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("alterColumnDefault"),
-    table: import_zod7.z.string().min(1).max(63),
-    column: import_zod7.z.string().min(1).max(63),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("alterColumnDefault"),
+    table: import_zod8.z.string().min(1).max(63),
+    column: import_zod8.z.string().min(1).max(63),
     /** null means drop the default; otherwise a SQL expression string. */
-    default: import_zod7.z.string().nullable()
+    default: import_zod8.z.string().nullable()
   }),
   // Indexes
-  import_zod7.z.object({
-    type: import_zod7.z.literal("addIndex"),
-    table: import_zod7.z.string().min(1).max(63),
-    name: import_zod7.z.string().min(1).max(63),
-    columns: import_zod7.z.array(import_zod7.z.string().min(1)).min(1),
-    unique: import_zod7.z.boolean().optional(),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("addIndex"),
+    table: import_zod8.z.string().min(1).max(63),
+    name: import_zod8.z.string().min(1).max(63),
+    columns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
+    unique: import_zod8.z.boolean().optional(),
     /** Partial-index WHERE clause, as a raw SQL expression */
-    where: import_zod7.z.string().optional(),
-    ifNotExists: import_zod7.z.boolean().optional()
+    where: import_zod8.z.string().optional(),
+    ifNotExists: import_zod8.z.boolean().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("dropIndex"),
-    name: import_zod7.z.string().min(1).max(63),
-    cascade: import_zod7.z.boolean().optional(),
-    ifExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("dropIndex"),
+    name: import_zod8.z.string().min(1).max(63),
+    cascade: import_zod8.z.boolean().optional(),
+    ifExists: import_zod8.z.boolean().optional()
   }),
   // Constraints
-  import_zod7.z.object({
-    type: import_zod7.z.literal("addForeignKey"),
-    table: import_zod7.z.string().min(1).max(63),
-    name: import_zod7.z.string().min(1).max(63),
-    columns: import_zod7.z.array(import_zod7.z.string().min(1)).min(1),
-    refTable: import_zod7.z.string().min(1).max(63),
-    refColumns: import_zod7.z.array(import_zod7.z.string().min(1)).min(1),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("addForeignKey"),
+    table: import_zod8.z.string().min(1).max(63),
+    name: import_zod8.z.string().min(1).max(63),
+    columns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
+    refTable: import_zod8.z.string().min(1).max(63),
+    refColumns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
     onDelete: referentialActionSchema.optional(),
     onUpdate: referentialActionSchema.optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("addUniqueConstraint"),
-    table: import_zod7.z.string().min(1).max(63),
-    name: import_zod7.z.string().min(1).max(63),
-    columns: import_zod7.z.array(import_zod7.z.string().min(1)).min(1)
+  import_zod8.z.object({
+    type: import_zod8.z.literal("addUniqueConstraint"),
+    table: import_zod8.z.string().min(1).max(63),
+    name: import_zod8.z.string().min(1).max(63),
+    columns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1)
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("addCheckConstraint"),
-    table: import_zod7.z.string().min(1).max(63),
-    name: import_zod7.z.string().min(1).max(63),
-    expression: import_zod7.z.string().min(1)
+  import_zod8.z.object({
+    type: import_zod8.z.literal("addCheckConstraint"),
+    table: import_zod8.z.string().min(1).max(63),
+    name: import_zod8.z.string().min(1).max(63),
+    expression: import_zod8.z.string().min(1)
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("dropConstraint"),
-    table: import_zod7.z.string().min(1).max(63),
-    name: import_zod7.z.string().min(1).max(63),
-    cascade: import_zod7.z.boolean().optional(),
-    ifExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("dropConstraint"),
+    table: import_zod8.z.string().min(1).max(63),
+    name: import_zod8.z.string().min(1).max(63),
+    cascade: import_zod8.z.boolean().optional(),
+    ifExists: import_zod8.z.boolean().optional()
   }),
   // Enum types
-  import_zod7.z.object({
-    type: import_zod7.z.literal("createEnum"),
-    name: import_zod7.z.string().min(1).max(63),
-    values: import_zod7.z.array(import_zod7.z.string().min(1)).min(1)
+  import_zod8.z.object({
+    type: import_zod8.z.literal("createEnum"),
+    name: import_zod8.z.string().min(1).max(63),
+    values: import_zod8.z.array(import_zod8.z.string().min(1)).min(1)
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("alterEnumAddValue"),
-    name: import_zod7.z.string().min(1).max(63),
-    value: import_zod7.z.string().min(1),
+  import_zod8.z.object({
+    type: import_zod8.z.literal("alterEnumAddValue"),
+    name: import_zod8.z.string().min(1).max(63),
+    value: import_zod8.z.string().min(1),
     /** Position the new value before an existing one (mutually exclusive with `after`) */
-    before: import_zod7.z.string().optional(),
+    before: import_zod8.z.string().optional(),
     /** Position the new value after an existing one (mutually exclusive with `before`) */
-    after: import_zod7.z.string().optional(),
-    ifNotExists: import_zod7.z.boolean().optional()
+    after: import_zod8.z.string().optional(),
+    ifNotExists: import_zod8.z.boolean().optional()
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("dropEnum"),
-    name: import_zod7.z.string().min(1).max(63),
-    cascade: import_zod7.z.boolean().optional(),
-    ifExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("dropEnum"),
+    name: import_zod8.z.string().min(1).max(63),
+    cascade: import_zod8.z.boolean().optional(),
+    ifExists: import_zod8.z.boolean().optional()
   }),
   // Extensions
-  import_zod7.z.object({
-    type: import_zod7.z.literal("createExtension"),
-    name: import_zod7.z.string().min(1),
-    ifNotExists: import_zod7.z.boolean().optional()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("createExtension"),
+    name: import_zod8.z.string().min(1),
+    ifNotExists: import_zod8.z.boolean().optional()
   }),
   // Data operations
   /**
@@ -3918,26 +3962,26 @@ var schemaOpSchema = import_zod7.z.discriminatedUnion("type", [
    * destructive — requires explicit confirm to replay on prod. The
    * `description` is what the agent/user sees at confirm time.
    */
-  import_zod7.z.object({
-    type: import_zod7.z.literal("backfill"),
-    description: import_zod7.z.string().min(1),
-    sql: import_zod7.z.string().min(1)
+  import_zod8.z.object({
+    type: import_zod8.z.literal("backfill"),
+    description: import_zod8.z.string().min(1),
+    sql: import_zod8.z.string().min(1)
   }),
   /**
    * Escape hatch for DDL the structured ops can't express. `destructive`
    * forces classification — use false only for genuinely additive-only SQL
    * (e.g. CREATE EXTENSION variants the structured op doesn't cover).
    */
-  import_zod7.z.object({
-    type: import_zod7.z.literal("rawSql"),
-    description: import_zod7.z.string().min(1),
-    sql: import_zod7.z.string().min(1),
-    destructive: import_zod7.z.boolean()
+  import_zod8.z.object({
+    type: import_zod8.z.literal("rawSql"),
+    description: import_zod8.z.string().min(1),
+    sql: import_zod8.z.string().min(1),
+    destructive: import_zod8.z.boolean()
   })
 ]);
 
 // ../../packages/lib/src/server/module-rail/ops.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // ../../packages/lib/src/server/module-rail/reconcile.ts
 var SANDBOX_BATCH_SIZE = 200;
@@ -3978,8 +4022,8 @@ function countedCompositionContext(context) {
     }
   };
 }
-async function listPresentModuleNames(context) {
-  const entries = await listImmediateEntries(context.sandbox, MODULES_SANDBOX_DIR, {
+async function listPresentModuleNames(sandbox) {
+  const entries = await listImmediateEntries(sandbox, MODULES_SANDBOX_DIR, {
     optional: true,
     label: "modules"
   });
@@ -4183,24 +4227,24 @@ async function discoverModuleRouteEntries(context, moduleName) {
   }
   return pages.sort((a, b) => a.nextRelativePath.localeCompare(b.nextRelativePath));
 }
-async function writeSandboxFileAtomic(context, path3, content) {
+async function writeSandboxFileAtomic(target, path3, content) {
   const dir = dirnamePosix(path3);
-  const tmp = `${path3}.tmp.${context.runId}`;
+  const tmp = `${path3}.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)}`
   ].join(" && ");
-  const result = await context.sandbox.exec(cmd, { raiseOnError: false });
+  const result = await target.sandbox.exec(cmd, { raiseOnError: false });
   if (result.exitCode !== 0) {
-    const cleanup = await context.sandbox.exec(`rm -f ${shellQuote(tmp)}`, {
+    const cleanup = await target.sandbox.exec(`rm -f ${shellQuote(tmp)}`, {
       raiseOnError: false
     });
     if (cleanup.exitCode !== 0) {
       const cleanupDetail = typeof cleanup.error === "string" && cleanup.error.trim() || cleanup.output.trim() || `exit ${cleanup.exitCode}`;
       console.log(
-        `[ModuleRail] runId=${context.runId} composition artifacts failed to clean temp ${redactSecrets(tmp)}: ${redactSecrets(cleanupDetail)}`
+        `[ModuleRail] runId=${target.runId} composition artifacts failed to clean temp ${redactSecrets(tmp)}: ${redactSecrets(cleanupDetail)}`
       );
     }
     const detail = typeof result.error === "string" && result.error.trim() || result.output.trim() || `exit ${result.exitCode}`;
@@ -4258,6 +4302,40 @@ async function deleteSandboxFile(context, path3) {
     );
   }
 }
+async function writeComposeInputs(target) {
+  const ignored = await target.sandbox.exec(
+    `git check-ignore -q ${shellQuote(COMPOSE_INPUTS_PATH)}`,
+    { raiseOnError: false }
+  );
+  if (ignored.exitCode === 1) {
+    console.log(
+      `[ComposeInputs] project=${target.projectId} skipped: ${COMPOSE_INPUTS_PATH} is not ignored in this checkout`
+    );
+    return false;
+  }
+  if (ignored.exitCode !== 0) {
+    const detail = typeof ignored.error === "string" && ignored.error.trim() || ignored.output.trim() || "(no output)";
+    throw new Error(
+      `[ComposeInputs] git check-ignore failed in this checkout (exit ${ignored.exitCode}): ${redactSecrets(detail)}`
+    );
+  }
+  const moduleNames = await listPresentModuleNames(target.sandbox);
+  const inputs = await buildComposeInputs({
+    db: target.db,
+    projectId: target.projectId,
+    deps: target.deps,
+    moduleNames
+  });
+  const content = `${JSON.stringify(inputs, null, 2)}
+`;
+  const existing = await target.sandbox.fileExists(COMPOSE_INPUTS_PATH) ? await target.sandbox.readFile(COMPOSE_INPUTS_PATH) : null;
+  const written = existing === null || existing.trimEnd() !== content.trimEnd();
+  if (written) await writeSandboxFileAtomic(target, COMPOSE_INPUTS_PATH, content);
+  console.log(
+    `[ComposeInputs] project=${target.projectId} stores=${inputs.connectedStores.length} installs=${Object.keys(inputs.installs).length} written=${written}`
+  );
+  return written;
+}
 async function applyCompositionArtifactMutations(context, plan, existingFiles) {
   const appliedWrites = [];
   const appliedDeletes = [];
@@ -4893,7 +4971,7 @@ async function reconcileCompositionArtifacts(context, options = {}) {
   context = counted.context;
   const deps = context.deps;
   if (!deps) throw new Error("Module rail dependencies are required for composition artifacts");
-  const presentRaw = await listPresentModuleNames(context);
+  const presentRaw = await listPresentModuleNames(context.sandbox);
   const presentNames = presentRaw.filter((name) => isValidModuleName(name)).sort((a, b) => a.localeCompare(b));
   const moduleFacts = [];
   const manifestsByName = {};
@@ -5113,6 +5191,15 @@ async function reconcileCompositionArtifacts(context, options = {}) {
   console.log(
     `[ModuleRail] runId=${context.runId} composition artifacts writes=${planned.plan.writes.length} deletes=${planned.plan.deletes.length} modules=${registry.modules.length} excluded=${excludedModules.length} changed=${changed} dryRun=${options.dryRun === true} sandboxExecs=${counted.counts.sandboxExecs} sandboxReads=${counted.counts.sandboxReads}`
   );
+  if (!options.dryRun && !options.skipComposeInputs) {
+    await writeComposeInputs({
+      db: context.db,
+      projectId: context.projectId,
+      runId: context.runId,
+      sandbox: context.sandbox,
+      deps
+    });
+  }
   if (changed && !options.dryRun) {
     await applyCompositionArtifactMutations(context, planned.plan, existingFiles);
   }
@@ -5130,26 +5217,7 @@ 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_zod9 = require("zod");
 var MODULES_DIR2 = MODULES_SANDBOX_DIR;
-var COMPOSE_INPUTS_PATH = "apps/web/stardeck.compose.json";
-var composeInputsSchema = import_zod9.z.strictObject({
-  connectedStores: import_zod9.z.array(
-    import_zod9.z.strictObject({
-      storeId: import_zod9.z.string().min(1),
-      slug: import_zod9.z.string().min(1),
-      bindingKey: import_zod9.z.string().min(1).nullish(),
-      accessLevel: import_zod9.z.enum(["read", "write", "admin"])
-    })
-  ).default([]),
-  installs: import_zod9.z.record(
-    import_zod9.z.string(),
-    import_zod9.z.strictObject({
-      installedVersion: import_zod9.z.string().min(1),
-      datastoreBindings: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).nullish()
-    })
-  ).default({})
-});
 function readComposeInputs(cwd) {
   const file = import_node_path2.default.join(cwd, COMPOSE_INPUTS_PATH);
   if (!import_node_fs2.default.existsSync(file)) return { connectedStores: [], installs: {} };
@@ -5183,6 +5251,7 @@ function assertSupportedTypescript(versionMajorMinor) {
   }
 }
 var APP_DIR_PREFIX2 = "apps/web/src/app/";
+var APP_PACKAGE_JSON = "apps/web/package.json";
 var STUB_GITIGNORE_PATH = "apps/web/src/app/.gitignore";
 var STUB_GITIGNORE_HEADER = "# Generated by stardeck-compose \u2014 Module-rail stubs are build outputs; do not edit or commit them.";
 function escapeGitignore(pattern) {
@@ -5214,10 +5283,10 @@ function assertStubGitignoreOwned(cwd) {
   }
 }
 function assertAppRoot(cwd) {
-  const modulesPath = import_node_path2.default.join(cwd, MODULES_DIR2);
-  if (!import_node_fs2.default.existsSync(modulesPath)) {
+  const appPath = import_node_path2.default.join(cwd, APP_PACKAGE_JSON);
+  if (!import_node_fs2.default.existsSync(appPath)) {
     throw new Error(
-      `[compose] ${modulesPath} not found \u2014 run this from the repo root of a Stardeck app`
+      `[compose] ${appPath} not found \u2014 run this from the repo root of a Stardeck app`
     );
   }
 }
@@ -5321,7 +5390,10 @@ async function compose(options) {
     assertNoAppLayerImporters(options.cwd, preview.excludedModules);
   }
   const result = await reconcileCompositionArtifacts(context, {
-    enabledModulesRaw: options.enabled
+    enabledModulesRaw: options.enabled,
+    // compose is the inputs file's reader: the deps above echo it back, so
+    // letting the rail rewrite it would round-trip a fork's own input.
+    skipComposeInputs: true
   });
   const gitignoreEntries = options.enabled ? null : writeStubGitignore(options.cwd, result.artifactPaths);
   let pruned = 0;

package/dist/index.d.mts

@@ -8,6 +8,37 @@ type ConnectedStore = {
     accessLevel: "read" | "write" | "admin";
 };
 
+/**
+ * Repo-relative inputs file: the platform's two database reads, as JSON.
+ *
+ * `@stardeck-customer-apps/compose` runs inside a customer app with no platform
+ * database, so the two facts the rail reads from one — the data stores connected
+ * to the app and each Module's install row — reach it through this file. The
+ * platform writes it (`writeComposeInputs`), compose reads it
+ * (`readComposeInputs`); the schema below is the single definition both sides
+ * parse against, so a drift on the writing side fails in lib rather than as an
+ * unexplained empty datastore binding inside a fork's build.
+ */
+declare const COMPOSE_INPUTS_PATH = "apps/web/stardeck.compose.json";
+declare const composeInputsSchema: z.ZodObject<{
+    connectedStores: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        storeId: z.ZodString;
+        slug: z.ZodString;
+        bindingKey: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+        accessLevel: z.ZodEnum<{
+            read: "read";
+            write: "write";
+            admin: "admin";
+        }>;
+    }, z.core.$strict>>>;
+    installs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        installedVersion: z.ZodString;
+        datastoreBindings: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+type ComposeInputsFile = z.infer<typeof composeInputsSchema>;
+type ComposeInputsInstall = ComposeInputsFile["installs"][string];
+
 interface ComposeOptions {
     /** Repo root of the customer app (the directory holding `apps/web`). */
     cwd: string;
@@ -30,28 +61,10 @@ interface ComposeResult {
     /** Null when a partial (`--enabled`) compose left the committed list untouched. */
     gitignoreEntries: number | null;
 }
-/** Repo-relative inputs file: the platform's two database reads, as JSON. */
-declare const COMPOSE_INPUTS_PATH = "apps/web/stardeck.compose.json";
-declare const composeInputsSchema: z.ZodObject<{
-    connectedStores: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        storeId: z.ZodString;
-        slug: z.ZodString;
-        bindingKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        accessLevel: z.ZodEnum<{
-            read: "read";
-            write: "write";
-            admin: "admin";
-        }>;
-    }, z.core.$strict>>>;
-    installs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        installedVersion: z.ZodString;
-        datastoreBindings: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-type ComposeInstall = z.infer<typeof composeInputsSchema>["installs"][string];
+
 interface ComposeInputs {
     connectedStores: ConnectedStore[];
-    installs: Record<string, ComposeInstall>;
+    installs: Record<string, ComposeInputsInstall>;
 }
 /**
  * The platform rail resolves data-store bindings and installed versions from