@prisma/composer 0.6.0-dev.13 → 0.6.0-dev.15

package/dist/{result-CFqJKiqg.mjs → result-wonf1deB.mjs}

@@ -1,19 +1,5 @@
-import { o as blindCast } from "./shared-CCaR42wo-BvegvmA_.mjs";
-//#region ../../0-framework/0-foundation/foundation/dist/internal-error-BIc-ehme.mjs
-/**
-* A bug in Prisma Next, not a user error. Never catch this except at the
-* outermost boundary for crash reporting — an InternalError means an invariant
-* broke and the process cannot reliably continue. User-facing failures use
-* `structuredError` with a dotted code instead.
-*/
-var InternalError = class extends Error {
-	isPrismaInternalError = true;
-	constructor(message, options) {
-		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
-		this.name = "InternalError";
-	}
-};
-//#endregion
+import { t as blindCast } from "./casts-DpaahrlC-C5XMnP9S.mjs";
+import { t as InternalError } from "./internal-error-BIc-ehme-Ck_lgxD_.mjs";
 //#region ../../0-framework/0-foundation/foundation/dist/result.mjs
 /**
 * Generic Result type for representing success or failure outcomes.
@@ -101,6 +87,6 @@ function okVoid() {
 	return OK_VOID;
 }
 //#endregion
-export { InternalError as i, ok as n, okVoid as r, notOk as t };
+export { ok as n, okVoid as r, notOk as t };
 
-//# sourceMappingURL=result-CFqJKiqg.mjs.map
+//# sourceMappingURL=result-wonf1deB.mjs.map

package/dist/result-wonf1deB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-wonf1deB.mjs","names":[],"sources":["../../../0-framework/0-foundation/foundation/dist/result.mjs"],"sourcesContent":["import { t as blindCast } from \"./casts-DpaahrlC.mjs\";\nimport { t as InternalError } from \"./internal-error-BIc-ehme.mjs\";\n//#region src/result.ts\n/**\n* Generic Result type for representing success or failure outcomes.\n*\n* This is the standard way to return \"expected failures\" as values rather than\n* throwing exceptions. See docs/Error Handling.md for the full taxonomy.\n*\n* Naming rationale:\n* - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator\n* - `NotOk` avoids collision with domain types like \"Failure\" or \"Error\"\n* - `failure` property distinguishes from JS Error semantics\n*/\n/**\n* Result class that implements both Ok and NotOk variants.\n*/\nvar ResultImpl = class ResultImpl {\n\tok;\n\t_value;\n\t_failure;\n\tconstructor(ok, valueOrFailure) {\n\t\tthis.ok = ok;\n\t\tif (ok) this._value = blindCast(valueOrFailure);\n\t\telse this._failure = blindCast(valueOrFailure);\n\t\tObject.freeze(this);\n\t}\n\tget value() {\n\t\tif (!this.ok) throw new InternalError(\"Cannot access value on NotOk result\");\n\t\treturn this._value;\n\t}\n\tget failure() {\n\t\tif (this.ok) throw new InternalError(\"Cannot access failure on Ok result\");\n\t\treturn this._failure;\n\t}\n\t/**\n\t* Creates a successful result.\n\t*/\n\tstatic ok(value) {\n\t\treturn blindCast(new ResultImpl(true, value));\n\t}\n\t/**\n\t* Creates an unsuccessful result.\n\t*/\n\tstatic notOk(failure) {\n\t\treturn blindCast(new ResultImpl(false, failure));\n\t}\n\t/**\n\t* Asserts that this result is Ok and returns the value.\n\t* Throws if the result is NotOk.\n\t*/\n\tassertOk() {\n\t\tif (!this.ok) throw new InternalError(\"Expected Ok result but got NotOk\");\n\t\treturn this.value;\n\t}\n\t/**\n\t* Asserts that this result is NotOk and returns the failure.\n\t* Throws if the result is Ok.\n\t*/\n\tassertNotOk() {\n\t\tif (this.ok) throw new InternalError(\"Expected NotOk result but got Ok\");\n\t\treturn this.failure;\n\t}\n};\n/**\n* Creates a successful result.\n*/\nfunction ok(value) {\n\treturn ResultImpl.ok(value);\n}\n/**\n* Creates an unsuccessful result.\n*/\nfunction notOk(failure) {\n\treturn ResultImpl.notOk(failure);\n}\n/**\n* Singleton for void success results.\n* Use this for validation checks that don't produce a value.\n*/\nconst OK_VOID = ResultImpl.ok(void 0);\n/**\n* Returns a successful void result.\n* Use this for validation checks that don't produce a value.\n*/\nfunction okVoid() {\n\treturn OK_VOID;\n}\n//#endregion\nexport { notOk, ok, okVoid };\n\n//# sourceMappingURL=result.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,IAAI,aAAa,MAAM,WAAW;CACjC;CACA;CACA;CACA,YAAY,IAAI,gBAAgB;EAC/B,KAAK,KAAK;EACV,IAAI,IAAI,KAAK,SAAS,UAAU,cAAc;OACzC,KAAK,WAAW,UAAU,cAAc;EAC7C,OAAO,OAAO,IAAI;CACnB;CACA,IAAI,QAAQ;EACX,IAAI,CAAC,KAAK,IAAI,MAAM,IAAI,cAAc,qCAAqC;EAC3E,OAAO,KAAK;CACb;CACA,IAAI,UAAU;EACb,IAAI,KAAK,IAAI,MAAM,IAAI,cAAc,oCAAoC;EACzE,OAAO,KAAK;CACb;;;;CAIA,OAAO,GAAG,OAAO;EAChB,OAAO,UAAU,IAAI,WAAW,MAAM,KAAK,CAAC;CAC7C;;;;CAIA,OAAO,MAAM,SAAS;EACrB,OAAO,UAAU,IAAI,WAAW,OAAO,OAAO,CAAC;CAChD;;;;;CAKA,WAAW;EACV,IAAI,CAAC,KAAK,IAAI,MAAM,IAAI,cAAc,kCAAkC;EACxE,OAAO,KAAK;CACb;;;;;CAKA,cAAc;EACb,IAAI,KAAK,IAAI,MAAM,IAAI,cAAc,kCAAkC;EACvE,OAAO,KAAK;CACb;AACD;;;;AAIA,SAAS,GAAG,OAAO;CAClB,OAAO,WAAW,GAAG,KAAK;AAC3B;;;;AAIA,SAAS,MAAM,SAAS;CACvB,OAAO,WAAW,MAAM,OAAO;AAChC;;;;;AAKA,MAAM,UAAU,WAAW,GAAG,KAAK,CAAC;;;;;AAKpC,SAAS,SAAS;CACjB,OAAO;AACR"}

package/dist/run-alchemy-D44OZlyB-DA7s331N.mjs

@@ -0,0 +1,93 @@
+import { c as CliStructuredError } from "./result-B4XjxVK6.mjs";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+//#region ../../0-framework/3-tooling/cli/dist/run-alchemy-D44OZlyB.mjs
+/**
+* Pipeline step 7 (deploy-cli.md § The pipeline; design-notes.md's "Driving
+* Alchemy" call): hand the terminal to the generated stack file. Resolves the
+* workspace's own installed `alchemy` bin (walking up `node_modules/.bin`
+* from the generated file's package dir) rather than going through
+* `bunx`/`npx`, so this works the same under node and bun — the resolved
+* bin's own launcher (`alchemy/bin/cli.js`) does its own node/bun dispatch
+* from there, driven by the env it inherits.
+*
+* This module composes the invocation; it does not decide how the child is
+* started. Under the CLI the engine starts it (`ctx.spawn`), which is what
+* makes Ctrl-C reach the child natively and keeps signal policy in one place.
+* `spawnAlchemy` is the default for programmatic hosts driving
+* `@prisma/composer/control`, which have no engine to borrow.
+*/
+/** Walks up from `startDir` looking for `node_modules/.bin/alchemy`. */
+function resolveAlchemyBin(startDir) {
+	let dir = startDir;
+	while (true) {
+		const candidate = path.join(dir, "node_modules", ".bin", "alchemy");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new CliStructuredError("DEPLOY.ALCHEMY_BIN_MISSING", `Could not find an installed \`alchemy\` bin above "${startDir}".`, { fix: "Add \"alchemy\" as a dependency of your app." });
+		dir = parent;
+	}
+}
+/**
+* Resolves the invocation against this machine — the step every adapter takes
+* and no caller should. Raises DEPLOY.ALCHEMY_BIN_MISSING when the app has no
+* alchemy installed.
+*/
+function alchemyCommandLine(invocation) {
+	return {
+		command: resolveAlchemyBin(invocation.cwd),
+		args: [
+			invocation.action,
+			invocation.stackFileRelativePath,
+			"--yes",
+			"--stage",
+			invocation.stage
+		],
+		cwd: invocation.cwd,
+		env: invocation.env
+	};
+}
+/** What becomes `alchemy deploy|destroy <stack file> --yes --stage <stage>`. */
+function alchemyInvocation(input) {
+	return {
+		action: input.command,
+		stackFileRelativePath: input.stackFileRelativePath,
+		cwd: input.cwd,
+		stage: input.stage,
+		env: {
+			...input.containerEnv,
+			...input.env
+		}
+	};
+}
+/**
+* The default runner for hosts with no engine: inherited stdio, the caller's
+* own process group, and the child's status returned verbatim. It does not
+* collapse a signal into an exit code — that collapse is what made a
+* Ctrl-C'd deploy report itself as a failure.
+*/
+const spawnAlchemy = async (invocation) => {
+	const line = alchemyCommandLine(invocation);
+	return new Promise((resolve, reject) => {
+		const child = spawn(line.command, [...line.args], {
+			cwd: line.cwd,
+			stdio: "inherit",
+			env: {
+				...process.env,
+				...line.env
+			}
+		});
+		child.on("error", reject);
+		child.on("close", (exitCode, signal) => {
+			resolve({
+				exitCode,
+				signal
+			});
+		});
+	});
+};
+//#endregion
+export { alchemyInvocation as n, spawnAlchemy as r, alchemyCommandLine as t };
+
+//# sourceMappingURL=run-alchemy-D44OZlyB-DA7s331N.mjs.map

package/dist/run-alchemy-D44OZlyB-DA7s331N.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-alchemy-D44OZlyB-DA7s331N.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/run-alchemy-D44OZlyB.mjs"],"sourcesContent":["import { CliStructuredError } from \"@internal/foundation/errors\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { spawn } from \"node:child_process\";\n//#region src/run-alchemy.ts\n/**\n* Pipeline step 7 (deploy-cli.md § The pipeline; design-notes.md's \"Driving\n* Alchemy\" call): hand the terminal to the generated stack file. Resolves the\n* workspace's own installed `alchemy` bin (walking up `node_modules/.bin`\n* from the generated file's package dir) rather than going through\n* `bunx`/`npx`, so this works the same under node and bun — the resolved\n* bin's own launcher (`alchemy/bin/cli.js`) does its own node/bun dispatch\n* from there, driven by the env it inherits.\n*\n* This module composes the invocation; it does not decide how the child is\n* started. Under the CLI the engine starts it (`ctx.spawn`), which is what\n* makes Ctrl-C reach the child natively and keeps signal policy in one place.\n* `spawnAlchemy` is the default for programmatic hosts driving\n* `@prisma/composer/control`, which have no engine to borrow.\n*/\n/** Walks up from `startDir` looking for `node_modules/.bin/alchemy`. */\nfunction resolveAlchemyBin(startDir) {\n\tlet dir = startDir;\n\twhile (true) {\n\t\tconst candidate = path.join(dir, \"node_modules\", \".bin\", \"alchemy\");\n\t\tif (fs.existsSync(candidate)) return candidate;\n\t\tconst parent = path.dirname(dir);\n\t\tif (parent === dir) throw new CliStructuredError(\"DEPLOY.ALCHEMY_BIN_MISSING\", `Could not find an installed \\`alchemy\\` bin above \"${startDir}\".`, { fix: \"Add \\\"alchemy\\\" as a dependency of your app.\" });\n\t\tdir = parent;\n\t}\n}\n/**\n* Resolves the invocation against this machine — the step every adapter takes\n* and no caller should. Raises DEPLOY.ALCHEMY_BIN_MISSING when the app has no\n* alchemy installed.\n*/\nfunction alchemyCommandLine(invocation) {\n\treturn {\n\t\tcommand: resolveAlchemyBin(invocation.cwd),\n\t\targs: [\n\t\t\tinvocation.action,\n\t\t\tinvocation.stackFileRelativePath,\n\t\t\t\"--yes\",\n\t\t\t\"--stage\",\n\t\t\tinvocation.stage\n\t\t],\n\t\tcwd: invocation.cwd,\n\t\tenv: invocation.env\n\t};\n}\n/** What becomes `alchemy deploy|destroy <stack file> --yes --stage <stage>`. */\nfunction alchemyInvocation(input) {\n\treturn {\n\t\taction: input.command,\n\t\tstackFileRelativePath: input.stackFileRelativePath,\n\t\tcwd: input.cwd,\n\t\tstage: input.stage,\n\t\tenv: {\n\t\t\t...input.containerEnv,\n\t\t\t...input.env\n\t\t}\n\t};\n}\n/**\n* The default runner for hosts with no engine: inherited stdio, the caller's\n* own process group, and the child's status returned verbatim. It does not\n* collapse a signal into an exit code — that collapse is what made a\n* Ctrl-C'd deploy report itself as a failure.\n*/\nconst spawnAlchemy = async (invocation) => {\n\tconst line = alchemyCommandLine(invocation);\n\treturn new Promise((resolve, reject) => {\n\t\tconst child = spawn(line.command, [...line.args], {\n\t\t\tcwd: line.cwd,\n\t\t\tstdio: \"inherit\",\n\t\t\tenv: {\n\t\t\t\t...process.env,\n\t\t\t\t...line.env\n\t\t\t}\n\t\t});\n\t\tchild.on(\"error\", reject);\n\t\tchild.on(\"close\", (exitCode, signal) => {\n\t\t\tresolve({\n\t\t\t\texitCode,\n\t\t\t\tsignal\n\t\t\t});\n\t\t});\n\t});\n};\n//#endregion\nexport { spawnAlchemy as i, alchemyInvocation as n, resolveAlchemyBin as r, alchemyCommandLine as t };\n\n//# sourceMappingURL=run-alchemy-D44OZlyB.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAS,kBAAkB,UAAU;CACpC,IAAI,MAAM;CACV,OAAO,MAAM;EACZ,MAAM,YAAY,KAAK,KAAK,KAAK,gBAAgB,QAAQ,SAAS;EAClE,IAAI,GAAG,WAAW,SAAS,GAAG,OAAO;EACrC,MAAM,SAAS,KAAK,QAAQ,GAAG;EAC/B,IAAI,WAAW,KAAK,MAAM,IAAI,mBAAmB,8BAA8B,sDAAsD,SAAS,KAAK,EAAE,KAAK,+CAA+C,CAAC;EAC1M,MAAM;CACP;AACD;;;;;;AAMA,SAAS,mBAAmB,YAAY;CACvC,OAAO;EACN,SAAS,kBAAkB,WAAW,GAAG;EACzC,MAAM;GACL,WAAW;GACX,WAAW;GACX;GACA;GACA,WAAW;EACZ;EACA,KAAK,WAAW;EAChB,KAAK,WAAW;CACjB;AACD;;AAEA,SAAS,kBAAkB,OAAO;CACjC,OAAO;EACN,QAAQ,MAAM;EACd,uBAAuB,MAAM;EAC7B,KAAK,MAAM;EACX,OAAO,MAAM;EACb,KAAK;GACJ,GAAG,MAAM;GACT,GAAG,MAAM;EACV;CACD;AACD;;;;;;;AAOA,MAAM,eAAe,OAAO,eAAe;CAC1C,MAAM,OAAO,mBAAmB,UAAU;CAC1C,OAAO,IAAI,SAAS,SAAS,WAAW;EACvC,MAAM,QAAQ,MAAM,KAAK,SAAS,CAAC,GAAG,KAAK,IAAI,GAAG;GACjD,KAAK,KAAK;GACV,OAAO;GACP,KAAK;IACJ,GAAG,QAAQ;IACX,GAAG,KAAK;GACT;EACD,CAAC;EACD,MAAM,GAAG,SAAS,MAAM;EACxB,MAAM,GAAG,UAAU,UAAU,WAAW;GACvC,QAAQ;IACP;IACA;GACD,CAAC;EACF,CAAC;CACF,CAAC;AACF"}

package/dist/run-alchemy-D44OZlyB-DeDTFsB6.mjs

@@ -0,0 +1,93 @@
+import { t as CliStructuredError } from "./errors-DkXcnjPx.mjs";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+//#region ../../0-framework/3-tooling/cli/dist/run-alchemy-D44OZlyB.mjs
+/**
+* Pipeline step 7 (deploy-cli.md § The pipeline; design-notes.md's "Driving
+* Alchemy" call): hand the terminal to the generated stack file. Resolves the
+* workspace's own installed `alchemy` bin (walking up `node_modules/.bin`
+* from the generated file's package dir) rather than going through
+* `bunx`/`npx`, so this works the same under node and bun — the resolved
+* bin's own launcher (`alchemy/bin/cli.js`) does its own node/bun dispatch
+* from there, driven by the env it inherits.
+*
+* This module composes the invocation; it does not decide how the child is
+* started. Under the CLI the engine starts it (`ctx.spawn`), which is what
+* makes Ctrl-C reach the child natively and keeps signal policy in one place.
+* `spawnAlchemy` is the default for programmatic hosts driving
+* `@prisma/composer/control`, which have no engine to borrow.
+*/
+/** Walks up from `startDir` looking for `node_modules/.bin/alchemy`. */
+function resolveAlchemyBin(startDir) {
+	let dir = startDir;
+	while (true) {
+		const candidate = path.join(dir, "node_modules", ".bin", "alchemy");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new CliStructuredError("DEPLOY.ALCHEMY_BIN_MISSING", `Could not find an installed \`alchemy\` bin above "${startDir}".`, { fix: "Add \"alchemy\" as a dependency of your app." });
+		dir = parent;
+	}
+}
+/**
+* Resolves the invocation against this machine — the step every adapter takes
+* and no caller should. Raises DEPLOY.ALCHEMY_BIN_MISSING when the app has no
+* alchemy installed.
+*/
+function alchemyCommandLine(invocation) {
+	return {
+		command: resolveAlchemyBin(invocation.cwd),
+		args: [
+			invocation.action,
+			invocation.stackFileRelativePath,
+			"--yes",
+			"--stage",
+			invocation.stage
+		],
+		cwd: invocation.cwd,
+		env: invocation.env
+	};
+}
+/** What becomes `alchemy deploy|destroy <stack file> --yes --stage <stage>`. */
+function alchemyInvocation(input) {
+	return {
+		action: input.command,
+		stackFileRelativePath: input.stackFileRelativePath,
+		cwd: input.cwd,
+		stage: input.stage,
+		env: {
+			...input.containerEnv,
+			...input.env
+		}
+	};
+}
+/**
+* The default runner for hosts with no engine: inherited stdio, the caller's
+* own process group, and the child's status returned verbatim. It does not
+* collapse a signal into an exit code — that collapse is what made a
+* Ctrl-C'd deploy report itself as a failure.
+*/
+const spawnAlchemy = async (invocation) => {
+	const line = alchemyCommandLine(invocation);
+	return new Promise((resolve, reject) => {
+		const child = spawn(line.command, [...line.args], {
+			cwd: line.cwd,
+			stdio: "inherit",
+			env: {
+				...process.env,
+				...line.env
+			}
+		});
+		child.on("error", reject);
+		child.on("close", (exitCode, signal) => {
+			resolve({
+				exitCode,
+				signal
+			});
+		});
+	});
+};
+//#endregion
+export { alchemyInvocation as n, spawnAlchemy as r, alchemyCommandLine as t };
+
+//# sourceMappingURL=run-alchemy-D44OZlyB-DeDTFsB6.mjs.map

package/dist/run-alchemy-D44OZlyB-DeDTFsB6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-alchemy-D44OZlyB-DeDTFsB6.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/run-alchemy-D44OZlyB.mjs"],"sourcesContent":["import { CliStructuredError } from \"@internal/foundation/errors\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { spawn } from \"node:child_process\";\n//#region src/run-alchemy.ts\n/**\n* Pipeline step 7 (deploy-cli.md § The pipeline; design-notes.md's \"Driving\n* Alchemy\" call): hand the terminal to the generated stack file. Resolves the\n* workspace's own installed `alchemy` bin (walking up `node_modules/.bin`\n* from the generated file's package dir) rather than going through\n* `bunx`/`npx`, so this works the same under node and bun — the resolved\n* bin's own launcher (`alchemy/bin/cli.js`) does its own node/bun dispatch\n* from there, driven by the env it inherits.\n*\n* This module composes the invocation; it does not decide how the child is\n* started. Under the CLI the engine starts it (`ctx.spawn`), which is what\n* makes Ctrl-C reach the child natively and keeps signal policy in one place.\n* `spawnAlchemy` is the default for programmatic hosts driving\n* `@prisma/composer/control`, which have no engine to borrow.\n*/\n/** Walks up from `startDir` looking for `node_modules/.bin/alchemy`. */\nfunction resolveAlchemyBin(startDir) {\n\tlet dir = startDir;\n\twhile (true) {\n\t\tconst candidate = path.join(dir, \"node_modules\", \".bin\", \"alchemy\");\n\t\tif (fs.existsSync(candidate)) return candidate;\n\t\tconst parent = path.dirname(dir);\n\t\tif (parent === dir) throw new CliStructuredError(\"DEPLOY.ALCHEMY_BIN_MISSING\", `Could not find an installed \\`alchemy\\` bin above \"${startDir}\".`, { fix: \"Add \\\"alchemy\\\" as a dependency of your app.\" });\n\t\tdir = parent;\n\t}\n}\n/**\n* Resolves the invocation against this machine — the step every adapter takes\n* and no caller should. Raises DEPLOY.ALCHEMY_BIN_MISSING when the app has no\n* alchemy installed.\n*/\nfunction alchemyCommandLine(invocation) {\n\treturn {\n\t\tcommand: resolveAlchemyBin(invocation.cwd),\n\t\targs: [\n\t\t\tinvocation.action,\n\t\t\tinvocation.stackFileRelativePath,\n\t\t\t\"--yes\",\n\t\t\t\"--stage\",\n\t\t\tinvocation.stage\n\t\t],\n\t\tcwd: invocation.cwd,\n\t\tenv: invocation.env\n\t};\n}\n/** What becomes `alchemy deploy|destroy <stack file> --yes --stage <stage>`. */\nfunction alchemyInvocation(input) {\n\treturn {\n\t\taction: input.command,\n\t\tstackFileRelativePath: input.stackFileRelativePath,\n\t\tcwd: input.cwd,\n\t\tstage: input.stage,\n\t\tenv: {\n\t\t\t...input.containerEnv,\n\t\t\t...input.env\n\t\t}\n\t};\n}\n/**\n* The default runner for hosts with no engine: inherited stdio, the caller's\n* own process group, and the child's status returned verbatim. It does not\n* collapse a signal into an exit code — that collapse is what made a\n* Ctrl-C'd deploy report itself as a failure.\n*/\nconst spawnAlchemy = async (invocation) => {\n\tconst line = alchemyCommandLine(invocation);\n\treturn new Promise((resolve, reject) => {\n\t\tconst child = spawn(line.command, [...line.args], {\n\t\t\tcwd: line.cwd,\n\t\t\tstdio: \"inherit\",\n\t\t\tenv: {\n\t\t\t\t...process.env,\n\t\t\t\t...line.env\n\t\t\t}\n\t\t});\n\t\tchild.on(\"error\", reject);\n\t\tchild.on(\"close\", (exitCode, signal) => {\n\t\t\tresolve({\n\t\t\t\texitCode,\n\t\t\t\tsignal\n\t\t\t});\n\t\t});\n\t});\n};\n//#endregion\nexport { spawnAlchemy as i, alchemyInvocation as n, resolveAlchemyBin as r, alchemyCommandLine as t };\n\n//# sourceMappingURL=run-alchemy-D44OZlyB.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAS,kBAAkB,UAAU;CACpC,IAAI,MAAM;CACV,OAAO,MAAM;EACZ,MAAM,YAAY,KAAK,KAAK,KAAK,gBAAgB,QAAQ,SAAS;EAClE,IAAI,GAAG,WAAW,SAAS,GAAG,OAAO;EACrC,MAAM,SAAS,KAAK,QAAQ,GAAG;EAC/B,IAAI,WAAW,KAAK,MAAM,IAAI,mBAAmB,8BAA8B,sDAAsD,SAAS,KAAK,EAAE,KAAK,+CAA+C,CAAC;EAC1M,MAAM;CACP;AACD;;;;;;AAMA,SAAS,mBAAmB,YAAY;CACvC,OAAO;EACN,SAAS,kBAAkB,WAAW,GAAG;EACzC,MAAM;GACL,WAAW;GACX,WAAW;GACX;GACA;GACA,WAAW;EACZ;EACA,KAAK,WAAW;EAChB,KAAK,WAAW;CACjB;AACD;;AAEA,SAAS,kBAAkB,OAAO;CACjC,OAAO;EACN,QAAQ,MAAM;EACd,uBAAuB,MAAM;EAC7B,KAAK,MAAM;EACX,OAAO,MAAM;EACb,KAAK;GACJ,GAAG,MAAM;GACT,GAAG,MAAM;EACV;CACD;AACD;;;;;;;AAOA,MAAM,eAAe,OAAO,eAAe;CAC1C,MAAM,OAAO,mBAAmB,UAAU;CAC1C,OAAO,IAAI,SAAS,SAAS,WAAW;EACvC,MAAM,QAAQ,MAAM,KAAK,SAAS,CAAC,GAAG,KAAK,IAAI,GAAG;GACjD,KAAK,KAAK;GACV,OAAO;GACP,KAAK;IACJ,GAAG,QAAQ;IACX,GAAG,KAAK;GACT;EACD,CAAC;EACD,MAAM,GAAG,SAAS,MAAM;EACxB,MAAM,GAAG,UAAU,UAAU,WAAW;GACvC,QAAQ;IACP;IACA;GACD,CAAC;EACF,CAAC;CACF,CAAC;AACF"}

package/dist/service-rpc.d.mts

@@ -1,5 +1,5 @@
-import { L as RunnableServiceNode, M as ProvisionNeed, o as Contract, s as DependencyEnd } from "./graph-types-N6brq1zY-1VMNwtkJ.mjs";
-import "./index-DryPyF9U.mjs";
+import { N as ProvisionNeed, R as RunnableServiceNode, c as DependencyEnd, s as Contract } from "./graph-DqklX5Sf-CdNH3lA7.mjs";
+import "./index-DuF5iI3i.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region ../../0-framework/2-authoring/service-rpc/dist/index.d.mts
 //#region src/rpc.d.ts

package/dist/service-rpc.mjs

@@ -1,6 +1,6 @@
 import { t as blindCast } from "./casts-DpaahrlC-C5XMnP9S.mjs";
-import { i as dependency, p as provisionNeed } from "./graph-BJgUfGB0-kvgFzT4q.mjs";
-import { c as string } from "./dist-C5rZnr4n.mjs";
+import { i as dependency, p as provisionNeed } from "./graph-BJgUfGB0-7fmubS_y.mjs";
+import { c as string } from "./dist-C0dNEgS-.mjs";
 //#region ../../0-framework/2-authoring/service-rpc/dist/index.mjs
 /** Bounded jittered backoff for retrying a dropped call. `maxRetries` is retries after the first attempt. */
 const RETRY = {

package/dist/testing.d.mts

@@ -1,5 +1,57 @@
-import { L as RunnableServiceNode, c as Deps, j as Params, m as HydratedDeps, u as Expose } from "./graph-types-N6brq1zY-1VMNwtkJ.mjs";
+import { M as Params, R as RunnableServiceNode, d as Expose, ft as CliStructuredError, h as HydratedDeps, l as Deps } from "./graph-DqklX5Sf-CdNH3lA7.mjs";
+import { A as Result, _ as OperationDeps, a as DestroyEvent, f as LogAttached, g as LogLine, h as LogInput, l as DevInput, n as DeploySuccess, o as DestroyInput, p as LogDeps, t as DeployInput, u as DevSession, v as ServiceEndpoint } from "./log-DRnnWupy-9jbzL64M.mjs";
+import { t as ComposerOperations } from "./family-DkH0si4D-Uov_MuHV.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region ../../0-framework/3-tooling/cli/dist/testing.d.mts
+//#region src/testing/control-double.d.ts
+interface ControlDoubleFixtures {
+  /** Returned as-is; pass notOk(error) for a failing deploy. Default: ok with no summary. */
+  readonly deploy?: Result<DeploySuccess, CliStructuredError> | undefined;
+  /** Returned as-is. Default: ok. */
+  readonly destroy?: Result<void, CliStructuredError> | undefined;
+  /** Delivered to the caller's onEvent, in order, before destroy resolves. */
+  readonly destroyEvents?: readonly DestroyEvent[] | undefined;
+  /**
+   * A failing dev: returned as-is, no session starts. When absent, dev
+   * succeeds with a working DevSession double over `devEndpoints`.
+   */
+  readonly dev?: Result<DevSession, CliStructuredError> | undefined;
+  /** The session's front door; emitted as the initial 'ready' event, like the real operation's. */
+  readonly devEndpoints?: readonly ServiceEndpoint[] | undefined;
+  /** A failing log: returned as-is. When absent, log attaches over the fixtures below. */
+  readonly log?: Result<LogAttached, CliStructuredError> | undefined;
+  readonly logAppName?: string | undefined;
+  readonly logServices?: readonly ServiceEndpoint[] | undefined;
+  /** Replayed through the attachment's stream, then the stream ends (or ends early on signal abort). */
+  readonly logLines?: readonly LogLine[] | undefined;
+}
+/**
+ * The deps each call carried, in the same order as the inputs beside them.
+ * These are the operation's SECOND argument — the seam the config path, the
+ * converge spawn adapter and the credentials ride in on — so a host that
+ * drops one of those is caught here rather than by its absence downstream.
+ */
+interface ControlDoubleDeps {
+  readonly deploy: readonly OperationDeps[];
+  readonly destroy: readonly OperationDeps[];
+  readonly dev: readonly OperationDeps[];
+  readonly log: readonly LogDeps[];
+}
+/** Every input each operation received, in call order — the assertion surface. */
+interface ControlDoubleCalls {
+  readonly deploy: readonly DeployInput[];
+  readonly destroy: readonly DestroyInput[];
+  readonly dev: readonly DevInput[];
+  readonly log: readonly LogInput[];
+  readonly deps: ControlDoubleDeps;
+}
+interface ControlDouble {
+  /** Drop-in for the real operations: hand to createComposerFamily({ operations }). */
+  readonly operations: ComposerOperations;
+  readonly calls: ControlDoubleCalls;
+}
+declare function createControlDouble(fixtures?: ControlDoubleFixtures): ControlDouble;
+//#endregion
 //#region ../../0-framework/1-core/core/dist/testing.d.mts
 //#region src/testing.d.ts
 /**
@@ -25,5 +77,5 @@ type LoadOverrides<D extends Deps, I extends StandardSchemaV1 | undefined> = Hyd
  */
 declare function mockService<D extends Deps, P extends Params, E extends Expose, I extends StandardSchemaV1 | undefined>(service: RunnableServiceNode<D, P, E, I>, overrides: LoadOverrides<D, I>): RunnableServiceNode<D, P, E, I>;
 //#endregion
-export { LoadOverrides, mockService };
+export { type ControlDouble, type ControlDoubleCalls, type ControlDoubleFixtures, LoadOverrides, createControlDouble, mockService };
 //# sourceMappingURL=testing.d.mts.map

package/dist/testing.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/testing.d.mts"],"mappings":";;;;;;;;;;;;KAWK,cAAc,UAAU,MAAM,UAAU,gCAAgC,aAAa,MAAM,UAAU;EACxG,OAAO,iBAAiB,YAAY;;EAEpC;;;;;;;;;;iBAUe,YAAY,UAAU,MAAM,UAAU,QAAQ,UAAU,QAAQ,UAAU,8BAA8B,SAAS,oBAAoB,GAAG,GAAG,GAAG,IAAI,WAAW,cAAc,GAAG,KAAK,oBAAoB,GAAG,GAAG,GAAG"}
+{"version":3,"file":"testing.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/testing.d.mts","../../../0-framework/1-core/core/dist/testing.d.mts"],"mappings":";;;;;;UAKU;;WAEC,SAAS,OAAO,eAAe;;WAE/B,UAAU,aAAa;;WAEvB,yBAAyB;;;;;WAKzB,MAAM,OAAO,YAAY;;WAEzB,wBAAwB;;WAExB,MAAM,OAAO,aAAa;WAC1B;WACA,uBAAuB;;WAEvB,oBAAoB;;;;;;;;UAQrB;WACC,iBAAiB;WACjB,kBAAkB;WAClB,cAAc;WACd,cAAc;;;UAGf;WACC,iBAAiB;WACjB,kBAAkB;WAClB,cAAc;WACd,cAAc;WACd,MAAM;;UAEP;;WAEC,YAAY;WACZ,OAAO;;iBAED,oBAAoB,WAAW,wBAAwB;;;;;;;;;;;;KCxCnE,cAAc,UAAU,MAAM,UAAU,gCAAgC,aAAa,MAAM,UAAU;EACxG,OAAO,iBAAiB,YAAY;;EAEpC;;;;;;;;;;iBAUe,YAAY,UAAU,MAAM,UAAU,QAAQ,UAAU,QAAQ,UAAU,8BAA8B,SAAS,oBAAoB,GAAG,GAAG,GAAG,IAAI,WAAW,cAAc,GAAG,KAAK,oBAAoB,GAAG,GAAG,GAAG"}

package/dist/testing.mjs

@@ -1,4 +1,153 @@
 import { t as blindCast } from "./casts-DpaahrlC-C5XMnP9S.mjs";
+import { t as CliStructuredError } from "./errors-DkXcnjPx.mjs";
+import { n as ok, r as okVoid, t as notOk } from "./result-wonf1deB.mjs";
+//#region ../../0-framework/3-tooling/cli/dist/testing.mjs
+/**
+* The published control-API double (`@prisma/composer/testing`): the four
+* control operations with their real signatures and Result shapes, backed by
+* fixtures instead of alchemy, containers, or a network.
+*
+* Hosts that mount composer's command family — prisma-cli above all — test
+* against this instead of the real operations, so their suites never spawn a
+* converge and their typecheck never needs the alchemy/effect constellation.
+* The conformance guarantee is carried by the types: `ComposerOperations` is
+* defined as `typeof deployWithDeps` (etc.) of the REAL operations, and the
+* double is declared against it, so a drift in any real signature fails
+* `tsc --noEmit` right here. Every import of implementation modules is
+* type-only and erases
+* at build — the built `testing` chunk must contain no path to the real
+* control implementation, which scripts/check-family-static-graph.mjs proves
+* against the packed tarball.
+*/
+function devSessionDouble(input, endpoints) {
+	let resolveClosed;
+	const closed = new Promise((resolve) => {
+		resolveClosed = resolve;
+	});
+	let stopped = false;
+	input.onEvent?.({
+		kind: "ready",
+		endpoints
+	});
+	return {
+		endpoints,
+		closed,
+		stop: async () => {
+			if (stopped) return;
+			stopped = true;
+			input.onEvent?.({ kind: "stopping" });
+			input.onEvent?.({ kind: "stopped" });
+			resolveClosed();
+		}
+	};
+}
+async function* replayLines(lines, address, signal) {
+	for (const line of lines) {
+		if (signal?.aborted === true) return;
+		if (address !== void 0 && line.service !== address) continue;
+		yield line;
+	}
+}
+/**
+* Runs the caller's converge adapter, when it supplied one, against a
+* synthetic invocation — no alchemy bin is resolved and no real child is
+* started; the adapter decides what the child does.
+*
+* This is what makes a host's tests cover the settlement rules rather than
+* just the grammar: a scripted fake child that exits non-zero, or is killed
+* by a signal, produces the same failure shape the real executor produces, so
+* the handler's settlement — and the engine's own child-status settlement
+* behind it — is genuinely exercised. Returns undefined when no adapter was
+* injected, leaving the fixture result untouched.
+*/
+async function runConverge(action, deps, cwd) {
+	if (deps.alchemy === void 0) return void 0;
+	const stackFilePath = ".prisma-composer/alchemy.run.ts";
+	const reproduceCommand = `alchemy ${action} ${stackFilePath} --yes --stage test`;
+	const workingDirectory = cwd ?? ".";
+	const outcome = await deps.alchemy({
+		action,
+		stackFileRelativePath: stackFilePath,
+		cwd: workingDirectory,
+		stage: "test",
+		env: {}
+	});
+	if (outcome.signal !== null) return notOk(new CliStructuredError("DEPLOY.ENGINE_FAILED", `alchemy ${action} was interrupted by ${outcome.signal}.`, { meta: {
+		signal: outcome.signal,
+		diagnostics: {
+			exitCode: void 0,
+			signal: outcome.signal,
+			stackFilePath,
+			reproduceCommand,
+			cwd: workingDirectory
+		}
+	} }));
+	const status = outcome.exitCode ?? 1;
+	if (status === 0) return void 0;
+	return notOk(new CliStructuredError("DEPLOY.ENGINE_FAILED", `alchemy ${action} exited with status ${status}.`, { meta: {
+		exitCode: status,
+		diagnostics: {
+			exitCode: status,
+			stackFilePath,
+			reproduceCommand,
+			cwd: workingDirectory
+		}
+	} }));
+}
+function createControlDouble(fixtures = {}) {
+	const deployCalls = [];
+	const destroyCalls = [];
+	const devCalls = [];
+	const logCalls = [];
+	const deps = {
+		deploy: [],
+		destroy: [],
+		dev: [],
+		log: []
+	};
+	const calls = {
+		deploy: deployCalls,
+		destroy: destroyCalls,
+		dev: devCalls,
+		log: logCalls,
+		deps
+	};
+	return {
+		operations: {
+			deploy: async (input, operationDeps) => {
+				calls.deploy.push(input);
+				deps.deploy.push(operationDeps);
+				const converge = await runConverge("deploy", operationDeps, input.cwd);
+				if (converge !== void 0) return converge;
+				return fixtures.deploy ?? ok({ summary: void 0 });
+			},
+			destroy: async (input, operationDeps) => {
+				calls.destroy.push(input);
+				deps.destroy.push(operationDeps);
+				for (const event of fixtures.destroyEvents ?? []) input.onEvent?.(event);
+				const converge = await runConverge("destroy", operationDeps, input.cwd);
+				if (converge !== void 0) return converge;
+				return fixtures.destroy ?? okVoid();
+			},
+			dev: async (input, operationDeps) => {
+				calls.dev.push(input);
+				deps.dev.push(operationDeps);
+				return fixtures.dev ?? ok(devSessionDouble(input, fixtures.devEndpoints ?? []));
+			},
+			log: async (input, logDeps) => {
+				calls.log.push(input);
+				deps.log.push(logDeps);
+				return fixtures.log ?? ok({
+					appName: fixtures.logAppName ?? "app",
+					services: fixtures.logServices ?? [],
+					lines: replayLines(fixtures.logLines ?? [], input.address, input.signal)
+				});
+			}
+		},
+		calls
+	};
+}
+//#endregion
 //#region ../../0-framework/1-core/core/dist/testing.mjs
 /**
 * The unit-test seam (testing.md § Unit): `mockService` replaces a service
@@ -32,6 +181,6 @@ function mockService(service, overrides) {
 	});
 }
 //#endregion
-export { mockService };
+export { createControlDouble, mockService };
 
 //# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"testing.mjs","names":[],"sources":["../../../0-framework/1-core/core/dist/testing.mjs"],"sourcesContent":["import { blindCast } from \"@internal/foundation/casts\";\n//#region src/testing.ts\n/**\n* The unit-test seam (testing.md § Unit): `mockService` replaces a service\n* node's `load()` and `input()` output so any code that pulls dependencies or\n* input through them — a page, a server action, a helper — runs against typed\n* doubles with no server and no environment. Target-agnostic: every service\n* node has `load()`/`input()`. It does no module mocking; wiring the\n* substitution into a test runner (`vi.mock`, `mock.module`) stays in the test.\n* The integration seam (`bootstrapService`) is target-specific and lives in the\n* target's own testing entry (e.g. `@prisma/composer-prisma-cloud/testing`).\n*/\n/**\n* Returns a service node whose `load()` yields the dependency doubles and\n* `input()` the given input object — everything else about the node (its\n* deps, input schema, build, expose) is unchanged. The input double is NOT\n* validated: the test supplies the typed, already-validated shape directly.\n* `run()` is not meaningful on a mock (there is no boot, no environment) and\n* throws if called.\n*/\nfunction mockService(service, overrides) {\n\tconst entries = Object.entries(overrides);\n\tconst deps = blindCast(Object.fromEntries(entries.filter(([name]) => name in service.inputs)));\n\tconst input = blindCast(entries.find(([name]) => name === \"input\")?.[1]);\n\treturn Object.freeze({\n\t\t...service,\n\t\trun() {\n\t\t\tthrow new Error(`mockService(): \"${service.name}\" is a load()/input()-only mock — it has no run() (no boot, no environment).`);\n\t\t},\n\t\tload: () => deps,\n\t\tinput: () => input\n\t});\n}\n//#endregion\nexport { mockService };\n\n//# sourceMappingURL=testing.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,YAAY,SAAS,WAAW;CACxC,MAAM,UAAU,OAAO,QAAQ,SAAS;CACxC,MAAM,OAAO,UAAU,OAAO,YAAY,QAAQ,QAAQ,CAAC,UAAU,QAAQ,QAAQ,MAAM,CAAC,CAAC;CAC7F,MAAM,QAAQ,UAAU,QAAQ,MAAM,CAAC,UAAU,SAAS,OAAO,CAAC,GAAG,EAAE;CACvE,OAAO,OAAO,OAAO;EACpB,GAAG;EACH,MAAM;GACL,MAAM,IAAI,MAAM,mBAAmB,QAAQ,KAAK,6EAA6E;EAC9H;EACA,YAAY;EACZ,aAAa;CACd,CAAC;AACF"}
+{"version":3,"file":"testing.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/testing.mjs","../../../0-framework/1-core/core/dist/testing.mjs"],"sourcesContent":["import { CliStructuredError } from \"@internal/foundation/errors\";\nimport { notOk, ok, okVoid } from \"@internal/foundation/result\";\n//#region src/testing/control-double.ts\n/**\n* The published control-API double (`@prisma/composer/testing`): the four\n* control operations with their real signatures and Result shapes, backed by\n* fixtures instead of alchemy, containers, or a network.\n*\n* Hosts that mount composer's command family — prisma-cli above all — test\n* against this instead of the real operations, so their suites never spawn a\n* converge and their typecheck never needs the alchemy/effect constellation.\n* The conformance guarantee is carried by the types: `ComposerOperations` is\n* defined as `typeof deployWithDeps` (etc.) of the REAL operations, and the\n* double is declared against it, so a drift in any real signature fails\n* `tsc --noEmit` right here. Every import of implementation modules is\n* type-only and erases\n* at build — the built `testing` chunk must contain no path to the real\n* control implementation, which scripts/check-family-static-graph.mjs proves\n* against the packed tarball.\n*/\nfunction devSessionDouble(input, endpoints) {\n\tlet resolveClosed;\n\tconst closed = new Promise((resolve) => {\n\t\tresolveClosed = resolve;\n\t});\n\tlet stopped = false;\n\tinput.onEvent?.({\n\t\tkind: \"ready\",\n\t\tendpoints\n\t});\n\treturn {\n\t\tendpoints,\n\t\tclosed,\n\t\tstop: async () => {\n\t\t\tif (stopped) return;\n\t\t\tstopped = true;\n\t\t\tinput.onEvent?.({ kind: \"stopping\" });\n\t\t\tinput.onEvent?.({ kind: \"stopped\" });\n\t\t\tresolveClosed();\n\t\t}\n\t};\n}\nasync function* replayLines(lines, address, signal) {\n\tfor (const line of lines) {\n\t\tif (signal?.aborted === true) return;\n\t\tif (address !== void 0 && line.service !== address) continue;\n\t\tyield line;\n\t}\n}\n/**\n* Runs the caller's converge adapter, when it supplied one, against a\n* synthetic invocation — no alchemy bin is resolved and no real child is\n* started; the adapter decides what the child does.\n*\n* This is what makes a host's tests cover the settlement rules rather than\n* just the grammar: a scripted fake child that exits non-zero, or is killed\n* by a signal, produces the same failure shape the real executor produces, so\n* the handler's settlement — and the engine's own child-status settlement\n* behind it — is genuinely exercised. Returns undefined when no adapter was\n* injected, leaving the fixture result untouched.\n*/\nasync function runConverge(action, deps, cwd) {\n\tif (deps.alchemy === void 0) return void 0;\n\tconst stackFilePath = \".prisma-composer/alchemy.run.ts\";\n\tconst reproduceCommand = `alchemy ${action} ${stackFilePath} --yes --stage test`;\n\tconst workingDirectory = cwd ?? \".\";\n\tconst outcome = await deps.alchemy({\n\t\taction,\n\t\tstackFileRelativePath: stackFilePath,\n\t\tcwd: workingDirectory,\n\t\tstage: \"test\",\n\t\tenv: {}\n\t});\n\tif (outcome.signal !== null) return notOk(new CliStructuredError(\"DEPLOY.ENGINE_FAILED\", `alchemy ${action} was interrupted by ${outcome.signal}.`, { meta: {\n\t\tsignal: outcome.signal,\n\t\tdiagnostics: {\n\t\t\texitCode: void 0,\n\t\t\tsignal: outcome.signal,\n\t\t\tstackFilePath,\n\t\t\treproduceCommand,\n\t\t\tcwd: workingDirectory\n\t\t}\n\t} }));\n\tconst status = outcome.exitCode ?? 1;\n\tif (status === 0) return void 0;\n\treturn notOk(new CliStructuredError(\"DEPLOY.ENGINE_FAILED\", `alchemy ${action} exited with status ${status}.`, { meta: {\n\t\texitCode: status,\n\t\tdiagnostics: {\n\t\t\texitCode: status,\n\t\t\tstackFilePath,\n\t\t\treproduceCommand,\n\t\t\tcwd: workingDirectory\n\t\t}\n\t} }));\n}\nfunction createControlDouble(fixtures = {}) {\n\tconst deployCalls = [];\n\tconst destroyCalls = [];\n\tconst devCalls = [];\n\tconst logCalls = [];\n\tconst deps = {\n\t\tdeploy: [],\n\t\tdestroy: [],\n\t\tdev: [],\n\t\tlog: []\n\t};\n\tconst calls = {\n\t\tdeploy: deployCalls,\n\t\tdestroy: destroyCalls,\n\t\tdev: devCalls,\n\t\tlog: logCalls,\n\t\tdeps\n\t};\n\treturn {\n\t\toperations: {\n\t\t\tdeploy: async (input, operationDeps) => {\n\t\t\t\tcalls.deploy.push(input);\n\t\t\t\tdeps.deploy.push(operationDeps);\n\t\t\t\tconst converge = await runConverge(\"deploy\", operationDeps, input.cwd);\n\t\t\t\tif (converge !== void 0) return converge;\n\t\t\t\treturn fixtures.deploy ?? ok({ summary: void 0 });\n\t\t\t},\n\t\t\tdestroy: async (input, operationDeps) => {\n\t\t\t\tcalls.destroy.push(input);\n\t\t\t\tdeps.destroy.push(operationDeps);\n\t\t\t\tfor (const event of fixtures.destroyEvents ?? []) input.onEvent?.(event);\n\t\t\t\tconst converge = await runConverge(\"destroy\", operationDeps, input.cwd);\n\t\t\t\tif (converge !== void 0) return converge;\n\t\t\t\treturn fixtures.destroy ?? okVoid();\n\t\t\t},\n\t\t\tdev: async (input, operationDeps) => {\n\t\t\t\tcalls.dev.push(input);\n\t\t\t\tdeps.dev.push(operationDeps);\n\t\t\t\treturn fixtures.dev ?? ok(devSessionDouble(input, fixtures.devEndpoints ?? []));\n\t\t\t},\n\t\t\tlog: async (input, logDeps) => {\n\t\t\t\tcalls.log.push(input);\n\t\t\t\tdeps.log.push(logDeps);\n\t\t\t\treturn fixtures.log ?? ok({\n\t\t\t\t\tappName: fixtures.logAppName ?? \"app\",\n\t\t\t\t\tservices: fixtures.logServices ?? [],\n\t\t\t\t\tlines: replayLines(fixtures.logLines ?? [], input.address, input.signal)\n\t\t\t\t});\n\t\t\t}\n\t\t},\n\t\tcalls\n\t};\n}\n//#endregion\nexport { createControlDouble };\n\n//# sourceMappingURL=testing.mjs.map","import { blindCast } from \"@internal/foundation/casts\";\n//#region src/testing.ts\n/**\n* The unit-test seam (testing.md § Unit): `mockService` replaces a service\n* node's `load()` and `input()` output so any code that pulls dependencies or\n* input through them — a page, a server action, a helper — runs against typed\n* doubles with no server and no environment. Target-agnostic: every service\n* node has `load()`/`input()`. It does no module mocking; wiring the\n* substitution into a test runner (`vi.mock`, `mock.module`) stays in the test.\n* The integration seam (`bootstrapService`) is target-specific and lives in the\n* target's own testing entry (e.g. `@prisma/composer-prisma-cloud/testing`).\n*/\n/**\n* Returns a service node whose `load()` yields the dependency doubles and\n* `input()` the given input object — everything else about the node (its\n* deps, input schema, build, expose) is unchanged. The input double is NOT\n* validated: the test supplies the typed, already-validated shape directly.\n* `run()` is not meaningful on a mock (there is no boot, no environment) and\n* throws if called.\n*/\nfunction mockService(service, overrides) {\n\tconst entries = Object.entries(overrides);\n\tconst deps = blindCast(Object.fromEntries(entries.filter(([name]) => name in service.inputs)));\n\tconst input = blindCast(entries.find(([name]) => name === \"input\")?.[1]);\n\treturn Object.freeze({\n\t\t...service,\n\t\trun() {\n\t\t\tthrow new Error(`mockService(): \"${service.name}\" is a load()/input()-only mock — it has no run() (no boot, no environment).`);\n\t\t},\n\t\tload: () => deps,\n\t\tinput: () => input\n\t});\n}\n//#endregion\nexport { mockService };\n\n//# sourceMappingURL=testing.mjs.map"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/composer",
-  "version": "0.6.0-dev.13",
+  "version": "0.6.0-dev.15",
   "type": "module",
   "description": "Prisma Composer — build a Prisma App by composing Modules. Core authoring, deploy pipeline, the prisma-composer CLI, and the service-rpc/node/nextjs authoring surfaces.",
   "bin": {
@@ -10,6 +10,7 @@
     ".": "./dist/index.mjs",
     "./config": "./dist/config.mjs",
     "./control": "./dist/control.mjs",
+    "./family": "./dist/family.mjs",
     "./deploy": "./dist/deploy.mjs",
     "./local-target": "./dist/local-target.mjs",
     "./report": "./dist/report.mjs",
@@ -30,25 +31,25 @@
   ],
   "dependencies": {
     "@effect/vitest": "4.0.0-beta.103",
+    "@prisma/cli-engine": "0.0.7",
     "@standard-schema/spec": "^1.1.0",
     "alchemy": "2.0.0-beta.67",
     "arktype": "^2.2.3",
     "c12": "^3.3.4",
-    "clipanion": "^3.2.1",
     "effect": "4.0.0-beta.103",
     "esbuild": "^0.28.1",
     "@prisma/management-api-sdk": "^1.57.0"
   },
   "devDependencies": {
-    "@internal/assemble": "0.6.0-dev.13",
-    "@internal/cli": "0.6.0-dev.13",
-    "@internal/core": "0.6.0-dev.13",
-    "@internal/foundation": "0.6.0-dev.13",
-    "@internal/lowering": "0.6.0-dev.13",
-    "@internal/nextjs": "0.6.0-dev.13",
-    "@internal/node": "0.6.0-dev.13",
-    "@internal/service-rpc": "0.6.0-dev.13",
-    "@internal/tsdown-config": "0.6.0-dev.13",
+    "@internal/assemble": "0.6.0-dev.15",
+    "@internal/cli": "0.6.0-dev.15",
+    "@internal/core": "0.6.0-dev.15",
+    "@internal/foundation": "0.6.0-dev.15",
+    "@internal/lowering": "0.6.0-dev.15",
+    "@internal/nextjs": "0.6.0-dev.15",
+    "@internal/node": "0.6.0-dev.15",
+    "@internal/service-rpc": "0.6.0-dev.15",
+    "@internal/tsdown-config": "0.6.0-dev.15",
     "@types/node": "^26.0.1",
     "tsdown": "^0.22.7",
     "typescript": "^6.0.3"

package/src/exports/family.ts

@@ -0,0 +1,14 @@
+/**
+ * Public surface (the `./family` subpath): composer's engine `CommandFamily`,
+ * for hosts that mount composer's commands into their own CLI — the `prisma`
+ * bin does exactly this.
+ *
+ * Kept apart from `./control` on purpose. `./control` is the programmatic
+ * deploy pipeline; this is the command surface: grammar, help and arg
+ * validation belong to the engine, and the handlers behind them are the same
+ * operations `./control` exposes.
+ *
+ * Its static graph is alchemy-free and effect-free, so importing it costs a
+ * host nothing until a composer command actually runs.
+ */
+export * from '@internal/cli/family';

package/src/exports/testing.ts

@@ -1 +1,2 @@
+export * from '@internal/cli/testing';
 export * from '@internal/core/testing';

package/dist/app-config-CFsSXEVj-B242oUnm.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-config-CFsSXEVj-B242oUnm.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/app-config-CFsSXEVj.d.mts"],"mappings":"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"}