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

package/dist/family.mjs

@@ -0,0 +1,839 @@
+import { n as DOCS_BASE } from "./errors-DkXcnjPx.mjs";
+import { c as logWithDeps, i as destroyWithDeps, n as deployWithDeps, o as devWithDeps, u as executionDiagnostics } from "./log-DfT2hHqi-CDp9nfI5.mjs";
+import { t as alchemyCommandLine } from "./run-alchemy-D44OZlyB-DeDTFsB6.mjs";
+import { spawn } from "node:child_process";
+import { EnvironmentCredentialManager, createCli, defineCommand, defineCommandFamily, defineConfigSection, defineSessionCommand, exitWithChildStatus, flag, loadConfig, positional } from "@prisma/cli-engine";
+import { CliStructuredError, notOk, ok } from "@prisma/cli-engine/protocol";
+//#region ../../0-framework/3-tooling/cli/dist/engine-cli-CrYVbsvO.mjs
+/**
+* The family boundary's error translation.
+*
+* Composer and the engine each carry a class called `CliStructuredError`, both
+* descended from the same prisma/prisma foundation, and both recognize errors
+* by duck-typing on `name === 'CliStructuredError'`. That means a composer
+* error handed to the engine untranslated is ACCEPTED — it does not fail
+* loudly, it renders. What it loses is its `fix`: composer's foundation
+* carries remediation as one prose string on that field, the engine carries it
+* as a `nextActions` list and has no `fix` at all, so the fix text is dropped
+* silently and the user is told what broke with no word on what to do about
+* it. Nothing about that failure is visible without a test that looks for the
+* fix on the other side, which is why there is one.
+*
+* Everything else on the envelope survives as-is; only remediation changes
+* representation.
+*/
+/**
+* Composer's `fix` is free prose — "add this overrides block and reinstall",
+* "run the build, then retry" — with no machine-readable command inside it.
+* `user-choice` is the engine's own kind for exactly that (it is what the
+* engine uses for its own config and prompt failures), so the text carries
+* over verbatim as one action rather than being parsed into a command the
+* author never wrote.
+*/
+function fixAsNextActions(fix) {
+	return fix === void 0 ? [] : [{
+		kind: "user-choice",
+		label: fix
+	}];
+}
+/** Translates a composer failure into the engine's error type. Composer-side detail — `meta`, `where`, `docsUrl` — rides along untouched. */
+function toEngineError(error) {
+	return new CliStructuredError(error.code, error.message, {
+		severity: error.severity,
+		nextActions: fixAsNextActions(error.fix),
+		...error.why === void 0 ? {} : { why: error.why },
+		...error.where === void 0 ? {} : { where: error.where },
+		...error.meta === void 0 ? {} : { meta: error.meta },
+		...error.docsUrl === void 0 ? {} : { docsUrl: error.docsUrl },
+		cause: error
+	});
+}
+/** The adapter the operations call, backed by the engine's `ctx.spawn` so the
+*  terminal reaches alchemy natively and the engine owns signal policy. */
+function convergeSpawn(ctx) {
+	return async (invocation) => {
+		const line = alchemyCommandLine(invocation);
+		return await ctx.spawn({
+			command: line.command,
+			args: line.args,
+			cwd: line.cwd,
+			env: line.env
+		});
+	};
+}
+/** The in-process leg's deps: composer's existing seam, carrying the engine's
+*  own client and workspace id rather than anything read from the env. */
+function operationDeps(spec) {
+	return {
+		alchemy: spec.alchemy,
+		configPath: spec.configPath,
+		credentials: {
+			workspaceId: spec.workspaceId,
+			client: spec.client
+		}
+	};
+}
+/**
+* The reproduce hint a failed converge carries. Deliberately absent for an
+* aborted one: the user stopped it, so there is nothing to reproduce.
+*/
+function reproduceHint(failure) {
+	const diagnostics = executionDiagnostics(failure);
+	if (diagnostics === void 0) return [];
+	return [{
+		kind: "run-command",
+		label: `Run the converge directly from ${diagnostics.cwd} to reproduce this`,
+		command: diagnostics.reproduceCommand,
+		reason: `Generated stack file: ${diagnostics.stackFilePath}`
+	}];
+}
+/**
+* How a FAILED converge settles. `deploy`, `destroy` and `dev` all end this
+* way and must not drift apart, so the decision lives here once rather than
+* inline in each handler.
+*
+* A failure that reached the child exits with the child's status verbatim and
+* carries the reproduce hint; a failure that never reached the child is an
+* ordinary structured error and gets the normal envelope. Nothing here reads
+* `signal` — see settleConverge.
+*/
+function settleConvergeFailure(failure, ctx) {
+	const child = ctx.lastChild();
+	if (child !== void 0 && child.exitCode !== 0) return ok(exitWithChildStatus({ nextActions: reproduceHint(failure) }));
+	return notOk(toEngineError(failure));
+}
+/**
+* How a converge settles, now that the engine owns the child's status.
+*
+* Nothing here reads `signal`. `exitWithChildStatus` settles from the engine's
+* own record of the child, and a signal-killed one overrules whatever this
+* function asked for: 128 + the signal, no failure envelope, and the reproduce
+* hint dropped, because the user stopped the run and there is nothing to
+* reproduce.
+*
+* What is left is the operation's own verdict. A failure that reached the
+* child exits with the child's status verbatim and carries the reproduce hint;
+* a failure that never reached the child is an ordinary structured error and
+* gets the normal envelope.
+*
+* A SUCCESS presents its result even when the child was signal-killed. No
+* composer operation produces that pair today — each one reports a
+* signal-killed converge as a failure — and an operation that ever did would
+* have a real result worth showing. The run still exits 130, because the
+* engine settles a signal-terminated run from its own record of the signal
+* whatever the handler returns.
+*/
+function settleConverge(result, ctx, present) {
+	if (!result.ok) return settleConvergeFailure(result.failure, ctx);
+	return ok(present(result.value));
+}
+/**
+* Composer's projection into `prisma.config.ts` — the `composer` section.
+*
+* The section is deliberately tiny. Composer's real configuration lives in
+* `prisma-composer.config.ts`, which holds executable values (Effect layers,
+* provider factories, container lifecycles) and can only be understood by
+* evaluating it inside a running command. A config-section validator loads
+* with the command tree at start-up and must be dependency-light and total,
+* so it is the wrong place to evaluate any of that. What the section carries
+* is therefore only the one fact the engine can usefully know before a
+* command runs: WHERE that file is, when the user wants to say so.
+*
+* Its fields grow only by amending the slice contract.
+*/
+const KNOWN_FIELDS = ["configPath"];
+function diagnostic(spec) {
+	return {
+		code: spec.code,
+		severity: spec.severity,
+		summary: spec.summary,
+		...spec.why === void 0 ? {} : { why: spec.why },
+		nextActions: spec.fix === void 0 ? [] : [{
+			kind: "edit-file",
+			label: spec.fix
+		}]
+	};
+}
+function validate(raw) {
+	if (raw === void 0) return {
+		ok: true,
+		value: {},
+		diagnostics: []
+	};
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {
+		ok: false,
+		diagnostics: [diagnostic({
+			code: "CONFIG.FIELD_INVALID",
+			severity: "error",
+			summary: "The `composer` section of prisma.config.ts must be an object.",
+			fix: "Write `composer: { configPath: \"./prisma-composer.config.ts\" }`, or remove the section entirely."
+		})]
+	};
+	let record;
+	try {
+		record = { ...raw };
+	} catch {
+		return {
+			ok: false,
+			diagnostics: [diagnostic({
+				code: "CONFIG.FIELD_INVALID",
+				severity: "error",
+				summary: "The `composer` section of prisma.config.ts could not be read.",
+				why: "Reading its fields threw, so nothing in it can be trusted.",
+				fix: "Write it as a plain object literal, e.g. `composer: { configPath: \"./prisma-composer.config.ts\" }`."
+			})]
+		};
+	}
+	const configPath = record["configPath"];
+	if (configPath !== void 0 && (typeof configPath !== "string" || configPath.length === 0)) return {
+		ok: false,
+		diagnostics: [diagnostic({
+			code: "CONFIG.FIELD_INVALID",
+			severity: "error",
+			summary: "`composer.configPath` must be a non-empty string.",
+			why: "It names the prisma-composer.config.ts file to load.",
+			fix: "Set it to a path, or remove it to search upward from the entry."
+		})]
+	};
+	const unknown = Object.keys(record).filter((key) => !KNOWN_FIELDS.includes(key));
+	return {
+		ok: true,
+		value: configPath === void 0 ? {} : { configPath },
+		diagnostics: unknown.map((key) => diagnostic({
+			code: "CONFIG.FIELD_UNKNOWN",
+			severity: "warn",
+			summary: `The \`composer\` section has no field \`${key}\`; it is ignored.`,
+			fix: `Remove \`${key}\`, or check it against the version of @prisma/composer you have installed.`
+		}))
+	};
+}
+const composerSection = defineConfigSection({
+	name: "composer",
+	validate
+});
+/**
+* The workspace the in-process leg acts in, from the engine's credential
+* read. Handlers never decode a token and never read PRISMA_WORKSPACE_ID:
+* whether the credential came from a stored session or the environment, the
+* engine has already resolved it, and branching on where it came from is a
+* defect by the credential-manager design.
+*
+* Undefined when the active credential names no workspace — an environment
+* token whose claims carry none. The container descriptors raise their own
+* "workspace required" error in that case, which is the error the user needs.
+*/
+async function workspaceIdOf(ctx) {
+	return (await ctx.activeCredential())?.workspaceId;
+}
+/**
+* `deploy <entry>` — a result command that hands the terminal to alchemy.
+*
+* `--production` is gone. It was accepted and then always errored ("only
+* valid with destroy"), so no invocation using it could ever have succeeded;
+* deploy targets production by default when no `--stage` is given.
+*/
+const createDeployCommand = (operations) => defineCommand({
+	help: {
+		summary: "Deploy the application whose root node is <entry>'s default export.",
+		examples: ["{bin} deploy src/service.ts", "{bin} deploy src/service.ts --stage feat-auth"]
+	},
+	args: {
+		positionals: { entry: positional.string({
+			brief: "The module whose default export is the application root.",
+			placeholder: "entry"
+		}) },
+		flags: {
+			name: flag.string({
+				brief: "Override the root node's name — the deploy's application name.",
+				placeholder: "name"
+			}),
+			stage: flag.string({
+				brief: "Deploy scope to target; omit for production.",
+				placeholder: "stage"
+			})
+		}
+	},
+	needs: {
+		config: composerSection,
+		credentials: "child"
+	},
+	maySpawn: true,
+	handler: async (args, ctx) => {
+		const alchemy = convergeSpawn(ctx);
+		return settleConverge(await operations.deploy({
+			entry: args.positionals.entry,
+			name: args.flags.name,
+			stage: args.flags.stage,
+			cwd: ctx.cwd
+		}, operationDeps({
+			alchemy,
+			configPath: ctx.config.configPath,
+			workspaceId: await workspaceIdOf(ctx),
+			client: ctx.api
+		})), ctx, ({ summary }) => ctx.present({ data: { summary: summary ?? null } }, {
+			human: (ui) => summary === void 0 ? [{
+				kind: "summary",
+				tone: "ok",
+				text: "Deployed."
+			}] : [{
+				kind: "summary",
+				tone: "ok",
+				text: `Deployed ${ui.emphasize(summary.app)}.`
+			}, {
+				kind: "table",
+				columns: ["Address", "Deployed"],
+				rows: summary.nodes.map((node) => [node.address, node.entities.map((entity) => `${entity.kind} ${entity.id}`).join(", ")])
+			}],
+			json: () => ({ summary: summary ?? null })
+		}));
+	}
+});
+/**
+* `destroy`'s target, from its two mutually exclusive flags. Kept out of the
+* grammar because the engine's flag layer has no "exactly one of these"
+* construct — and because both wrong shapes need their own remedy, which a
+* generic arity error could not give.
+*/
+function targetOf(stage, production) {
+	if (stage !== void 0 && production) return notOk(new CliStructuredError("DEPLOY.TARGET_CONFLICT", "Pass either --stage <name> or --production to `destroy`, not both."));
+	if (stage === void 0 && !production) return notOk(new CliStructuredError("DEPLOY.TARGET_MISSING", "`destroy` requires an explicit target.", { nextActions: [{
+		kind: "user-choice",
+		label: "Pass --stage <name> to tear down a branch environment, or --production to tear down the production environment."
+	}] }));
+	return ok(stage !== void 0 ? {
+		kind: "stage",
+		stage
+	} : { kind: "production" });
+}
+/**
+* `destroy <entry>` — deploy's mirror: same derivation, alchemy destroy.
+*
+* No confirmation prompt, matching the CLI this replaces. The front door
+* cannot know what the child will tear down, so a consent step here would be
+* asking the user to approve a list nobody has computed yet; if destroy
+* deserves one it belongs in composer's own operation, not in the grammar.
+*/
+const createDestroyCommand = (operations) => defineCommand({
+	help: {
+		summary: "Tear down the application whose root node is <entry>'s default export.",
+		description: "Same derivation as deploy. Requires an explicit target: --stage <name> for a branch environment, or --production for the production environment.",
+		examples: ["{bin} destroy src/service.ts --stage feat-auth", "{bin} destroy src/service.ts --production"]
+	},
+	args: {
+		positionals: { entry: positional.string({
+			brief: "The module whose default export is the application root.",
+			placeholder: "entry"
+		}) },
+		flags: {
+			name: flag.string({
+				brief: "Override the root node's name — the application name to tear down.",
+				placeholder: "name"
+			}),
+			stage: flag.string({
+				brief: "Tear down this branch environment.",
+				placeholder: "stage"
+			}),
+			production: flag.boolean({ brief: "Tear down the project-level production environment." })
+		}
+	},
+	needs: {
+		config: composerSection,
+		credentials: "child"
+	},
+	maySpawn: true,
+	handler: async (args, ctx) => {
+		const target = targetOf(args.flags.stage, args.flags.production);
+		if (!target.ok) return target;
+		const alchemy = convergeSpawn(ctx);
+		return settleConverge(await operations.destroy({
+			entry: args.positionals.entry,
+			name: args.flags.name,
+			target: target.value,
+			cwd: ctx.cwd,
+			onEvent: (event) => {
+				if (event.kind !== "no-local-deploy-state") return;
+				ctx.report({
+					kind: "message",
+					severity: "warn",
+					text: `No prior deploy state under ${event.cwd} — if you deployed from a different directory, run destroy from there; otherwise this is a no-op.`
+				});
+			}
+		}, operationDeps({
+			alchemy,
+			configPath: ctx.config.configPath,
+			workspaceId: await workspaceIdOf(ctx),
+			client: ctx.api
+		})), ctx, () => ctx.present({ data: void 0 }, { human: () => [{
+			kind: "summary",
+			tone: "ok",
+			text: "Destroyed."
+		}] }));
+	}
+});
+const STOP_STEP = "Stopping the app's services — emulators and data stay up";
+/** Resolves when the run is asked to stop. */
+function stopRequested(signal) {
+	if (signal.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		signal.addEventListener("abort", () => resolve(), { once: true });
+	});
+}
+/**
+* One converge at a time. `ctx.spawn` refuses a second live child, and the
+* watch loop can well fire a rebuild while the previous converge is still
+* running — so a request that arrives during a live converge joins the single
+* queued follow-up instead of starting its own. That extends the coalescing
+* the watcher already does across a burst of edits to cover the converge
+* itself, and it is sound because every dev converge is the SAME invocation:
+* one stack file at one fixed path, rewritten in place before each request.
+*/
+function coalescedConverge(run) {
+	let live;
+	let queued;
+	const start = (invocation) => {
+		const outcome = run(invocation);
+		const settled = outcome.then(() => void 0, () => void 0);
+		live = settled;
+		settled.then(() => {
+			if (live === settled) live = void 0;
+		});
+		return outcome;
+	};
+	return (invocation) => {
+		const running = live;
+		if (running === void 0) return start(invocation);
+		queued ??= running.then(() => {
+			queued = void 0;
+			return start(invocation);
+		});
+		return queued;
+	};
+}
+/** The front door, ordered by address depth (fewest dots first) then lexicographically. */
+function frontDoorOrder(endpoints) {
+	return [...endpoints].sort((a, b) => {
+		const depth = a.address.split(".").length - b.address.split(".").length;
+		if (depth !== 0) return depth;
+		return a.address < b.address ? -1 : a.address > b.address ? 1 : 0;
+	});
+}
+/**
+* The operation's events as engine events. The legacy `[dev]` console prefix
+* is gone: these are commentary the engine renders and frames.
+*/
+function reportDevEvent(report, lastChild) {
+	let stopFailed = false;
+	return (event) => {
+		switch (event.kind) {
+			case "ready":
+				report({
+					kind: "status",
+					subject: "dev",
+					status: "ready"
+				});
+				for (const endpoint of frontDoorOrder(event.endpoints)) report({
+					kind: "endpoint",
+					name: endpoint.address,
+					url: endpoint.url
+				});
+				return;
+			case "unwatchable":
+				report({
+					kind: "message",
+					severity: "warn",
+					text: `${event.address} has no watchable inputs.`
+				});
+				return;
+			case "rebuild-failed":
+				report({
+					kind: "message",
+					severity: "warn",
+					text: `Rebuild failed: ${event.message}`
+				});
+				return;
+			case "watch-error":
+				report({
+					kind: "message",
+					severity: "warn",
+					text: `Watch error: ${event.message}`
+				});
+				return;
+			case "converge-failed": {
+				const child = lastChild();
+				if (child !== void 0 && child.signal !== null) return;
+				report({
+					kind: "message",
+					severity: "warn",
+					text: `Converge failed — the running app is untouched; still watching.
+Generated stack file: ${event.stackFilePath}\nRun \`${event.reproduceCommand}\` from ${event.cwd} to reproduce this directly.`
+				});
+				report({
+					kind: "remediation",
+					action: {
+						kind: "run-command",
+						label: `Run the converge directly from ${event.cwd} to reproduce this`,
+						command: event.reproduceCommand,
+						reason: `Generated stack file: ${event.stackFilePath}`
+					}
+				});
+				return;
+			}
+			case "stopping":
+				report({
+					kind: "step-started",
+					step: STOP_STEP,
+					id: "dev-stop"
+				});
+				return;
+			case "stop-error":
+				stopFailed = true;
+				report({
+					kind: "message",
+					severity: "warn",
+					text: `A service refused to stop: ${event.message}`
+				});
+				return;
+			case "stopped":
+				report({
+					kind: "step-finished",
+					step: STOP_STEP,
+					id: "dev-stop",
+					outcome: stopFailed ? "warning" : "ok"
+				});
+				return;
+		}
+	};
+}
+const createDevCommand = (operations) => defineSessionCommand({
+	help: {
+		summary: "Bring up the application whose root node is <entry>'s default export, entirely on this machine.",
+		description: "Runs credential-free and watches the app for changes, reconverging on every edit. Logs are a separate command; run `log <entry>` to tail them.",
+		examples: ["{bin} dev src/service.ts", "{bin} dev src/service.ts --fresh"]
+	},
+	args: {
+		positionals: { entry: positional.string({
+			brief: "The module whose default export is the application root.",
+			placeholder: "entry"
+		}) },
+		flags: {
+			name: flag.string({
+				brief: "Override the root node's name — the dev instance's application name.",
+				placeholder: "name"
+			}),
+			fresh: flag.boolean({ brief: "Destroy the dev stack and wipe the dev state directory before starting." })
+		}
+	},
+	needs: { config: composerSection },
+	maySpawn: true,
+	handler: async (args, ctx) => {
+		const alchemy = convergeSpawn(ctx);
+		const result = await operations.dev({
+			entry: args.positionals.entry,
+			name: args.flags.name,
+			fresh: args.flags.fresh,
+			cwd: ctx.cwd,
+			onEvent: reportDevEvent(ctx.report, ctx.lastChild)
+		}, {
+			alchemy: coalescedConverge(alchemy),
+			configPath: ctx.config.configPath
+		});
+		if (!result.ok) return settleConvergeFailure(result.failure, ctx);
+		await stopRequested(ctx.signal);
+		await result.value.stop();
+		return ok(void 0);
+	}
+});
+/**
+* `log <entry> [address]` — a session command that tails the merged logs of
+* the app running locally on this machine.
+*
+* It reads the LOCAL dev-emulator daemon, not the platform's logs surface, so
+* it is credential-free. It hands the terminal to nothing, which is why it
+* does not declare `maySpawn` and keeps json support: the log lines ARE its
+* json surface.
+*
+* Windows is refused inside the operation itself (LOG.PLATFORM_UNSUPPORTED),
+* which is why nothing here reads the platform.
+*/
+/** An empty screen reads as broken, so show a little recent history before going live. */
+const DEFAULT_TAIL = 20;
+const createLogCommand = (operations) => defineSessionCommand({
+	help: {
+		summary: "Tail the merged logs of the locally-running application whose root node is <entry>'s default export.",
+		examples: ["{bin} log src/service.ts", "{bin} log src/service.ts catalog.service"]
+	},
+	args: {
+		positionals: {
+			entry: positional.string({
+				brief: "The module whose default export is the application root.",
+				placeholder: "entry"
+			}),
+			address: positional.optionalString({
+				brief: "Only this service's lines, by its dotted address (catalog.service); every service when absent.",
+				placeholder: "address"
+			})
+		},
+		flags: {
+			name: flag.string({
+				brief: "Override the root node's name — the dev instance's application name.",
+				placeholder: "name"
+			}),
+			tail: flag.number({
+				brief: `How many trailing history lines to show before live output (default ${String(DEFAULT_TAIL)}).`,
+				placeholder: "lines",
+				default: DEFAULT_TAIL
+			})
+		}
+	},
+	needs: { config: composerSection },
+	handler: async (args, ctx) => {
+		const reportLogEvent = (event) => {
+			ctx.report({
+				kind: "message",
+				severity: "warn",
+				text: event.kind === "stream-failed" ? `Stream failed: ${event.message}` : `Falling behind — dropped the ${String(event.count)} oldest lines.`
+			});
+		};
+		const result = await operations.log({
+			entry: args.positionals.entry,
+			name: args.flags.name,
+			address: args.positionals.address,
+			tail: args.flags.tail ?? DEFAULT_TAIL,
+			cwd: ctx.cwd,
+			signal: ctx.signal,
+			onEvent: reportLogEvent
+		}, { configPath: ctx.config.configPath });
+		if (!result.ok) return notOk(toEngineError(result.failure));
+		const attached = result.value;
+		if (attached.services.length === 0) {
+			ctx.report({
+				kind: "message",
+				severity: "warn",
+				text: `No running services for "${attached.appName}" — start it first with \`dev ${args.positionals.entry}\`.`
+			});
+			return ok(void 0);
+		}
+		for await (const { service, line } of attached.lines) ctx.report({
+			kind: "output",
+			source: service,
+			channel: "data",
+			line: `[${service}] ${line}`
+		});
+		return ok(void 0);
+	}
+});
+/**
+* Composer's `CommandFamily` — the unit the engine mounts, whether the process
+* is composer's own CLI or the `prisma` bin.
+*
+* This module and everything it reaches statically must stay free of alchemy
+* and of effect VALUE imports: the `prisma` bin imports the family directly,
+* so anything in this static graph loads on `prisma --version`. The mechanism
+* that holds it is the existing lazy boundary inside the operation modules —
+* `operations/deploy.ts`, `destroy.ts`, `dev.ts` and `log.ts` each `await
+* import()` their executor, and it is the executors that reach the provider
+* tree. Importing the operations here is therefore free; importing an
+* executor, or flattening one of those dynamic imports, is not.
+* scripts/check-family-static-graph.mjs enforces this against BUILT output,
+* where type-only imports have already been erased.
+*
+* The four commands close over the operations they are given, so a host can
+* mount this family against the test double and exercise real grammar, real
+* arg validation and real handlers with no alchemy behind them.
+*/
+const realOperations = {
+	deploy: deployWithDeps,
+	destroy: destroyWithDeps,
+	dev: devWithDeps,
+	log: logWithDeps
+};
+function createComposerFamily(options = {}) {
+	const operations = options.operations ?? realOperations;
+	return defineCommandFamily({
+		configSection: composerSection,
+		commands: {
+			deploy: createDeployCommand(operations),
+			destroy: createDestroyCommand(operations),
+			dev: createDevCommand(operations),
+			log: createLogCommand(operations)
+		},
+		docsBaseUrl: DOCS_BASE
+	});
+}
+/**
+* Everything environmental the engine needs, assembled from a host process.
+*
+* The engine takes no globals: streams, cwd, env, TTY-ness, exit and signal
+* subscription all arrive through `Runtime`, which is what lets a test drive a
+* whole run without touching `process`. Composing one is the substantive part
+* of hosting the engine — `createCli` and `Cli.run` are two calls.
+*
+* Credentials come from the engine's own environment-only manager, which
+* composes a session from PRISMA_SERVICE_TOKEN / PRISMA_WORKSPACE_ID and
+* refuses every mutation. That is the whole of composer's standalone auth
+* story: this CLI has no login flow and mounts no auth commands, so there is
+* nothing to store — the two variables ARE the credential.
+*/
+/** Where the management API lives. Matches the lowering client's default origin; the env var is the escape hatch for staging. */
+const DEFAULT_MANAGEMENT_API_BASE_URL = "https://api.prisma.io";
+const DEFAULT_AUTH_BASE_URL = "https://auth.prisma.io";
+/**
+* Starts the converge child: inherited stdio, this process's own group, no
+* `detached` and no new console — which is what lets the terminal deliver
+* Ctrl-C to the child natively instead of the CLI forwarding it. The engine
+* never imports node:child_process; this adapter is the whole of the host's
+* side of that seam.
+*/
+const spawnChild = (request) => {
+	const child = spawn(request.command, [...request.args], {
+		cwd: request.cwd,
+		stdio: "inherit",
+		env: request.env
+	});
+	return {
+		ended: new Promise((resolve, reject) => {
+			child.on("error", reject);
+			child.on("close", (exitCode, signal) => {
+				resolve({
+					exitCode,
+					signal
+				});
+			});
+		}),
+		kill: (signal) => {
+			child.kill(signal);
+		}
+	};
+};
+/**
+* The SDK's client construction config. The engine requires all four fields
+* whenever a credential manager is wired, but this host reaches none of the
+* login paths: an environment credential carries no refresh token, so nothing
+* ever refreshes and `clientId`/`redirectUri` are never read. They are
+* env-overridable rather than hard-coded so a staging run can point the whole
+* client somewhere else in one place.
+*/
+function clientConfig(env, apiBaseUrl) {
+	return {
+		clientId: env["PRISMA_CLIENT_ID"] ?? "prisma-composer-cli",
+		redirectUri: env["PRISMA_REDIRECT_URI"] ?? "http://127.0.0.1/callback",
+		apiBaseUrl,
+		authBaseUrl: env["PRISMA_AUTH_URL"] ?? DEFAULT_AUTH_BASE_URL
+	};
+}
+/**
+* Which package manager invoked us, read from the `npm_config_user_agent`
+* every major manager sets (`pnpm/10.27.0 npm/? node/v24.16.0 darwin arm64`).
+* `unknown` when the CLI was run directly rather than through a manager — a
+* normal case, not a failure, so nothing is inferred from the filesystem.
+*/
+function detectPackageManager(env) {
+	const agent = env["npm_config_user_agent"];
+	if (agent === void 0) return "unknown";
+	const name = agent.split("/")[0];
+	switch (name) {
+		case "npm":
+		case "pnpm":
+		case "yarn":
+		case "bun": return name;
+		default: return "unknown";
+	}
+}
+/**
+* The config loader arrives as a function rather than an already-loaded config
+* because the engine reads `prisma.config.ts` on demand — only when the command
+* it is about to run declares a config section, and with whatever file
+* `--config` named. A host that loaded the file up front would read it for runs
+* that never needed it, and would have nowhere to put `--config`.
+*/
+function createRuntime(host, loadConfig) {
+	const env = host.env;
+	const apiBaseUrl = env["PRISMA_MANAGEMENT_API_URL"] ?? DEFAULT_MANAGEMENT_API_BASE_URL;
+	return {
+		stdout: host.stdout,
+		stderr: host.stderr,
+		stdin: host.stdin,
+		cwd: host.cwd(),
+		env,
+		isTty: {
+			stdin: host.stdin.isTTY === true,
+			stdout: host.stdout.isTTY === true,
+			stderr: host.stderr.isTTY === true
+		},
+		exit: (code) => host.exit(code),
+		onSignal: (cb) => {
+			const onSigint = () => {
+				cb("SIGINT");
+			};
+			const onSigterm = () => {
+				cb("SIGTERM");
+			};
+			host.on("SIGINT", onSigint);
+			host.on("SIGTERM", onSigterm);
+			return () => {
+				host.off("SIGINT", onSigint);
+				host.off("SIGTERM", onSigterm);
+			};
+		},
+		loadConfig,
+		credentialManager: new EnvironmentCredentialManager({ env }),
+		managementApiClientConfig: clientConfig(env, apiBaseUrl),
+		spawn: spawnChild,
+		managementApi: { baseUrl: apiBaseUrl },
+		packageManager: detectPackageManager(env)
+	};
+}
+/**
+* Composer's own CLI, rebuilt as a thin composition of the family it
+* publishes: `createCli` over `createComposerFamily()`, `Cli.run` with a
+* Runtime. Grammar, help, arg validation, output framing, exit codes and
+* signal ownership all belong to the engine now — this module contributes the
+* family and the environment, and nothing else.
+*
+* Running composer's commands through the same path an external host uses is
+* the point: it is what proves the family works standalone before the `prisma`
+* bin mounts it.
+*
+* This IS composer's CLI. The clipanion shell it replaced, and the bespoke
+* runner that shelled out to alchemy, are gone; `bin.ts` is a call into here.
+*/
+const BINARY_NAME = "prisma-composer";
+/**
+* Composer's commands mount at the top level of its own CLI (`prisma-composer
+* deploy`); under the `prisma` bin the same family mounts one level down
+* (`prisma composer deploy`). The family is identical either way — only the
+* mount paths differ, which is exactly the split `createCli` draws between
+* `commandFamilies` and `commands`.
+*/
+function mountedTree(family) {
+	return { ...family.commands };
+}
+function createComposerCli(spec) {
+	const family = createComposerFamily({ operations: spec.operations });
+	return createCli({
+		name: BINARY_NAME,
+		version: spec.version,
+		commandFamilies: [family],
+		groups: {},
+		commands: mountedTree(family)
+	});
+}
+/**
+* Composes the Runtime and runs one invocation. Returns the exit code rather
+* than exiting, so the caller owns the process — a bin assigns it to
+* `process.exitCode` and lets the streams drain, as composer's CLI has always
+* done.
+*
+* `prisma.config.ts` is not read here. The loader goes in as a function, and the
+* engine calls it only when the command it is about to run declares a config
+* section, passing it the file `--config` named; the loader resolves that
+* against the host's cwd.
+*/
+function runComposerCli(argv, host, spec, hooks) {
+	const runtime = createRuntime(host, (configPath) => loadConfig(host.cwd(), configPath));
+	return createComposerCli(spec).run(argv, runtime, hooks);
+}
+//#endregion
+export { BINARY_NAME, composerSection, createComposerCli, createComposerFamily, realOperations, runComposerCli, toEngineError };
+
+//# sourceMappingURL=family.mjs.map