@prisma/composer-cli 0.6.0-dev.21

package/dist/shared-BTnATsqm-CDCqKwCF.mjs

@@ -0,0 +1,158 @@
+import { i as CliStructuredError, s as blindCast } from "./result-D4d-xy4I.mjs";
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import * as path from "node:path";
+//#region ../../0-framework/3-tooling/cli/dist/shared-BTnATsqm.mjs
+/**
+* Deploy preflight (TML-3158): verify that alchemy resolves the exact `effect`
+* version @prisma/composer pins. Package managers cannot be made to enforce
+* this — alchemy's own peer range accepts newer effect betas, and npm resolves
+* transitive peer conflicts with a warning, not a failure — so a floating
+* `@effect/*` range anywhere in the consumer's tree can hoist a newer effect
+* to the root, where alchemy picks it up and crashes mid-deploy
+* (`TypeError: Schedule.either is not a function`). This check turns that
+* silent break into a start-up error naming the fix.
+*/
+/** Walks up from `startDir` looking for `node_modules/alchemy` (mirrors resolveAlchemyBin). Undefined when absent — the check skips rather than second-guessing later, clearer failures. */
+function findAlchemyPackageDir(startDir) {
+	let dir = startDir;
+	while (true) {
+		const candidate = path.join(dir, "node_modules", "alchemy");
+		if (fs.existsSync(path.join(candidate, "package.json"))) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+/**
+* The `effect` version Node gives `packageDir`'s code, resolved exactly as
+* Node would: from the package's real path (so pnpm symlink layouts resolve
+* from the package's own store position, like at runtime). Undefined when
+* `effect` is not resolvable from there.
+*/
+function resolveEffectVersionFrom(packageDir) {
+	let entry;
+	try {
+		entry = createRequire(path.join(fs.realpathSync(packageDir), "noop.js")).resolve("effect");
+	} catch {
+		return;
+	}
+	let dir = path.dirname(entry);
+	while (!fs.existsSync(path.join(dir, "package.json"))) {
+		const parent = path.dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+	const version = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf-8")).version;
+	return typeof version === "string" ? version : void 0;
+}
+/**
+* The `effect` version @prisma/composer pins, read from its own installed
+* package.json — the single source of truth; never hardcoded here. Undefined
+* when @prisma/composer is not resolvable from `startDir` (e.g. the CLI is
+* driven some other way), in which case the check skips.
+*
+* Assumes the pin is an exact version — effectMismatchError compares with
+* `===`, which scripts/check-npm-effect-resolution.mjs enforces in CI;
+* relaxing the pin to a range means revisiting that comparison.
+*/
+function requiredEffectVersion(startDir) {
+	let manifestPath;
+	try {
+		manifestPath = createRequire(path.join(startDir, "noop.js")).resolve("@prisma/composer/package.json");
+	} catch {
+		return;
+	}
+	const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+	if (typeof manifest !== "object" || manifest === null || !("dependencies" in manifest)) return;
+	const dependencies = manifest.dependencies;
+	if (typeof dependencies !== "object" || dependencies === null || !("effect" in dependencies)) return;
+	const version = dependencies.effect;
+	return typeof version === "string" ? version : void 0;
+}
+/** Pure comparison + parts rendering, separated so tests cover the rule without a filesystem. Returns the structured error parts, or undefined when the tree is healthy or either side is unknown. */
+function effectMismatchError(found, required) {
+	if (found === void 0 || required === void 0 || found === required) return void 0;
+	return {
+		summary: `Dependency conflict: alchemy resolves effect@${found}, but @prisma/composer requires effect@${required}.`,
+		why: "Your package manager installed a second effect that alchemy picks up; deploying with it would crash inside alchemy.",
+		fix: `Add this to your app's package.json, then reinstall:
+
+  "overrides": { "effect": "${required}" }\n\n(npm uses "overrides"; yarn calls it "resolutions", pnpm "pnpm.overrides".)`,
+		meta: {
+			found,
+			required
+		}
+	};
+}
+/**
+* Runs the preflight from the app's directory and RETURNS the
+* DEPS.EFFECT_VERSION_CONFLICT error for a mismatched tree; undefined when the
+* tree is healthy or alchemy is not installed.
+*
+* This is the form the config-load machinery uses. The check belongs on the
+* config-load path rather than at import time because that is the first moment
+* anything actually loads alchemy's provider tree — the break it explains —
+* and because a check that runs at import time takes out commands that never
+* touch alchemy at all, help among them.
+*/
+function effectResolutionDiagnostic(cwd) {
+	const alchemyDir = findAlchemyPackageDir(cwd);
+	if (alchemyDir === void 0) return void 0;
+	const parts = effectMismatchError(resolveEffectVersionFrom(alchemyDir), requiredEffectVersion(cwd));
+	if (parts === void 0) return void 0;
+	return new CliStructuredError("DEPS.EFFECT_VERSION_CONFLICT", parts.summary, {
+		why: parts.why,
+		fix: parts.fix,
+		meta: parts.meta
+	});
+}
+/** The throwing form, used by the executor-load diagnosis — the one caller left now that the bin runs no start-up preflight of its own. */
+function checkEffectResolution(cwd) {
+	const diagnostic = effectResolutionDiagnostic(cwd);
+	if (diagnostic !== void 0) throw diagnostic;
+}
+/**
+* Reads the execution diagnostics an engine-failure error carries in
+* `meta.diagnostics`; undefined for every other failure.
+*/
+function executionDiagnostics(f) {
+	const diagnostics = f.meta?.["diagnostics"];
+	if (typeof diagnostics !== "object" || diagnostics === null) return void 0;
+	const candidate = blindCast(diagnostics);
+	if (candidate["exitCode"] !== void 0 && typeof candidate["exitCode"] !== "number" || candidate["signal"] !== void 0 && typeof candidate["signal"] !== "string" || typeof candidate["stackFilePath"] !== "string" || typeof candidate["reproduceCommand"] !== "string" || typeof candidate["cwd"] !== "string") return;
+	return blindCast(diagnostics);
+}
+/**
+* Site-specific wrap for foreign extension/environment causes — passthrough
+* when already structured; never a boundary fallback (base-type rule 6(ii)).
+*/
+function toStructured(code, error) {
+	return CliStructuredError.is(error) ? error : new CliStructuredError(code, error instanceof Error ? error.message : String(error), { cause: error });
+}
+/** Diagnoses a failed executor import: when the app's tree resolves a
+* mismatched `effect` (the known way that import breaks), the failure is the
+* fix-naming DEPS.EFFECT_VERSION_CONFLICT from checkEffectResolution with the
+* import error riding as cause; otherwise DEPS.EXECUTOR_UNLOADABLE — an
+* environmental failure of the consumer's installed tree, not a bug here. */
+function executorLoadFailure(operation, error, cwd) {
+	try {
+		checkEffectResolution(cwd);
+	} catch (diagnostic) {
+		if (CliStructuredError.is(diagnostic)) return new CliStructuredError(diagnostic.code, diagnostic.message, {
+			...diagnostic.why !== void 0 ? { why: diagnostic.why } : {},
+			...diagnostic.fix !== void 0 ? { fix: diagnostic.fix } : {},
+			...diagnostic.meta !== void 0 ? { meta: diagnostic.meta } : {},
+			cause: error
+		});
+	}
+	return new CliStructuredError("DEPS.EXECUTOR_UNLOADABLE", `Could not load the ${operation} executor: ${error instanceof Error ? error.message : String(error)}`, {
+		why: `The ${operation} operation's executor imports the deploy engine's provider tree from your app's installed dependencies, and that import failed.`,
+		fix: "Reinstall your dependencies, and check that `alchemy` is installed and loadable from your app.",
+		cause: error
+	});
+}
+//#endregion
+export { toStructured as i, executionDiagnostics as n, executorLoadFailure as r, effectResolutionDiagnostic as t };
+
+//# sourceMappingURL=shared-BTnATsqm-CDCqKwCF.mjs.map

package/dist/shared-BTnATsqm-CDCqKwCF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-BTnATsqm-CDCqKwCF.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/shared-BTnATsqm.mjs"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport { CliStructuredError } from \"@internal/foundation/errors\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { blindCast } from \"@internal/foundation/casts\";\n//#region src/check-effect-resolution.ts\n/**\n* Deploy preflight (TML-3158): verify that alchemy resolves the exact `effect`\n* version @prisma/composer pins. Package managers cannot be made to enforce\n* this — alchemy's own peer range accepts newer effect betas, and npm resolves\n* transitive peer conflicts with a warning, not a failure — so a floating\n* `@effect/*` range anywhere in the consumer's tree can hoist a newer effect\n* to the root, where alchemy picks it up and crashes mid-deploy\n* (`TypeError: Schedule.either is not a function`). This check turns that\n* silent break into a start-up error naming the fix.\n*/\n/** Walks up from `startDir` looking for `node_modules/alchemy` (mirrors resolveAlchemyBin). Undefined when absent — the check skips rather than second-guessing later, clearer failures. */\nfunction findAlchemyPackageDir(startDir) {\n\tlet dir = startDir;\n\twhile (true) {\n\t\tconst candidate = path.join(dir, \"node_modules\", \"alchemy\");\n\t\tif (fs.existsSync(path.join(candidate, \"package.json\"))) return candidate;\n\t\tconst parent = path.dirname(dir);\n\t\tif (parent === dir) return void 0;\n\t\tdir = parent;\n\t}\n}\n/**\n* The `effect` version Node gives `packageDir`'s code, resolved exactly as\n* Node would: from the package's real path (so pnpm symlink layouts resolve\n* from the package's own store position, like at runtime). Undefined when\n* `effect` is not resolvable from there.\n*/\nfunction resolveEffectVersionFrom(packageDir) {\n\tlet entry;\n\ttry {\n\t\tentry = createRequire(path.join(fs.realpathSync(packageDir), \"noop.js\")).resolve(\"effect\");\n\t} catch {\n\t\treturn;\n\t}\n\tlet dir = path.dirname(entry);\n\twhile (!fs.existsSync(path.join(dir, \"package.json\"))) {\n\t\tconst parent = path.dirname(dir);\n\t\tif (parent === dir) return void 0;\n\t\tdir = parent;\n\t}\n\tconst version = JSON.parse(fs.readFileSync(path.join(dir, \"package.json\"), \"utf-8\")).version;\n\treturn typeof version === \"string\" ? version : void 0;\n}\n/**\n* The `effect` version @prisma/composer pins, read from its own installed\n* package.json — the single source of truth; never hardcoded here. Undefined\n* when @prisma/composer is not resolvable from `startDir` (e.g. the CLI is\n* driven some other way), in which case the check skips.\n*\n* Assumes the pin is an exact version — effectMismatchError compares with\n* `===`, which scripts/check-npm-effect-resolution.mjs enforces in CI;\n* relaxing the pin to a range means revisiting that comparison.\n*/\nfunction requiredEffectVersion(startDir) {\n\tlet manifestPath;\n\ttry {\n\t\tmanifestPath = createRequire(path.join(startDir, \"noop.js\")).resolve(\"@prisma/composer/package.json\");\n\t} catch {\n\t\treturn;\n\t}\n\tconst manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf-8\"));\n\tif (typeof manifest !== \"object\" || manifest === null || !(\"dependencies\" in manifest)) return;\n\tconst dependencies = manifest.dependencies;\n\tif (typeof dependencies !== \"object\" || dependencies === null || !(\"effect\" in dependencies)) return;\n\tconst version = dependencies.effect;\n\treturn typeof version === \"string\" ? version : void 0;\n}\n/** Pure comparison + parts rendering, separated so tests cover the rule without a filesystem. Returns the structured error parts, or undefined when the tree is healthy or either side is unknown. */\nfunction effectMismatchError(found, required) {\n\tif (found === void 0 || required === void 0 || found === required) return void 0;\n\treturn {\n\t\tsummary: `Dependency conflict: alchemy resolves effect@${found}, but @prisma/composer requires effect@${required}.`,\n\t\twhy: \"Your package manager installed a second effect that alchemy picks up; deploying with it would crash inside alchemy.\",\n\t\tfix: `Add this to your app's package.json, then reinstall:\n\n  \"overrides\": { \"effect\": \"${required}\" }\\n\\n(npm uses \"overrides\"; yarn calls it \"resolutions\", pnpm \"pnpm.overrides\".)`,\n\t\tmeta: {\n\t\t\tfound,\n\t\t\trequired\n\t\t}\n\t};\n}\n/**\n* Runs the preflight from the app's directory and RETURNS the\n* DEPS.EFFECT_VERSION_CONFLICT error for a mismatched tree; undefined when the\n* tree is healthy or alchemy is not installed.\n*\n* This is the form the config-load machinery uses. The check belongs on the\n* config-load path rather than at import time because that is the first moment\n* anything actually loads alchemy's provider tree — the break it explains —\n* and because a check that runs at import time takes out commands that never\n* touch alchemy at all, help among them.\n*/\nfunction effectResolutionDiagnostic(cwd) {\n\tconst alchemyDir = findAlchemyPackageDir(cwd);\n\tif (alchemyDir === void 0) return void 0;\n\tconst parts = effectMismatchError(resolveEffectVersionFrom(alchemyDir), requiredEffectVersion(cwd));\n\tif (parts === void 0) return void 0;\n\treturn new CliStructuredError(\"DEPS.EFFECT_VERSION_CONFLICT\", parts.summary, {\n\t\twhy: parts.why,\n\t\tfix: parts.fix,\n\t\tmeta: parts.meta\n\t});\n}\n/** The throwing form, used by the executor-load diagnosis — the one caller left now that the bin runs no start-up preflight of its own. */\nfunction checkEffectResolution(cwd) {\n\tconst diagnostic = effectResolutionDiagnostic(cwd);\n\tif (diagnostic !== void 0) throw diagnostic;\n}\n//#endregion\n//#region src/operations/shared.ts\n/**\n* Reads the execution diagnostics an engine-failure error carries in\n* `meta.diagnostics`; undefined for every other failure.\n*/\nfunction executionDiagnostics(f) {\n\tconst diagnostics = f.meta?.[\"diagnostics\"];\n\tif (typeof diagnostics !== \"object\" || diagnostics === null) return void 0;\n\tconst candidate = blindCast(diagnostics);\n\tif (candidate[\"exitCode\"] !== void 0 && typeof candidate[\"exitCode\"] !== \"number\" || candidate[\"signal\"] !== void 0 && typeof candidate[\"signal\"] !== \"string\" || typeof candidate[\"stackFilePath\"] !== \"string\" || typeof candidate[\"reproduceCommand\"] !== \"string\" || typeof candidate[\"cwd\"] !== \"string\") return;\n\treturn blindCast(diagnostics);\n}\n/**\n* Site-specific wrap for foreign extension/environment causes — passthrough\n* when already structured; never a boundary fallback (base-type rule 6(ii)).\n*/\nfunction toStructured(code, error) {\n\treturn CliStructuredError.is(error) ? error : new CliStructuredError(code, error instanceof Error ? error.message : String(error), { cause: error });\n}\n/** Diagnoses a failed executor import: when the app's tree resolves a\n* mismatched `effect` (the known way that import breaks), the failure is the\n* fix-naming DEPS.EFFECT_VERSION_CONFLICT from checkEffectResolution with the\n* import error riding as cause; otherwise DEPS.EXECUTOR_UNLOADABLE — an\n* environmental failure of the consumer's installed tree, not a bug here. */\nfunction executorLoadFailure(operation, error, cwd) {\n\ttry {\n\t\tcheckEffectResolution(cwd);\n\t} catch (diagnostic) {\n\t\tif (CliStructuredError.is(diagnostic)) return new CliStructuredError(diagnostic.code, diagnostic.message, {\n\t\t\t...diagnostic.why !== void 0 ? { why: diagnostic.why } : {},\n\t\t\t...diagnostic.fix !== void 0 ? { fix: diagnostic.fix } : {},\n\t\t\t...diagnostic.meta !== void 0 ? { meta: diagnostic.meta } : {},\n\t\t\tcause: error\n\t\t});\n\t}\n\treturn new CliStructuredError(\"DEPS.EXECUTOR_UNLOADABLE\", `Could not load the ${operation} executor: ${error instanceof Error ? error.message : String(error)}`, {\n\t\twhy: `The ${operation} operation's executor imports the deploy engine's provider tree from your app's installed dependencies, and that import failed.`,\n\t\tfix: \"Reinstall your dependencies, and check that `alchemy` is installed and loadable from your app.\",\n\t\tcause: error\n\t});\n}\n//#endregion\nexport { effectResolutionDiagnostic as i, executorLoadFailure as n, toStructured as r, executionDiagnostics as t };\n\n//# sourceMappingURL=shared-BTnATsqm.mjs.map"],"mappings":"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"}

package/dist/testing.d.mts

@@ -0,0 +1,53 @@
+import { _ as Result, a as DeployInput, c as DestroyInput, d as LogAttached, f as LogDeps, g as ServiceEndpoint, h as OperationDeps, l as DevInput, m as LogLine, o as DeploySuccess, p as LogInput, s as DestroyEvent, t as ComposerOperations, u as DevSession, v as CliStructuredError } from "./family-DkH0si4D-CN5QubKS.mjs";
+//#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
+export { type ControlDouble, type ControlDoubleCalls, type ControlDoubleFixtures, createControlDouble };
+//# sourceMappingURL=testing.d.mts.map

package/dist/testing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.mts","names":[],"sources":["../../../0-framework/3-tooling/cli/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"}

package/dist/testing.mjs

@@ -0,0 +1,151 @@
+import { i as CliStructuredError, n as ok, r as okVoid, t as notOk } from "./result-D4d-xy4I.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
+export { createControlDouble };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/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"],"mappings":"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"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@prisma/composer-cli",
+  "version": "0.6.0-dev.21",
+  "type": "module",
+  "description": "Prisma Composer's command family and the `prisma-composer` CLI.",
+  "bin": {
+    "prisma-composer": "./dist/bin.mjs"
+  },
+  "exports": {
+    "./family": "./dist/family.mjs",
+    "./testing": "./dist/testing.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@prisma/composer": "0.6.0-dev.21",
+    "alchemy": "2.0.0-beta.67",
+    "c12": "^3.3.4",
+    "effect": "4.0.0-beta.103",
+    "esbuild": "^0.28.1"
+  },
+  "peerDependencies": {
+    "@prisma/cli-engine": "0.1.1"
+  },
+  "devDependencies": {
+    "@internal/cli": "0.6.0-dev.21",
+    "@internal/tsdown-config": "0.6.0-dev.21",
+    "@prisma/cli-engine": "0.1.1",
+    "@types/node": "^26.0.1",
+    "tsdown": "^0.22.7",
+    "typescript": "^6.0.3"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/composer.git",
+    "directory": "packages/9-public/composer-cli"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}

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 `@prisma/composer`'s `./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

@@ -0,0 +1,6 @@
+/**
+ * Public surface (the `./testing` subpath): `createControlDouble`, the
+ * fixture-backed double of the control API, for hosts that test how they
+ * mount the command family without running real deploys.
+ */
+export * from '@internal/cli/testing';