@stardeck-customer-apps/compose 0.2.0 → 0.4.0

package/dist/index.js

@@ -314,6 +314,14 @@ var datastoreRequirementSchema = import_zod.z.object({
   id: tableNameSchema,
   /** "app" = this project's app-local store; "org" = an org-level shared store. */
   scope: import_zod.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
+   * (file/object storage — uploads, images) only to a storage store; the
+   * 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"),
   /** true → install fails when no store resolves; false → binding omitted, module degrades. */
   required: import_zod.z.boolean().default(true),
   /** Checked against the connected store's accessLevel at install. */
@@ -2067,6 +2075,44 @@ 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"]),
+      // 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;
@@ -3568,6 +3614,33 @@ 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.listConnectedStoresForProject(db, projectId)).filter(
+    (store) => store.type === "database"
+  );
+  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
+    };
+  }
+  const parsed = composeInputsSchema.parse({ connectedStores, installs });
+  return {
+    ...parsed,
+    connectedStores: parsed.connectedStores.map(({ type: _type, ...store }) => store)
+  };
+}
+
 // ../../packages/lib/src/shared/data-store-manifest.ts
 function dataStoreSlug(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
@@ -3591,7 +3664,7 @@ function compareStores(a, b) {
 function describeCandidates(stores) {
   if (stores.length === 0) return "none";
   return stores.map(
-    (store) => `${store.storeId} (slug=${store.slug}, bindingKey=${store.bindingKey ?? "none"}, access=${store.accessLevel})`
+    (store) => `${store.storeId} (type=${store.type}, slug=${store.slug}, bindingKey=${store.bindingKey ?? "none"}, access=${store.accessLevel})`
   ).join(", ");
 }
 function groupStoresById(stores) {
@@ -3622,14 +3695,15 @@ function accessLevelForBinding(group, binding) {
   );
 }
 function resolveModuleDataStoreBindings(input) {
-  const stores = [...input.connectedStores].sort(compareStores);
-  const storeGroups = groupStoresById(stores);
+  const allStores = [...input.connectedStores].sort(compareStores);
   const requirements = [...input.requirements].sort((a, b) => compareStrings(a.id, b.id));
   const overrides = input.explicitOverrides ?? {};
   const bindings = {};
   const errors = [];
-  const candidates = describeCandidates(stores);
   for (const requirement of requirements) {
+    const stores = allStores.filter((store) => store.type === requirement.type);
+    const storeGroups = groupStoresById(stores);
+    const candidates = describeCandidates(allStores);
     const logicalSlug = dataStoreSlug(requirement.id);
     let selected;
     if (Object.prototype.hasOwnProperty.call(overrides, requirement.id)) {
@@ -3642,7 +3716,7 @@ function resolveModuleDataStoreBindings(input) {
           moduleName: input.moduleName,
           logicalId: requirement.id,
           kind: "explicit-override",
-          message: matches.length === 0 ? `Module "${input.moduleName}" data store "${requirement.id}" override "${override}" did not match a connected database store; candidates: ${candidates}` : `Module "${input.moduleName}" data store "${requirement.id}" override "${override}" is ambiguous; matches: ${describeCandidates(matches.flatMap((group) => group.stores))}`
+          message: matches.length === 0 ? `Module "${input.moduleName}" data store "${requirement.id}" override "${override}" did not match a connected ${requirement.type} store; candidates: ${candidates}` : `Module "${input.moduleName}" data store "${requirement.id}" override "${override}" is ambiguous; matches: ${describeCandidates(matches.flatMap((group) => group.stores))}`
         });
         continue;
       }
@@ -3653,6 +3727,8 @@ function resolveModuleDataStoreBindings(input) {
       );
       if (conventionMatches.length === 1) {
         selected = conventionMatches[0];
+      } else if (conventionMatches.length === 0 && requirement.type === "storage") {
+        if (storeGroups.length === 1) selected = storeGroups[0];
       } else if (conventionMatches.length === 0 && requirement.scope === "app") {
         if (storeGroups.length === 1) {
           selected = storeGroups[0];
@@ -3764,162 +3840,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
   /**
@@ -3927,26 +4003,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;
@@ -3987,8 +4063,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"
   });
@@ -4011,7 +4087,7 @@ async function resolveCompositionDataStoreBindings(context, presentNames, manife
   if (modulesWithRequirements.length === 0) return bindingsByModule;
   const deps = context.deps;
   if (!deps) throw new Error("Module rail dependencies are required for data-store bindings");
-  const connectedStores = await deps.listDatabaseStoresForProject(context.db, context.projectId);
+  const connectedStores = await deps.listConnectedStoresForProject(context.db, context.projectId);
   const installs = await Promise.all(
     modulesWithRequirements.map(
       (moduleName) => deps.getModuleInstall(context.db, context.projectId, moduleName)
@@ -4192,24 +4268,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}`;
@@ -4267,6 +4343,55 @@ 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 readStubIgnore(context) {
+  const existing = await context.sandbox.fileExists(STUB_IGNORE_PATH) ? await context.sandbox.readFile(STUB_IGNORE_PATH) : null;
+  if (existing !== null && existing.split("\n", 1)[0] !== STUB_IGNORE_HEADER) {
+    throw new Error(
+      `[ModuleRail] refusing to overwrite ${STUB_IGNORE_PATH}: it is not compose-generated (line 1 is not the generated header)`
+    );
+  }
+  return existing;
+}
+async function writeStubIgnore(context, existing, artifactPaths) {
+  const content = buildStubIgnore(artifactPaths);
+  const written = existing === null || existing.trimEnd() !== content.trimEnd();
+  if (written) await writeSandboxFileAtomic(context, STUB_IGNORE_PATH, content);
+  return written;
+}
 async function applyCompositionArtifactMutations(context, plan, existingFiles) {
   const appliedWrites = [];
   const appliedDeletes = [];
@@ -4902,7 +5027,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 = {};
@@ -5122,9 +5247,26 @@ 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
+    });
+  }
+  const maintainIgnore = !options.dryRun && !options.enabledModulesRaw;
+  const existingIgnore = maintainIgnore ? await readStubIgnore(context) : null;
   if (changed && !options.dryRun) {
     await applyCompositionArtifactMutations(context, planned.plan, existingFiles);
   }
+  if (maintainIgnore) {
+    const wroteIgnore = await writeStubIgnore(context, existingIgnore, planned.plan.desiredPaths);
+    console.log(
+      `[ModuleRail] runId=${context.runId} stub ignore list entries=${planned.plan.desiredPaths.length} written=${wroteIgnore}`
+    );
+  }
   return {
     registryPath: planned.plan.registryPath,
     writePaths: planned.plan.writes.map((w) => w.path),
@@ -5139,26 +5281,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: {} };
@@ -5180,7 +5303,8 @@ function readComposeInputs(cwd) {
       storeId: store.storeId,
       slug: store.slug,
       bindingKey: store.bindingKey ?? null,
-      accessLevel: store.accessLevel
+      accessLevel: store.accessLevel,
+      type: store.type
     })),
     installs: parsed.data.installs
   };
@@ -5192,6 +5316,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) {
@@ -5223,10 +5348,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`
     );
   }
 }
@@ -5313,7 +5438,7 @@ async function compose(options) {
   const deps = {
     sandbox,
     getModuleInstall: async (_db, _projectId, moduleName) => inputs.installs[moduleName] ?? null,
-    listDatabaseStoresForProject: async () => inputs.connectedStores
+    listConnectedStoresForProject: async () => inputs.connectedStores
   };
   const context = {
     db: {},
@@ -5330,7 +5455,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;