@prisma-idb/family-idb 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Prisma IDB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# `@prisma-idb/family-idb`
+
+> The [Prisma 8](https://www.prisma.io/blog/prisma-next-call-for-extension-authors) driver + adapter + target stack for IndexedDB — offline-first, no server required.
+
+**family-idb** is the main entry point for the `@prisma-idb` stack. It exposes the control-plane descriptor, the family instance, and the `prisma-idb` CLI for migration authoring and config integration. The former `prisma-idb` command remains an alias.
+
+## Stack
+
+```
+family-idb  ← you are here (CLI / config / entry point)
+client-idb  (ORM query builder)
+runtime-idb (RuntimeCore)
+adapter-idb (query AST → IDB plan)
+driver-idb  (window.indexedDB wrapper)
+target-idb  (identity + migrations)
+```
+
+## Installation
+
+```bash
+npm install @prisma-idb/family-idb
+```
+
+## Documentation
+
+See [prisma-idb.dev](https://prisma-idb.dev/) for full setup and usage docs.
+
+## License
+
+MIT

package/dist/bin/prisma-idb.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/bin/prisma-idb.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { i as runIdbCli } from "../cli-Dlaym_DD.mjs";
+//#region src/bin/prisma-idb.ts
+runIdbCli(process).then((code) => {
+	process.exitCode = code;
+}).catch((err) => {
+	process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=prisma-idb.mjs.map

package/dist/bin/prisma-idb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-idb.mjs","names":[],"sources":["../../src/bin/prisma-idb.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { runIdbCli } from \"../cli/cli\";\n\nrunIdbCli(process)\n  .then((code) => {\n    process.exitCode = code;\n  })\n  .catch((err: unknown) => {\n    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n    process.exitCode = 1;\n  });\n"],"mappings":";;;AAGA,UAAU,OAAO,CAAC,CACf,MAAM,SAAS;CACd,QAAQ,WAAW;AACrB,CAAC,CAAC,CACD,OAAO,QAAiB;CACvB,QAAQ,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,EAAE,GAAG;CAC5E,QAAQ,WAAW;AACrB,CAAC"}

package/dist/chain-order-CaHXo5jz.mjs

@@ -0,0 +1,44 @@
+//#region src/core/chain-order.ts
+/**
+* Walk an unordered set of migration packages by `metadata.from`/`to` edges
+* to produce a chain-ordered list. Starts at the package whose
+* `from === null` (the baseline) and follows each `to` to the next
+* package's matching `from`.
+*
+* Throws on:
+* - No baseline (no package with `from === null`)
+* - Multiple baselines (two packages with `from === null`)
+* - Broken edge (no package whose `from` matches the cursor)
+* - Cycle (revisited hash)
+* - Orphan package (package left unvisited after chain completes)
+*/
+function chainOrderByMetadata(unordered) {
+	if (unordered.size === 0) return [];
+	const byFrom = /* @__PURE__ */ new Map();
+	for (const pkg of unordered.values()) {
+		const from = pkg.metadata.from;
+		const existing = byFrom.get(from);
+		if (existing) throw new Error(`Migration chain conflict: ${existing.dirName} and ${pkg.dirName} both declare from === ${JSON.stringify(from)}. The chain must be linear.`);
+		byFrom.set(from, pkg);
+	}
+	const ordered = [];
+	const visited = /* @__PURE__ */ new Set();
+	let cursor = null;
+	while (true) {
+		const next = byFrom.get(cursor);
+		if (!next) {
+			if (ordered.length === unordered.size) break;
+			const orphans = [...unordered.keys()].filter((d) => !visited.has(d));
+			throw new Error(`Migration chain broken: no package declares from === ${JSON.stringify(cursor)}. Orphan package(s) not reachable from the baseline: ${orphans.join(", ")}. Either the migrations directory has been hand-edited or a package was deleted; re-emit the affected migration with \`node migration.ts\`.`);
+		}
+		if (visited.has(next.dirName)) throw new Error(`Migration chain cycle detected at ${next.dirName}.`);
+		visited.add(next.dirName);
+		ordered.push(next);
+		cursor = next.metadata.to;
+	}
+	return ordered;
+}
+//#endregion
+export { chainOrderByMetadata as t };
+
+//# sourceMappingURL=chain-order-CaHXo5jz.mjs.map

package/dist/chain-order-CaHXo5jz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-order-CaHXo5jz.mjs","names":[],"sources":["../src/core/chain-order.ts"],"sourcesContent":["import type { MigrationMetadata } from \"@prisma/orm-toolchain/migration-tools/metadata\";\n\n/**\n * Minimal shape that {@link chainOrderByMetadata} needs from each package.\n *\n * Callers typically have richer types (ops, file paths) — just make sure\n * `dirName` and `metadata.from` are present.\n */\nexport interface ChainablePackage {\n  readonly dirName: string;\n  readonly metadata: Pick<MigrationMetadata, \"from\" | \"to\">;\n}\n\n/**\n * Walk an unordered set of migration packages by `metadata.from`/`to` edges\n * to produce a chain-ordered list. Starts at the package whose\n * `from === null` (the baseline) and follows each `to` to the next\n * package's matching `from`.\n *\n * Throws on:\n * - No baseline (no package with `from === null`)\n * - Multiple baselines (two packages with `from === null`)\n * - Broken edge (no package whose `from` matches the cursor)\n * - Cycle (revisited hash)\n * - Orphan package (package left unvisited after chain completes)\n */\nexport function chainOrderByMetadata<P extends ChainablePackage>(unordered: ReadonlyMap<string, P>): P[] {\n  if (unordered.size === 0) return [];\n\n  const byFrom = new Map<string | null, P>();\n  for (const pkg of unordered.values()) {\n    const from = pkg.metadata.from;\n    const existing = byFrom.get(from);\n    if (existing) {\n      throw new Error(\n        `Migration chain conflict: ${existing.dirName} and ${pkg.dirName} both ` +\n          `declare from === ${JSON.stringify(from)}. The chain must be linear.`\n      );\n    }\n    byFrom.set(from, pkg);\n  }\n\n  const ordered: P[] = [];\n  const visited = new Set<string>();\n  let cursor: string | null = null;\n  while (true) {\n    const next = byFrom.get(cursor);\n    if (!next) {\n      if (ordered.length === unordered.size) break; // chain complete\n      const orphans = [...unordered.keys()].filter((d) => !visited.has(d));\n      throw new Error(\n        `Migration chain broken: no package declares from === ${JSON.stringify(cursor)}. ` +\n          `Orphan package(s) not reachable from the baseline: ${orphans.join(\", \")}. ` +\n          \"Either the migrations directory has been hand-edited or a package was \" +\n          \"deleted; re-emit the affected migration with `node migration.ts`.\"\n      );\n    }\n    if (visited.has(next.dirName)) {\n      throw new Error(`Migration chain cycle detected at ${next.dirName}.`);\n    }\n    visited.add(next.dirName);\n    ordered.push(next);\n    cursor = next.metadata.to;\n  }\n\n  return ordered;\n}\n"],"mappings":";;;;;;;;;;;;;;AA0BA,SAAgB,qBAAiD,WAAwC;CACvG,IAAI,UAAU,SAAS,GAAG,OAAO,CAAC;CAElC,MAAM,yBAAS,IAAI,IAAsB;CACzC,KAAK,MAAM,OAAO,UAAU,OAAO,GAAG;EACpC,MAAM,OAAO,IAAI,SAAS;EAC1B,MAAM,WAAW,OAAO,IAAI,IAAI;EAChC,IAAI,UACF,MAAM,IAAI,MACR,6BAA6B,SAAS,QAAQ,OAAO,IAAI,QAAQ,yBAC3C,KAAK,UAAU,IAAI,EAAE,4BAC7C;EAEF,OAAO,IAAI,MAAM,GAAG;CACtB;CAEA,MAAM,UAAe,CAAC;CACtB,MAAM,0BAAU,IAAI,IAAY;CAChC,IAAI,SAAwB;CAC5B,OAAO,MAAM;EACX,MAAM,OAAO,OAAO,IAAI,MAAM;EAC9B,IAAI,CAAC,MAAM;GACT,IAAI,QAAQ,WAAW,UAAU,MAAM;GACvC,MAAM,UAAU,CAAC,GAAG,UAAU,KAAK,CAAC,CAAC,CAAC,QAAQ,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;GACnE,MAAM,IAAI,MACR,wDAAwD,KAAK,UAAU,MAAM,EAAE,uDACvB,QAAQ,KAAK,IAAI,EAAE,4IAG7E;EACF;EACA,IAAI,QAAQ,IAAI,KAAK,OAAO,GAC1B,MAAM,IAAI,MAAM,qCAAqC,KAAK,QAAQ,EAAE;EAEtE,QAAQ,IAAI,KAAK,OAAO;EACxB,QAAQ,KAAK,IAAI;EACjB,SAAS,KAAK,SAAS;CACzB;CAEA,OAAO;AACT"}

package/dist/cli-Dlaym_DD.mjs

@@ -0,0 +1,342 @@
+import { dirname, join, resolve } from "pathe";
+import { createCli, defineCommand, defineCommandFamily, flag, loadConfig } from "@prisma/cli-engine";
+import { ormConfigSection } from "@prisma/orm-toolchain/cli";
+import { CliStructuredError, notOk, ok } from "@prisma/cli-engine/protocol";
+import { finalizeConfig } from "@prisma/orm-toolchain/config-loader";
+//#region src/cli/collecting-sink.ts
+/**
+* Buffers writes the way a real stream does: a write with no trailing
+* newline (e.g. the wrapped functions' `out("  ${dirName} … ")` followed
+* later by a separate `out("ok\n")` call) stays pending and joins with
+* whatever arrives next, rather than becoming its own line. Splitting each
+* `out`/`err` call independently — the first cut of this — silently broke
+* exactly this pattern in `preflight.ts`'s per-package progress line.
+*/
+function createCollectingSink() {
+	const completedLines = [];
+	let buffer = "";
+	function push(text) {
+		buffer += text;
+		const parts = buffer.split("\n");
+		buffer = parts.pop() ?? "";
+		for (const part of parts) if (part.length > 0) completedLines.push(part);
+	}
+	const lines = () => buffer.length > 0 ? [...completedLines, buffer] : completedLines;
+	return {
+		out: (text) => push(text),
+		err: (text) => push(text),
+		lines,
+		fullText: () => lines().join("\n").trim()
+	};
+}
+/**
+* Renders collected lines as a `drawing` block (verbatim, no reflow) in
+* human mode; `stdout` stays empty since these commands carry no separate
+* machine-pipeable data channel beyond the human log itself.
+*/
+function presentationsFromSink(sink, exitCode) {
+	const lines = sink.lines();
+	return {
+		human: () => lines.length === 0 ? [] : [{
+			kind: "drawing",
+			lines
+		}],
+		stdout: () => [],
+		json: () => ({
+			exitCode,
+			lines
+		}),
+		next: () => []
+	};
+}
+//#endregion
+//#region src/cli/define-command.ts
+function normalizeError(error) {
+	if (CliStructuredError.is(error)) return error;
+	return new CliStructuredError("IDB-CLI.UNEXPECTED_ERROR", error instanceof Error ? error.message : String(error));
+}
+function finalizedConfigContext(ctx) {
+	if (ctx.config === void 0) return ctx;
+	return {
+		...ctx,
+		config: finalizeConfig(ctx.config, ctx.cwd)
+	};
+}
+/**
+* These 3 commands are IDB-specific (fake-indexeddb, IdbMigrationPlanner) —
+* pointing them at a non-IDB `prisma.config.ts` would fail confusingly deep
+* inside that logic rather than with a clear, actionable error. `orm`'s own
+* config section is family-agnostic by design (ADR 150), so this guard is
+* this shell's responsibility, not the section's.
+*/
+function requireIdbFamily(config) {
+	const familyId = config.family?.familyId;
+	if (familyId !== "idb") throw new CliStructuredError("IDB-CLI.FAMILY_MISMATCH", `config family is "${familyId ?? "unknown"}", expected "idb".`, {
+		why: "This CLI's migration commands operate on IDB-family projects only.",
+		nextActions: [{
+			kind: "edit-file",
+			label: "Point --config at your browser-side prisma.config.ts (the one using @prisma-idb/family-idb/control)"
+		}]
+	});
+}
+/**
+* `defineCommand` pre-bound to the `orm` config section (see
+* `config-section.ts`) with a uniform error boundary and path
+* finalization, mirroring `@prisma/orm-toolchain`'s own `defineOrmCommand`
+* (`vendor/prisma/packages/1-framework/3-tooling/cli/src/orm/define-command.ts`):
+* the engine's config loader hands a command `contract.output`/
+* `migrations.dir` exactly as authored (usually relative); finalizing here,
+* once, means handlers always read absolute paths.
+*/
+function defineIdbCommand(def) {
+	return defineCommand({
+		...def,
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			try {
+				const finalized = finalizedConfigContext(ctx);
+				requireIdbFamily(finalized.config);
+				return await def.handler(args, finalized);
+			} catch (error) {
+				return notOk(normalizeError(error));
+			}
+		}
+	});
+}
+//#endregion
+//#region src/cli/migration/paths.ts
+/**
+* Resolves the contract/migrations paths a command needs from the already
+* finalized (absolute-paths) `orm` config section, with CLI flag overrides
+* winning when supplied. `ctx.config` arrives finalized by
+* `defineIdbCommand` (see `../define-command.ts`), so `config.contract.output`
+* and `config.migrations.dir` are already absolute — only an explicit
+* `--contract`/`--migrations-dir` flag (relative to `cwd`) needs resolving
+* here.
+*/
+function requireContractPath(config, cwd, override) {
+	if (override !== void 0) return resolve(cwd, override);
+	const output = config.contract?.output;
+	if (output === void 0) throw new CliStructuredError("IDB-CLI.CONTRACT_PATH_MISSING", "config.contract.output is required to resolve the contract path.", {
+		why: "Neither --contract nor prisma.config.ts's orm.contract.output supplied a path.",
+		nextActions: [{
+			kind: "edit-file",
+			label: "Set contract.output in prisma.config.ts, or pass --contract explicitly"
+		}]
+	});
+	return output;
+}
+/**
+* `finalizeConfig` always resolves `migrations.dir` to an absolute path
+* (defaulting to `<configDir>/migrations` when unset); the fallback here is
+* defensive, not the expected path.
+*/
+function resolveMigrationsDir(config, cwd, override) {
+	if (override !== void 0) return resolve(cwd, override);
+	return config.migrations?.dir ?? resolve(cwd, "migrations");
+}
+//#endregion
+//#region src/cli/migration/contract-space.ts
+const migrationContractSpaceCommand = defineIdbCommand({
+	help: {
+		summary: "Regenerate contract-space.generated.ts from migrations/app/",
+		description: "Reads every migration package under <migrationsDir>/app/, validates the\nchain's connectivity, and emits a generated TypeScript module that bundles\nthem into a ContractSpace.",
+		examples: ["migration contract-space", "migration contract-space --out src/lib/prisma/contract-space.ts"]
+	},
+	args: { flags: {
+		contract: flag.string({
+			brief: "Path to contract.json (default: orm.contract.output)",
+			placeholder: "path"
+		}),
+		migrationsDir: flag.string({
+			brief: "Path to the migrations root (default: orm.migrations.dir)",
+			placeholder: "path"
+		}),
+		out: flag.string({
+			brief: "Output file path (default: colocated with the resolved contract.json)",
+			placeholder: "path"
+		})
+	} },
+	handler: async (args, ctx) => {
+		const contractPath = requireContractPath(ctx.config, ctx.cwd, args.flags.contract);
+		const migrationsDir = resolveMigrationsDir(ctx.config, ctx.cwd, args.flags.migrationsDir);
+		const outPath = args.flags.out !== void 0 ? resolve(ctx.cwd, args.flags.out) : join(dirname(contractPath), "contract-space.generated.ts");
+		const { generateContractSpace } = await import("./contract-space-codegen--gfuyap2.mjs");
+		const sink = createCollectingSink();
+		const exitCode = await generateContractSpace({
+			migrationsDir,
+			contractPath,
+			outPath,
+			out: sink.out,
+			err: sink.err
+		});
+		if (exitCode !== 0) return notOk(new CliStructuredError("IDB-CLI.CONTRACT_SPACE_FAILED", sink.fullText() || "migration contract-space failed."));
+		return ok(ctx.present({ data: {
+			exitCode,
+			outPath
+		} }, presentationsFromSink(sink, exitCode)));
+	}
+});
+//#endregion
+//#region src/cli/family.ts
+const commands = {
+	"migration plan": defineIdbCommand({
+		help: {
+			summary: "Plan the next IDB migration package (auto-detects baseline vs. incremental)",
+			description: "Compares the emitted contract against the latest on-disk migration state and\nproduces a new migration package with the required operations. Offline —\nnever opens IndexedDB (there is no live database on the Node side to consult).",
+			examples: [
+				"migration plan",
+				"migration plan --name add-posts",
+				"migration plan --space idb-sync"
+			]
+		},
+		args: { flags: {
+			name: flag.string({
+				brief: "Directory slug (default: \"baseline\" for a fresh space; required otherwise)",
+				placeholder: "slug"
+			}),
+			space: flag.string({
+				brief: "Contract-space id (default: \"app\"). See ADR 212 for extension-space migrations.",
+				placeholder: "id"
+			}),
+			contract: flag.string({
+				brief: "Path to contract.json (default: orm.contract.output)",
+				placeholder: "path"
+			}),
+			migrationsDir: flag.string({
+				brief: "Path to the migrations root (default: orm.migrations.dir)",
+				placeholder: "path"
+			})
+		} },
+		handler: async (args, ctx) => {
+			const contractPath = requireContractPath(ctx.config, ctx.cwd, args.flags.contract);
+			const migrationsDir = resolveMigrationsDir(ctx.config, ctx.cwd, args.flags.migrationsDir);
+			const { migrationPlan } = await import("./migration-plan-BWhd8BdV.mjs");
+			const sink = createCollectingSink();
+			const exitCode = await migrationPlan({
+				migrationsDir,
+				contractPath,
+				out: sink.out,
+				err: sink.err,
+				...args.flags.name !== void 0 && { name: args.flags.name },
+				...args.flags.space !== void 0 && { spaceId: args.flags.space }
+			});
+			if (exitCode === 2) return notOk(new CliStructuredError("IDB-CLI.MIGRATION_NAME_REQUIRED", sink.fullText() || "--name <slug> is required when generating an incremental migration."));
+			if (exitCode !== 0) return notOk(new CliStructuredError("IDB-CLI.MIGRATION_PLAN_FAILED", sink.fullText() || "migration plan failed."));
+			return ok(ctx.present({ data: { exitCode } }, presentationsFromSink(sink, exitCode)));
+		}
+	}),
+	"migration contract-space": migrationContractSpaceCommand,
+	"migration preflight": defineIdbCommand({
+		help: {
+			summary: "Validate the migration chain against fake-indexeddb",
+			description: "Walks every migration package under <migrationsDir>/app/ in chain order,\napplying each package's ops.json against a fresh fake-indexeddb instance.\nCatches 'the chain doesn't apply cleanly' — not schema drift.",
+			examples: ["migration preflight"]
+		},
+		args: { flags: { migrationsDir: flag.string({
+			brief: "Path to the migrations root (default: orm.migrations.dir)",
+			placeholder: "path"
+		}) } },
+		handler: async (args, ctx) => {
+			const migrationsDir = resolveMigrationsDir(ctx.config, ctx.cwd, args.flags.migrationsDir);
+			const { runPreflight } = await import("./preflight-4jDCNvS0.mjs");
+			const sink = createCollectingSink();
+			const exitCode = await runPreflight({
+				migrationsDir,
+				out: sink.out,
+				err: sink.err
+			});
+			if (exitCode !== 0) return notOk(new CliStructuredError("IDB-CLI.PREFLIGHT_FAILED", sink.fullText() || "Preflight failed."));
+			return ok(ctx.present({ data: { exitCode } }, presentationsFromSink(sink, exitCode)));
+		}
+	})
+};
+/**
+* The unit this package contributes to a `@prisma/cli-engine` shell: its
+* config section (reused from the ORM family, see `config-section.ts`) and
+* its 3 commands. These have no generic equivalent — the real `prisma` CLI's
+* `migration new`/`plan`/etc. work against a live database or a SQL/Mongo
+* on-disk model; ours works against `fake-indexeddb` and a hand-rolled
+* contract-space convention.
+*/
+const idbCommandFamily = defineCommandFamily({
+	configSection: ormConfigSection,
+	commands
+});
+//#endregion
+//#region package.json
+var version = "0.6.0";
+//#endregion
+//#region src/cli/cli.ts
+const BIN_NAME = "prisma-idb";
+const BIN_GROUPS = { migration: {
+	brief: "On-disk migration management commands",
+	description: "Plan, bundle, and validate IDB migration packages. Migrations are\ncontract-to-contract edges stored as versioned directories under migrations/."
+} };
+function createIdbCli() {
+	return createCli({
+		name: BIN_NAME,
+		version,
+		commandFamilies: [idbCommandFamily],
+		groups: BIN_GROUPS,
+		commands: idbCommandFamily.commands,
+		help: {
+			tagline: "IDB-target tooling for Prisma 8",
+			description: "Migration authoring for IndexedDB projects — no live database on the Node side to consult."
+		}
+	});
+}
+/** Everything environmental the engine is given, adapted from the host process once. */
+function runtimeFromProcess(proc) {
+	return {
+		stdout: { write: (text) => void proc.stdout.write(text) },
+		stderr: { write: (text) => void proc.stderr.write(text) },
+		stdin: proc.stdin,
+		cwd: proc.cwd(),
+		env: proc.env,
+		isTty: {
+			stdin: proc.stdin.isTTY === true,
+			stdout: proc.stdout.isTTY === true,
+			stderr: proc.stderr.isTTY === true
+		},
+		host: {
+			runtime: {
+				name: "node",
+				version: proc.version
+			},
+			platform: proc.platform,
+			arch: proc.arch
+		},
+		exit: (code) => proc.exit(code),
+		onSignal: (callback) => {
+			const onInterrupt = () => callback("SIGINT");
+			const onTerminate = () => callback("SIGTERM");
+			proc.on("SIGINT", onInterrupt);
+			proc.on("SIGTERM", onTerminate);
+			return () => {
+				proc.off("SIGINT", onInterrupt);
+				proc.off("SIGTERM", onTerminate);
+			};
+		},
+		loadConfig: (configPath) => loadConfig(proc.cwd(), configPath),
+		managementApi: { baseUrl: "https://api.prisma.io" }
+	};
+}
+const STARTUP_FAILURE_EXIT_CODE = 1;
+function reportStartupFailure(proc, error) {
+	const normalized = CliStructuredError.is(error) ? error : new CliStructuredError("IDB-CLI.STARTUP_FAILURE", error instanceof Error ? error.message : String(error));
+	proc.stderr.write(`✘ [${normalized.code}] ${normalized.message}\n`);
+	return STARTUP_FAILURE_EXIT_CODE;
+}
+/** Parses, executes and settles one invocation; returns the exit code. */
+async function runIdbCli(proc) {
+	try {
+		return await createIdbCli().run(proc.argv.slice(2), runtimeFromProcess(proc));
+	} catch (error) {
+		return reportStartupFailure(proc, error);
+	}
+}
+//#endregion
+export { idbCommandFamily as a, runIdbCli as i, BIN_NAME as n, createIdbCli as r, BIN_GROUPS as t };
+
+//# sourceMappingURL=cli-Dlaym_DD.mjs.map

package/dist/cli-Dlaym_DD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-Dlaym_DD.mjs","names":["packageJson.version"],"sources":["../src/cli/collecting-sink.ts","../src/cli/define-command.ts","../src/cli/migration/paths.ts","../src/cli/migration/contract-space.ts","../src/cli/migration/plan.ts","../src/cli/migration/preflight.ts","../src/cli/family.ts","../package.json","../src/cli/cli.ts"],"sourcesContent":["import type { Presentations } from \"@prisma/cli-engine\";\n\n/**\n * Collects a wrapped core function's `out`/`err` sink writes so a command\n * handler can present them through the engine instead of writing to the\n * real `process.stdout`/`process.stderr` directly (which would corrupt\n * `--json` mode and be invisible to `createTestCli`'s in-memory harness).\n */\nexport interface CollectingSink {\n  readonly out: (line: string) => void;\n  readonly err: (line: string) => void;\n  /** Every line written to either sink, in order, newline-split. */\n  lines(): readonly string[];\n  /**\n   * `lines()` joined back into text — the full collected log (progress\n   * AND error detail, not just the `err`-only parts), for use as a\n   * `CliStructuredError`'s `summary` on a nonzero exit. A wrapped function\n   * writes its error explanation to `err` only after already writing\n   * per-step progress to `out` (e.g. preflight's `\"<dir> … \"` / `\"FAILED\"`\n   * pair) — using only the `err` writes would silently drop that context.\n   */\n  fullText(): string;\n}\n\n/**\n * Buffers writes the way a real stream does: a write with no trailing\n * newline (e.g. the wrapped functions' `out(\"  ${dirName} … \")` followed\n * later by a separate `out(\"ok\\n\")` call) stays pending and joins with\n * whatever arrives next, rather than becoming its own line. Splitting each\n * `out`/`err` call independently — the first cut of this — silently broke\n * exactly this pattern in `preflight.ts`'s per-package progress line.\n */\nexport function createCollectingSink(): CollectingSink {\n  const completedLines: string[] = [];\n  let buffer = \"\";\n\n  function push(text: string): void {\n    buffer += text;\n    const parts = buffer.split(\"\\n\");\n    buffer = parts.pop() ?? \"\";\n    for (const part of parts) {\n      if (part.length > 0) completedLines.push(part);\n    }\n  }\n\n  const lines = (): readonly string[] => (buffer.length > 0 ? [...completedLines, buffer] : completedLines);\n\n  return {\n    out: (text) => push(text),\n    err: (text) => push(text),\n    lines,\n    fullText: () => lines().join(\"\\n\").trim(),\n  };\n}\n\n/**\n * Renders collected lines as a `drawing` block (verbatim, no reflow) in\n * human mode; `stdout` stays empty since these commands carry no separate\n * machine-pipeable data channel beyond the human log itself.\n */\nexport function presentationsFromSink(sink: CollectingSink, exitCode: number): Presentations {\n  const lines = sink.lines();\n  return {\n    human: () => (lines.length === 0 ? [] : [{ kind: \"drawing\", lines }]),\n    stdout: () => [],\n    json: () => ({ exitCode, lines }),\n    next: () => [],\n  };\n}\n","import type { PrismaNextConfig } from \"@prisma/orm-toolchain/config-loader\";\nimport { finalizeConfig } from \"@prisma/orm-toolchain/config-loader\";\nimport type {\n  ArgsSpec,\n  CommandDefinition,\n  FlagSpec,\n  Handler,\n  HelpSpec,\n  PositionalSpec,\n  SpawnDeclarations,\n} from \"@prisma/cli-engine\";\nimport { defineCommand } from \"@prisma/cli-engine\";\nimport { CliStructuredError, notOk } from \"@prisma/cli-engine/protocol\";\nimport { ormConfigSection } from \"./config-section\";\n\nfunction normalizeError(error: unknown): CliStructuredError {\n  if (CliStructuredError.is(error)) return error;\n  return new CliStructuredError(\"IDB-CLI.UNEXPECTED_ERROR\", error instanceof Error ? error.message : String(error));\n}\n\nfunction finalizedConfigContext<TCtx extends { readonly cwd: string; readonly config: unknown }>(ctx: TCtx): TCtx {\n  if (ctx.config === undefined) return ctx;\n  return { ...ctx, config: finalizeConfig(ctx.config as PrismaNextConfig, ctx.cwd) };\n}\n\n/**\n * These 3 commands are IDB-specific (fake-indexeddb, IdbMigrationPlanner) —\n * pointing them at a non-IDB `prisma.config.ts` would fail confusingly deep\n * inside that logic rather than with a clear, actionable error. `orm`'s own\n * config section is family-agnostic by design (ADR 150), so this guard is\n * this shell's responsibility, not the section's.\n */\nfunction requireIdbFamily(config: PrismaNextConfig): void {\n  const familyId = config.family?.familyId;\n  if (familyId !== \"idb\") {\n    throw new CliStructuredError(\n      \"IDB-CLI.FAMILY_MISMATCH\",\n      `config family is \"${familyId ?? \"unknown\"}\", expected \"idb\".`,\n      {\n        why: \"This CLI's migration commands operate on IDB-family projects only.\",\n        nextActions: [\n          {\n            kind: \"edit-file\",\n            label:\n              \"Point --config at your browser-side prisma.config.ts (the one using @prisma-idb/family-idb/control)\",\n          },\n        ],\n      }\n    );\n  }\n}\n\n/**\n * `defineCommand` pre-bound to the `orm` config section (see\n * `config-section.ts`) with a uniform error boundary and path\n * finalization, mirroring `@prisma/orm-toolchain`'s own `defineOrmCommand`\n * (`vendor/prisma/packages/1-framework/3-tooling/cli/src/orm/define-command.ts`):\n * the engine's config loader hands a command `contract.output`/\n * `migrations.dir` exactly as authored (usually relative); finalizing here,\n * once, means handlers always read absolute paths.\n */\nexport function defineIdbCommand<\n  TFlags extends Record<string, FlagSpec<unknown>> = Record<never, FlagSpec<unknown>>,\n  TPositionals extends Record<string, PositionalSpec<unknown>> = Record<never, PositionalSpec<unknown>>,\n  TCode extends number = never,\n>(\n  def: {\n    readonly help: HelpSpec;\n    readonly args?: ArgsSpec<TFlags, TPositionals>;\n    readonly exitCodes?: Readonly<Record<TCode, string>>;\n    readonly handler: Handler<TFlags, TPositionals, PrismaNextConfig, TCode, false, false>;\n  } & SpawnDeclarations\n): CommandDefinition<TFlags, TPositionals, PrismaNextConfig, TCode, false, false> {\n  return defineCommand<TFlags, TPositionals, PrismaNextConfig, TCode, false, false>({\n    ...def,\n    needs: { config: ormConfigSection },\n    handler: async (args, ctx) => {\n      try {\n        const finalized = finalizedConfigContext(ctx);\n        requireIdbFamily(finalized.config);\n        return await def.handler(args, finalized);\n      } catch (error) {\n        return notOk(normalizeError(error));\n      }\n    },\n  });\n}\n","import type { PrismaNextConfig } from \"@prisma/orm-toolchain/config-loader\";\nimport { CliStructuredError } from \"@prisma/cli-engine/protocol\";\nimport { resolve } from \"pathe\";\n\n/**\n * Resolves the contract/migrations paths a command needs from the already\n * finalized (absolute-paths) `orm` config section, with CLI flag overrides\n * winning when supplied. `ctx.config` arrives finalized by\n * `defineIdbCommand` (see `../define-command.ts`), so `config.contract.output`\n * and `config.migrations.dir` are already absolute — only an explicit\n * `--contract`/`--migrations-dir` flag (relative to `cwd`) needs resolving\n * here.\n */\nexport function requireContractPath(config: PrismaNextConfig, cwd: string, override: string | undefined): string {\n  if (override !== undefined) return resolve(cwd, override);\n  const output = config.contract?.output;\n  if (output === undefined) {\n    throw new CliStructuredError(\n      \"IDB-CLI.CONTRACT_PATH_MISSING\",\n      \"config.contract.output is required to resolve the contract path.\",\n      {\n        why: \"Neither --contract nor prisma.config.ts's orm.contract.output supplied a path.\",\n        nextActions: [\n          { kind: \"edit-file\", label: \"Set contract.output in prisma.config.ts, or pass --contract explicitly\" },\n        ],\n      }\n    );\n  }\n  return output;\n}\n\n/**\n * `finalizeConfig` always resolves `migrations.dir` to an absolute path\n * (defaulting to `<configDir>/migrations` when unset); the fallback here is\n * defensive, not the expected path.\n */\nexport function resolveMigrationsDir(config: PrismaNextConfig, cwd: string, override: string | undefined): string {\n  if (override !== undefined) return resolve(cwd, override);\n  return config.migrations?.dir ?? resolve(cwd, \"migrations\");\n}\n","import { dirname, join, resolve } from \"pathe\";\nimport { flag } from \"@prisma/cli-engine\";\nimport { CliStructuredError, notOk, ok } from \"@prisma/cli-engine/protocol\";\nimport { createCollectingSink, presentationsFromSink } from \"../collecting-sink\";\nimport { defineIdbCommand } from \"../define-command\";\nimport { requireContractPath, resolveMigrationsDir } from \"./paths\";\n\nexport const migrationContractSpaceCommand = defineIdbCommand({\n  help: {\n    summary: \"Regenerate contract-space.generated.ts from migrations/app/\",\n    description:\n      \"Reads every migration package under <migrationsDir>/app/, validates the\\n\" +\n      \"chain's connectivity, and emits a generated TypeScript module that bundles\\n\" +\n      \"them into a ContractSpace.\",\n    examples: [\"migration contract-space\", \"migration contract-space --out src/lib/prisma/contract-space.ts\"],\n  },\n  args: {\n    flags: {\n      contract: flag.string({\n        brief: \"Path to contract.json (default: orm.contract.output)\",\n        placeholder: \"path\",\n      }),\n      migrationsDir: flag.string({\n        brief: \"Path to the migrations root (default: orm.migrations.dir)\",\n        placeholder: \"path\",\n      }),\n      out: flag.string({\n        brief: \"Output file path (default: colocated with the resolved contract.json)\",\n        placeholder: \"path\",\n      }),\n    },\n  },\n  handler: async (args, ctx) => {\n    const contractPath = requireContractPath(ctx.config, ctx.cwd, args.flags.contract);\n    const migrationsDir = resolveMigrationsDir(ctx.config, ctx.cwd, args.flags.migrationsDir);\n    const outPath =\n      args.flags.out !== undefined\n        ? resolve(ctx.cwd, args.flags.out)\n        : join(dirname(contractPath), \"contract-space.generated.ts\");\n\n    const { generateContractSpace } = await import(\"../../core/contract-space-codegen\");\n    const sink = createCollectingSink();\n    const exitCode = await generateContractSpace({\n      migrationsDir,\n      contractPath,\n      outPath,\n      out: sink.out,\n      err: sink.err,\n    });\n\n    if (exitCode !== 0) {\n      return notOk(\n        new CliStructuredError(\"IDB-CLI.CONTRACT_SPACE_FAILED\", sink.fullText() || \"migration contract-space failed.\")\n      );\n    }\n    return ok(ctx.present({ data: { exitCode, outPath } }, presentationsFromSink(sink, exitCode)));\n  },\n});\n","import { flag } from \"@prisma/cli-engine\";\nimport { CliStructuredError, notOk, ok } from \"@prisma/cli-engine/protocol\";\nimport { createCollectingSink, presentationsFromSink } from \"../collecting-sink\";\nimport { defineIdbCommand } from \"../define-command\";\nimport { requireContractPath, resolveMigrationsDir } from \"./paths\";\n\nexport const migrationPlanCommand = defineIdbCommand({\n  help: {\n    summary: \"Plan the next IDB migration package (auto-detects baseline vs. incremental)\",\n    description:\n      \"Compares the emitted contract against the latest on-disk migration state and\\n\" +\n      \"produces a new migration package with the required operations. Offline —\\n\" +\n      \"never opens IndexedDB (there is no live database on the Node side to consult).\",\n    examples: [\"migration plan\", \"migration plan --name add-posts\", \"migration plan --space idb-sync\"],\n  },\n  args: {\n    flags: {\n      name: flag.string({\n        brief: 'Directory slug (default: \"baseline\" for a fresh space; required otherwise)',\n        placeholder: \"slug\",\n      }),\n      space: flag.string({\n        brief: 'Contract-space id (default: \"app\"). See ADR 212 for extension-space migrations.',\n        placeholder: \"id\",\n      }),\n      contract: flag.string({\n        brief: \"Path to contract.json (default: orm.contract.output)\",\n        placeholder: \"path\",\n      }),\n      migrationsDir: flag.string({\n        brief: \"Path to the migrations root (default: orm.migrations.dir)\",\n        placeholder: \"path\",\n      }),\n    },\n  },\n  handler: async (args, ctx) => {\n    const contractPath = requireContractPath(ctx.config, ctx.cwd, args.flags.contract);\n    const migrationsDir = resolveMigrationsDir(ctx.config, ctx.cwd, args.flags.migrationsDir);\n\n    const { migrationPlan } = await import(\"../../core/migration-plan\");\n    const sink = createCollectingSink();\n    const exitCode = await migrationPlan({\n      migrationsDir,\n      contractPath,\n      out: sink.out,\n      err: sink.err,\n      ...(args.flags.name !== undefined && { name: args.flags.name }),\n      ...(args.flags.space !== undefined && { spaceId: args.flags.space }),\n    });\n\n    if (exitCode === 2) {\n      return notOk(\n        new CliStructuredError(\n          \"IDB-CLI.MIGRATION_NAME_REQUIRED\",\n          sink.fullText() || \"--name <slug> is required when generating an incremental migration.\"\n        )\n      );\n    }\n    if (exitCode !== 0) {\n      return notOk(\n        new CliStructuredError(\"IDB-CLI.MIGRATION_PLAN_FAILED\", sink.fullText() || \"migration plan failed.\")\n      );\n    }\n    return ok(ctx.present({ data: { exitCode } }, presentationsFromSink(sink, exitCode)));\n  },\n});\n","import { flag } from \"@prisma/cli-engine\";\nimport { CliStructuredError, notOk, ok } from \"@prisma/cli-engine/protocol\";\nimport { createCollectingSink, presentationsFromSink } from \"../collecting-sink\";\nimport { defineIdbCommand } from \"../define-command\";\nimport { resolveMigrationsDir } from \"./paths\";\n\nexport const migrationPreflightCommand = defineIdbCommand({\n  help: {\n    summary: \"Validate the migration chain against fake-indexeddb\",\n    description:\n      \"Walks every migration package under <migrationsDir>/app/ in chain order,\\n\" +\n      \"applying each package's ops.json against a fresh fake-indexeddb instance.\\n\" +\n      \"Catches 'the chain doesn't apply cleanly' — not schema drift.\",\n    examples: [\"migration preflight\"],\n  },\n  args: {\n    flags: {\n      migrationsDir: flag.string({\n        brief: \"Path to the migrations root (default: orm.migrations.dir)\",\n        placeholder: \"path\",\n      }),\n    },\n  },\n  handler: async (args, ctx) => {\n    const migrationsDir = resolveMigrationsDir(ctx.config, ctx.cwd, args.flags.migrationsDir);\n\n    const { runPreflight } = await import(\"../../core/preflight\");\n    const sink = createCollectingSink();\n    const exitCode = await runPreflight({ migrationsDir, out: sink.out, err: sink.err });\n\n    if (exitCode !== 0) {\n      return notOk(new CliStructuredError(\"IDB-CLI.PREFLIGHT_FAILED\", sink.fullText() || \"Preflight failed.\"));\n    }\n    return ok(ctx.present({ data: { exitCode } }, presentationsFromSink(sink, exitCode)));\n  },\n});\n","import type { AnyCommand } from \"@prisma/cli-engine\";\nimport { defineCommandFamily } from \"@prisma/cli-engine\";\nimport { ormConfigSection } from \"./config-section\";\nimport { migrationContractSpaceCommand } from \"./migration/contract-space\";\nimport { migrationPlanCommand } from \"./migration/plan\";\nimport { migrationPreflightCommand } from \"./migration/preflight\";\n\nconst commands: Readonly<Record<string, AnyCommand>> = {\n  \"migration plan\": migrationPlanCommand,\n  \"migration contract-space\": migrationContractSpaceCommand,\n  \"migration preflight\": migrationPreflightCommand,\n};\n\n/**\n * The unit this package contributes to a `@prisma/cli-engine` shell: its\n * config section (reused from the ORM family, see `config-section.ts`) and\n * its 3 commands. These have no generic equivalent — the real `prisma` CLI's\n * `migration new`/`plan`/etc. work against a live database or a SQL/Mongo\n * on-disk model; ours works against `fake-indexeddb` and a hand-rolled\n * contract-space convention.\n */\nexport const idbCommandFamily = defineCommandFamily({\n  configSection: ormConfigSection,\n  commands,\n});\n","","import type { Cli, HostProcess, Runtime } from \"@prisma/cli-engine\";\nimport { createCli, loadConfig } from \"@prisma/cli-engine\";\nimport { CliStructuredError } from \"@prisma/cli-engine/protocol\";\nimport packageJson from \"../../package.json\" with { type: \"json\" };\nimport { idbCommandFamily } from \"./family\";\n\nexport const BIN_NAME = \"prisma-idb\";\n\nexport const BIN_GROUPS = {\n  migration: {\n    brief: \"On-disk migration management commands\",\n    description:\n      \"Plan, bundle, and validate IDB migration packages. Migrations are\\n\" +\n      \"contract-to-contract edges stored as versioned directories under migrations/.\",\n  },\n} as const;\n\nexport function createIdbCli(): Cli {\n  return createCli({\n    name: BIN_NAME,\n    version: packageJson.version,\n    commandFamilies: [idbCommandFamily],\n    groups: BIN_GROUPS,\n    commands: idbCommandFamily.commands,\n    help: {\n      tagline: \"IDB-target tooling for Prisma 8\",\n      description: \"Migration authoring for IndexedDB projects — no live database on the Node side to consult.\",\n    },\n  });\n}\n\n/** Everything environmental the engine is given, adapted from the host process once. */\nexport function runtimeFromProcess(proc: HostProcess): Runtime {\n  return {\n    stdout: { write: (text) => void proc.stdout.write(text) },\n    stderr: { write: (text) => void proc.stderr.write(text) },\n    stdin: proc.stdin,\n    cwd: proc.cwd(),\n    env: proc.env,\n    isTty: {\n      stdin: proc.stdin.isTTY === true,\n      stdout: proc.stdout.isTTY === true,\n      stderr: proc.stderr.isTTY === true,\n    },\n    host: {\n      runtime: { name: \"node\", version: proc.version },\n      platform: proc.platform,\n      arch: proc.arch,\n    },\n    exit: (code) => proc.exit(code),\n    onSignal: (callback) => {\n      const onInterrupt = () => callback(\"SIGINT\");\n      const onTerminate = () => callback(\"SIGTERM\");\n      proc.on(\"SIGINT\", onInterrupt);\n      proc.on(\"SIGTERM\", onTerminate);\n      return () => {\n        proc.off(\"SIGINT\", onInterrupt);\n        proc.off(\"SIGTERM\", onTerminate);\n      };\n    },\n    loadConfig: (configPath) => loadConfig(proc.cwd(), configPath),\n    // Never reached: no command here declares `credentials`/`managesCredentials`,\n    // so ctx.api is never constructed — required on Runtime regardless.\n    managementApi: { baseUrl: \"https://api.prisma.io\" },\n  };\n}\n\nconst STARTUP_FAILURE_EXIT_CODE = 1;\n\nfunction reportStartupFailure(proc: HostProcess, error: unknown): number {\n  const normalized = CliStructuredError.is(error)\n    ? error\n    : new CliStructuredError(\"IDB-CLI.STARTUP_FAILURE\", error instanceof Error ? error.message : String(error));\n  proc.stderr.write(`✘ [${normalized.code}] ${normalized.message}\\n`);\n  return STARTUP_FAILURE_EXIT_CODE;\n}\n\n/** Parses, executes and settles one invocation; returns the exit code. */\nexport async function runIdbCli(proc: HostProcess): Promise<number> {\n  try {\n    return await createIdbCli().run(proc.argv.slice(2), runtimeFromProcess(proc));\n  } catch (error) {\n    return reportStartupFailure(proc, error);\n  }\n}\n"],"mappings":"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"}

package/dist/contract-space-codegen--gfuyap2.mjs

@@ -0,0 +1,128 @@
+import { t as chainOrderByMetadata } from "./chain-order-CaHXo5jz.mjs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "pathe";
+//#region src/core/contract-space-codegen.ts
+/**
+* Read every migration package under `<migrationsDir>/app/`, validate the
+* chain's connectivity, then emit a generated TypeScript module that
+* JSON-imports each package's `migration.json` + `ops.json` and assembles
+* them into a `ContractSpace` via `contractSpaceFromJson`. The head ref
+* is inlined as `{ hash, invariants }` derived from the last package's
+* metadata — no on-disk `refs/head.json` is written.
+*
+* (We deliberately avoid writing `migrations/refs/` because the framework's
+* contract-space layout treats top-level `migrations/<subdir>/` as a
+* per-space directory; an orphan `refs/` collides with that. Extension
+* packages — postgis, paradedb, etc. — DO write `migrations/refs/head.json`
+* because their package root IS their single space and there's no
+* ambiguity. App-level layouts use `migrations/app/` for the app space, and
+* the head ref for the app space comes from the latest package's `to`.)
+*
+* Idempotent: re-running produces byte-identical output (modulo
+* migration package list changes). Exit code 0 on success.
+*/
+async function generateContractSpace(opts) {
+	const out = opts.out ?? ((line) => process.stdout.write(line));
+	const err = opts.err ?? ((line) => process.stderr.write(line));
+	const migrationsDir = opts.migrationsDir;
+	const appDir = join(migrationsDir, "app");
+	const contractPath = opts.contractPath;
+	const outPath = opts.outPath;
+	const packages = await loadPackages(appDir, err);
+	if (packages.length === 0) err(`Warning: no migration packages found in ${relative(process.cwd(), appDir)}/.\nThe generated module will have an empty migrations list, which breaks
+\`createAutoMigratingIdbClient\` on a fresh database.
+Run \`prisma-idb migration plan\` first to create the initial migration.
+
+`);
+	const outDir = dirname(outPath);
+	await mkdir(outDir, { recursive: true });
+	const source = renderModule({
+		outDir,
+		contractPath,
+		appDir,
+		packages
+	});
+	await writeFile(outPath, source, "utf-8");
+	out(`Wrote ${outPath} (${packages.length} migration${packages.length === 1 ? "" : "s"})\n`);
+	return 0;
+}
+async function loadPackages(appDir, err) {
+	let dirs;
+	try {
+		dirs = (await readdir(appDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+	} catch (dirErr) {
+		if (dirErr.code === "ENOENT") return [];
+		throw dirErr;
+	}
+	const unordered = /* @__PURE__ */ new Map();
+	for (const dirName of dirs) {
+		const metaPath = join(appDir, dirName, "migration.json");
+		const opsPath = join(appDir, dirName, "ops.json");
+		try {
+			const metaRaw = await readFile(metaPath, "utf-8");
+			const metadata = JSON.parse(metaRaw);
+			await readFile(opsPath, "utf-8");
+			unordered.set(dirName, {
+				dirName,
+				metadata
+			});
+		} catch (loadErr) {
+			err(`Skipping ${dirName}: missing or unreadable migration.json/ops.json (${loadErr.message})\n`);
+		}
+	}
+	return chainOrderByMetadata(unordered);
+}
+function renderModule(input) {
+	const contractImportPath = toModuleSpecifier(relative(input.outDir, input.contractPath));
+	const importLines = [
+		"// THIS FILE IS AUTO-GENERATED — do not edit by hand.",
+		"// Regenerate with: prisma-idb migration contract-space",
+		"",
+		`import type { Contract } from "${contractImportPath.replace(/\.json$/i, "")}";`,
+		"import { contractSpaceFromJson } from \"@prisma/orm-toolchain/migration-tools/spaces\";",
+		`import contractJson from "${contractImportPath}" with { type: "json" };`
+	];
+	for (const pkg of input.packages) {
+		const id = identFromDir(pkg.dirName);
+		const metaPath = toModuleSpecifier(relative(input.outDir, join(input.appDir, pkg.dirName, "migration.json")));
+		const opsPath = toModuleSpecifier(relative(input.outDir, join(input.appDir, pkg.dirName, "ops.json")));
+		importLines.push(`import ${id}_meta from "${metaPath}" with { type: "json" };`);
+		importLines.push(`import ${id}_ops from "${opsPath}" with { type: "json" };`);
+	}
+	const last = input.packages[input.packages.length - 1];
+	const headRefLiteral = last === void 0 ? "{ hash: \"\", invariants: [] as const }" : `{ hash: ${identFromDir(last.dirName)}_meta.to, invariants: (${identFromDir(last.dirName)}_meta.providedInvariants ?? []) as readonly string[] }`;
+	const migrationsBody = input.packages.length === 0 ? "  migrations: []," : [
+		"  migrations: [",
+		input.packages.map((pkg) => {
+			const id = identFromDir(pkg.dirName);
+			return `    { dirName: ${JSON.stringify(pkg.dirName)}, metadata: ${id}_meta, ops: ${id}_ops },`;
+		}).join("\n"),
+		"  ],"
+	].join("\n");
+	return [
+		...importLines,
+		"",
+		"export const contractSpace = contractSpaceFromJson<Contract>({",
+		"  contractJson,",
+		migrationsBody,
+		`  headRef: ${headRefLiteral},`,
+		"});",
+		""
+	].join("\n");
+}
+function identFromDir(dirName) {
+	return `mig_${dirName.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+/**
+* Coerce a `pathe` relative path into a TypeScript module specifier.
+* - Adds a leading `./` if the path doesn't already start with `.` or `/`.
+* - Leaves absolute and parent-relative paths alone.
+*/
+function toModuleSpecifier(p) {
+	if (p.startsWith(".") || p.startsWith("/")) return p;
+	return `./${p}`;
+}
+//#endregion
+export { generateContractSpace };
+
+//# sourceMappingURL=contract-space-codegen--gfuyap2.mjs.map