@stardeck-customer-apps/compose 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -2029,6 +2029,29 @@ var initialModuleCompositionSchema = z6.object({
 });
 var MODULE_SETUP_ATTEMPT_STALE_MS = 10 * 60 * 1e3;
 
+// ../../packages/lib/src/shared/compose-inputs.ts
+import { z as z7 } from "zod";
+var COMPOSE_INPUTS_PATH = "apps/web/stardeck.compose.json";
+var composeInputsSchema = z7.strictObject({
+  connectedStores: z7.array(
+    z7.strictObject({
+      storeId: z7.string().min(1),
+      slug: z7.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: z7.string().nullish().transform((value) => value || null),
+      accessLevel: z7.enum(["read", "write", "admin"])
+    })
+  ).default([]),
+  installs: z7.record(
+    z7.string(),
+    z7.strictObject({
+      installedVersion: z7.string().min(1),
+      datastoreBindings: z7.record(z7.string(), z7.string()).nullish()
+    })
+  ).default({})
+});
+
 // ../../packages/lib/src/shared/module-enablement.ts
 function isModuleEnabledByList(raw, name, kindOf) {
   if (!raw) return true;
@@ -3520,6 +3543,7 @@ function planCompositionArtifacts(input) {
       endpointStubs: stubs.endpointStubs,
       routeStubs: stubs.routeStubs,
       writes,
+      desiredPaths: [...desired.keys()].sort(compareNames2),
       deletes
     }
   };
@@ -3529,6 +3553,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, "");
@@ -3725,162 +3770,162 @@ function rejectPseudoModuleEntries(entries, parentDir, label) {
 }
 
 // ../../packages/lib/src/shared/schema-ops.ts
-import { z as z7 } from "zod";
-var columnSpecSchema = z7.object({
-  name: z7.string().min(1).max(63),
-  pgType: z7.string().min(1),
-  nullable: z7.boolean(),
+import { z as z8 } from "zod";
+var columnSpecSchema = z8.object({
+  name: z8.string().min(1).max(63),
+  pgType: z8.string().min(1),
+  nullable: z8.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: z7.string().nullable().optional(),
-  fieldType: z7.string().optional(),
-  fieldConfig: z7.record(z7.string(), z7.unknown()).optional()
+  default: z8.string().nullable().optional(),
+  fieldType: z8.string().optional(),
+  fieldConfig: z8.record(z8.string(), z8.unknown()).optional()
 });
-var referentialActionSchema = z7.enum([
+var referentialActionSchema = z8.enum([
   "cascade",
   "set null",
   "set default",
   "restrict",
   "no action"
 ]);
-var schemaOpSchema = z7.discriminatedUnion("type", [
+var schemaOpSchema = z8.discriminatedUnion("type", [
   // Tables
-  z7.object({
-    type: z7.literal("createTable"),
-    table: z7.string().min(1).max(63),
-    columns: z7.array(columnSpecSchema).min(1),
-    primaryKey: z7.array(z7.string()).optional(),
-    ifNotExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("createTable"),
+    table: z8.string().min(1).max(63),
+    columns: z8.array(columnSpecSchema).min(1),
+    primaryKey: z8.array(z8.string()).optional(),
+    ifNotExists: z8.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("dropTable"),
-    table: z7.string().min(1).max(63),
-    cascade: z7.boolean().optional(),
-    ifExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("dropTable"),
+    table: z8.string().min(1).max(63),
+    cascade: z8.boolean().optional(),
+    ifExists: z8.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("renameTable"),
-    from: z7.string().min(1).max(63),
-    to: z7.string().min(1).max(63)
+  z8.object({
+    type: z8.literal("renameTable"),
+    from: z8.string().min(1).max(63),
+    to: z8.string().min(1).max(63)
   }),
   // Columns
-  z7.object({
-    type: z7.literal("addColumn"),
-    table: z7.string().min(1).max(63),
+  z8.object({
+    type: z8.literal("addColumn"),
+    table: z8.string().min(1).max(63),
     column: columnSpecSchema,
-    ifNotExists: z7.boolean().optional()
+    ifNotExists: z8.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("dropColumn"),
-    table: z7.string().min(1).max(63),
-    column: z7.string().min(1).max(63),
-    cascade: z7.boolean().optional(),
-    ifExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("dropColumn"),
+    table: z8.string().min(1).max(63),
+    column: z8.string().min(1).max(63),
+    cascade: z8.boolean().optional(),
+    ifExists: z8.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("renameColumn"),
-    table: z7.string().min(1).max(63),
-    from: z7.string().min(1).max(63),
-    to: z7.string().min(1).max(63)
+  z8.object({
+    type: z8.literal("renameColumn"),
+    table: z8.string().min(1).max(63),
+    from: z8.string().min(1).max(63),
+    to: z8.string().min(1).max(63)
   }),
-  z7.object({
-    type: z7.literal("alterColumnType"),
-    table: z7.string().min(1).max(63),
-    column: z7.string().min(1).max(63),
-    newType: z7.string().min(1),
+  z8.object({
+    type: z8.literal("alterColumnType"),
+    table: z8.string().min(1).max(63),
+    column: z8.string().min(1).max(63),
+    newType: z8.string().min(1),
     /** Optional USING expression for potentially-lossy casts */
-    using: z7.string().optional()
+    using: z8.string().optional()
   }),
-  z7.object({
-    type: z7.literal("alterColumnNullable"),
-    table: z7.string().min(1).max(63),
-    column: z7.string().min(1).max(63),
-    nullable: z7.boolean()
+  z8.object({
+    type: z8.literal("alterColumnNullable"),
+    table: z8.string().min(1).max(63),
+    column: z8.string().min(1).max(63),
+    nullable: z8.boolean()
   }),
-  z7.object({
-    type: z7.literal("alterColumnDefault"),
-    table: z7.string().min(1).max(63),
-    column: z7.string().min(1).max(63),
+  z8.object({
+    type: z8.literal("alterColumnDefault"),
+    table: z8.string().min(1).max(63),
+    column: z8.string().min(1).max(63),
     /** null means drop the default; otherwise a SQL expression string. */
-    default: z7.string().nullable()
+    default: z8.string().nullable()
   }),
   // Indexes
-  z7.object({
-    type: z7.literal("addIndex"),
-    table: z7.string().min(1).max(63),
-    name: z7.string().min(1).max(63),
-    columns: z7.array(z7.string().min(1)).min(1),
-    unique: z7.boolean().optional(),
+  z8.object({
+    type: z8.literal("addIndex"),
+    table: z8.string().min(1).max(63),
+    name: z8.string().min(1).max(63),
+    columns: z8.array(z8.string().min(1)).min(1),
+    unique: z8.boolean().optional(),
     /** Partial-index WHERE clause, as a raw SQL expression */
-    where: z7.string().optional(),
-    ifNotExists: z7.boolean().optional()
+    where: z8.string().optional(),
+    ifNotExists: z8.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("dropIndex"),
-    name: z7.string().min(1).max(63),
-    cascade: z7.boolean().optional(),
-    ifExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("dropIndex"),
+    name: z8.string().min(1).max(63),
+    cascade: z8.boolean().optional(),
+    ifExists: z8.boolean().optional()
   }),
   // Constraints
-  z7.object({
-    type: z7.literal("addForeignKey"),
-    table: z7.string().min(1).max(63),
-    name: z7.string().min(1).max(63),
-    columns: z7.array(z7.string().min(1)).min(1),
-    refTable: z7.string().min(1).max(63),
-    refColumns: z7.array(z7.string().min(1)).min(1),
+  z8.object({
+    type: z8.literal("addForeignKey"),
+    table: z8.string().min(1).max(63),
+    name: z8.string().min(1).max(63),
+    columns: z8.array(z8.string().min(1)).min(1),
+    refTable: z8.string().min(1).max(63),
+    refColumns: z8.array(z8.string().min(1)).min(1),
     onDelete: referentialActionSchema.optional(),
     onUpdate: referentialActionSchema.optional()
   }),
-  z7.object({
-    type: z7.literal("addUniqueConstraint"),
-    table: z7.string().min(1).max(63),
-    name: z7.string().min(1).max(63),
-    columns: z7.array(z7.string().min(1)).min(1)
+  z8.object({
+    type: z8.literal("addUniqueConstraint"),
+    table: z8.string().min(1).max(63),
+    name: z8.string().min(1).max(63),
+    columns: z8.array(z8.string().min(1)).min(1)
   }),
-  z7.object({
-    type: z7.literal("addCheckConstraint"),
-    table: z7.string().min(1).max(63),
-    name: z7.string().min(1).max(63),
-    expression: z7.string().min(1)
+  z8.object({
+    type: z8.literal("addCheckConstraint"),
+    table: z8.string().min(1).max(63),
+    name: z8.string().min(1).max(63),
+    expression: z8.string().min(1)
   }),
-  z7.object({
-    type: z7.literal("dropConstraint"),
-    table: z7.string().min(1).max(63),
-    name: z7.string().min(1).max(63),
-    cascade: z7.boolean().optional(),
-    ifExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("dropConstraint"),
+    table: z8.string().min(1).max(63),
+    name: z8.string().min(1).max(63),
+    cascade: z8.boolean().optional(),
+    ifExists: z8.boolean().optional()
   }),
   // Enum types
-  z7.object({
-    type: z7.literal("createEnum"),
-    name: z7.string().min(1).max(63),
-    values: z7.array(z7.string().min(1)).min(1)
+  z8.object({
+    type: z8.literal("createEnum"),
+    name: z8.string().min(1).max(63),
+    values: z8.array(z8.string().min(1)).min(1)
   }),
-  z7.object({
-    type: z7.literal("alterEnumAddValue"),
-    name: z7.string().min(1).max(63),
-    value: z7.string().min(1),
+  z8.object({
+    type: z8.literal("alterEnumAddValue"),
+    name: z8.string().min(1).max(63),
+    value: z8.string().min(1),
     /** Position the new value before an existing one (mutually exclusive with `after`) */
-    before: z7.string().optional(),
+    before: z8.string().optional(),
     /** Position the new value after an existing one (mutually exclusive with `before`) */
-    after: z7.string().optional(),
-    ifNotExists: z7.boolean().optional()
+    after: z8.string().optional(),
+    ifNotExists: z8.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("dropEnum"),
-    name: z7.string().min(1).max(63),
-    cascade: z7.boolean().optional(),
-    ifExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("dropEnum"),
+    name: z8.string().min(1).max(63),
+    cascade: z8.boolean().optional(),
+    ifExists: z8.boolean().optional()
   }),
   // Extensions
-  z7.object({
-    type: z7.literal("createExtension"),
-    name: z7.string().min(1),
-    ifNotExists: z7.boolean().optional()
+  z8.object({
+    type: z8.literal("createExtension"),
+    name: z8.string().min(1),
+    ifNotExists: z8.boolean().optional()
   }),
   // Data operations
   /**
@@ -3888,26 +3933,26 @@ var schemaOpSchema = z7.discriminatedUnion("type", [
    * destructive — requires explicit confirm to replay on prod. The
    * `description` is what the agent/user sees at confirm time.
    */
-  z7.object({
-    type: z7.literal("backfill"),
-    description: z7.string().min(1),
-    sql: z7.string().min(1)
+  z8.object({
+    type: z8.literal("backfill"),
+    description: z8.string().min(1),
+    sql: z8.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).
    */
-  z7.object({
-    type: z7.literal("rawSql"),
-    description: z7.string().min(1),
-    sql: z7.string().min(1),
-    destructive: z7.boolean()
+  z8.object({
+    type: z8.literal("rawSql"),
+    description: z8.string().min(1),
+    sql: z8.string().min(1),
+    destructive: z8.boolean()
   })
 ]);
 
 // ../../packages/lib/src/server/module-rail/ops.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../packages/lib/src/server/module-rail/reconcile.ts
 var SANDBOX_BATCH_SIZE = 200;
@@ -3948,8 +3993,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"
   });
@@ -4153,24 +4198,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}`;
@@ -4228,6 +4273,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 = [];
@@ -4863,7 +4942,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 = {};
@@ -5083,6 +5162,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);
   }
@@ -5090,6 +5178,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
@@ -5100,11 +5189,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 = path2.join(cwd, COMPOSE_INPUTS_PATH);
+  if (!fs2.existsSync(file)) return { connectedStores: [], installs: {} };
+  let raw;
+  try {
+    raw = JSON.parse(fs2.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 = path2.join(cwd, STUB_GITIGNORE_PATH);
+  const existing = fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : null;
+  if (existing !== content) {
+    fs2.mkdirSync(path2.dirname(file), { recursive: true });
+    fs2.writeFileSync(file, content);
+  }
+  return entries.length;
+}
+function assertStubGitignoreOwned(cwd) {
+  const file = path2.join(cwd, STUB_GITIGNORE_PATH);
+  if (!fs2.existsSync(file)) return;
+  const firstLine = fs2.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 = path2.join(cwd, MODULES_DIR2);
-  if (!fs2.existsSync(modulesPath)) {
+  const appPath = path2.join(cwd, APP_PACKAGE_JSON);
+  if (!fs2.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`
     );
   }
 }
@@ -5184,12 +5337,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: {},
@@ -5206,8 +5361,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) {
@@ -5224,9 +5383,14 @@ async function compose(options) {
     excludedModules: result.excludedModules,
     writes: result.writePaths.length,
     deletes: result.deletePaths.length,
-    pruned
+    pruned,
+    gitignoreEntries
   };
 }
 export {
-  compose
+  COMPOSE_INPUTS_PATH,
+  assertSupportedTypescript,
+  compose,
+  escapeGitignore,
+  readComposeInputs
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stardeck-customer-apps/compose",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Regenerates a Stardeck app's Module-rail artifacts — the five src/*.gen.ts registries and every route/endpoint stub — from src/modules/*/module.json",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -51,7 +51,7 @@
     "zod": "^4.3.5"
   },
   "peerDependencies": {
-    "typescript": ">=5.0.0"
+    "typescript": ">=5.0.0 <7"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",