@stardeck-customer-apps/compose 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1886,6 +1886,9 @@ var MODULE_INIT_SERVER_GEN_PATH = `${APP_WEB_PREFIX}src/module-init.server.gen.t
 var MODULES_GEN_PATH = `${APP_WEB_PREFIX}src/modules.gen.ts`;
 var APP_EXTENSIONS_PATH = `${APP_WEB_PREFIX}src/lib/modules/app-extensions.ts`;
 
+// src/cli.ts
+var import_typescript5 = __toESM(require("typescript"));
+
 // src/index.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs2 = __toESM(require("fs"));
@@ -2066,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;
@@ -3546,6 +3572,7 @@ function planCompositionArtifacts(input) {
       endpointStubs: stubs.endpointStubs,
       routeStubs: stubs.routeStubs,
       writes,
+      desiredPaths: [...desired.keys()].sort(compareNames2),
       deletes
     }
   };
@@ -3555,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, "");
@@ -3751,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
   /**
@@ -3914,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;
@@ -3974,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"
   });
@@ -4179,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}`;
@@ -4254,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 = [];
@@ -4889,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 = {};
@@ -5109,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);
   }
@@ -5116,6 +5207,7 @@ async function reconcileCompositionArtifacts(context, options = {}) {
     registryPath: planned.plan.registryPath,
     writePaths: planned.plan.writes.map((w) => w.path),
     deletePaths: planned.plan.deletes,
+    artifactPaths: planned.plan.desiredPaths,
     changed,
     composedModules: composedNames,
     excludedModules
@@ -5126,11 +5218,75 @@ var HOME_I18N_MESSAGES_DIR = `${APP_PACKAGE_DIR}/src/lib/i18n/messages`;
 
 // 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: {} };
+  let raw;
+  try {
+    raw = JSON.parse(import_node_fs2.default.readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `[compose] ${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const parsed = composeInputsSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+    throw new Error(`[compose] ${file} is invalid: ${issues}`);
+  }
+  return {
+    connectedStores: parsed.data.connectedStores.map((store) => ({
+      storeId: store.storeId,
+      slug: store.slug,
+      bindingKey: store.bindingKey ?? null,
+      accessLevel: store.accessLevel
+    })),
+    installs: parsed.data.installs
+  };
+}
+function assertSupportedTypescript(versionMajorMinor) {
+  const major = Number.parseInt(versionMajorMinor.split(".")[0] ?? "", 10);
+  if (!Number.isInteger(major) || major < 5 || major >= 7) {
+    throw new Error(`[compose] typescript ${versionMajorMinor} is not supported (need >=5 <7)`);
+  }
+}
+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) {
+  const escaped = pattern.replace(/[\\[\]*?]/g, (char) => `\\${char}`);
+  return /^[#!]/.test(escaped) ? `\\${escaped}` : escaped;
+}
+function stubGitignoreEntries(artifactPaths) {
+  return artifactPaths.filter((artifact) => artifact.startsWith(APP_DIR_PREFIX2)).map((artifact) => escapeGitignore(`/${artifact.slice(APP_DIR_PREFIX2.length)}`)).sort();
+}
+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;
+  if (existing !== content) {
+    import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+    import_node_fs2.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] ?? "";
+  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)`
+    );
+  }
+}
 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`
     );
   }
 }
@@ -5210,12 +5366,14 @@ function removeDir(absolute) {
 }
 async function compose(options) {
   assertAppRoot(options.cwd);
+  assertStubGitignoreOwned(options.cwd);
+  const inputs = readComposeInputs(options.cwd);
   if (options.prune) assertModuleTreeClean(options.cwd);
   const sandbox = localFsSandbox(options.cwd);
   const deps = {
     sandbox,
-    getModuleInstall: async () => null,
-    listDatabaseStoresForProject: async () => []
+    getModuleInstall: async (_db, _projectId, moduleName) => inputs.installs[moduleName] ?? null,
+    listDatabaseStoresForProject: async () => inputs.connectedStores
   };
   const context = {
     db: {},
@@ -5232,8 +5390,12 @@ 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;
   if (options.prune) {
     for (const name of result.excludedModules) {
@@ -5250,12 +5412,14 @@ async function compose(options) {
     excludedModules: result.excludedModules,
     writes: result.writePaths.length,
     deletes: result.deletePaths.length,
-    pruned
+    pruned,
+    gitignoreEntries
   };
 }
 
 // src/cli.ts
 async function main() {
+  assertSupportedTypescript(import_typescript5.default.versionMajorMinor);
   const { values } = (0, import_node_util.parseArgs)({
     options: {
       enabled: { type: "string" },
@@ -5276,7 +5440,7 @@ async function main() {
     prune: values.prune
   });
   console.log(
-    `[compose] modules=${result.composedModules.join(",") || "none"} excluded=${result.excludedModules.join(",") || "none"} writes=${result.writes} deletes=${result.deletes} pruned=${result.pruned}`
+    `[compose] modules=${result.composedModules.join(",") || "none"} excluded=${result.excludedModules.join(",") || "none"} writes=${result.writes} deletes=${result.deletes} pruned=${result.pruned} gitignore=${result.gitignoreEntries ?? "kept"} stub paths`
   );
 }
 main().catch((error) => {