@prisma/composer 0.6.0-dev.17 → 0.6.0-dev.19

package/dist/bin.mjs

@@ -1,1344 +0,0 @@
-#!/usr/bin/env node
-import { a as executionDiagnostics, l as DOCS_BASE, o as executorLoadFailure, t as notOk$1 } from "./result-B4XjxVK6.mjs";
-import { t as alchemyCommandLine } from "./run-alchemy-D44OZlyB-DA7s331N.mjs";
-import "node:module";
-import * as fs from "node:fs";
-import * as path from "node:path";
-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";
-import { fileURLToPath } from "node:url";
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-//#endregion
-//#region ../../0-framework/3-tooling/cli/dist/log-DfT2hHqi.mjs
-/** In-package variant threading the injection seam (the CLI's RunDeps, unit
-* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
-* internal types and is not part of the published surface. */
-async function deployWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-deploy-destroy-DfVJUICu-quUQ08T8.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("deploy", error, cwd));
-	}
-	return executor.executeDeploy(input, deps, cwd);
-}
-/** In-package variant threading the injection seam (the CLI's RunDeps, unit
-* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
-* internal types and is not part of the published surface. */
-async function destroyWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-deploy-destroy-DfVJUICu-quUQ08T8.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("destroy", error, cwd));
-	}
-	return executor.executeDestroy(input, deps, cwd);
-}
-/** In-package variant threading the injection seam (the CLI's RunDeps, unit
-* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
-* internal types and is not part of the published surface. */
-async function devWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-dev-BMTFWfFc-B1whS-Rr.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("dev", error, cwd));
-	}
-	return executor.executeDev(input, deps, cwd);
-}
-/** In-package variant threading the injection seam (the CLI's LogRunDeps,
-* unit tests). Deliberately NOT re-exported through `./control` — the seam
-* mirrors internal types and is not part of the published surface. */
-async function logWithDeps(input, deps) {
-	const cwd = input.cwd ?? process.cwd();
-	let executor;
-	try {
-		executor = await import("./execute-log-Cay9hlKW-DrMeVOXq.mjs");
-	} catch (error) {
-		return notOk$1(executorLoadFailure("log", error, cwd));
-	}
-	return executor.executeLog(input, deps, cwd);
-}
-//#endregion
-//#region ../../../node_modules/ci-info/vendors.json
-var require_vendors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = [
-		{
-			"name": "Agola CI",
-			"constant": "AGOLA",
-			"env": "AGOLA_GIT_REF",
-			"pr": "AGOLA_PULL_REQUEST_ID"
-		},
-		{
-			"name": "Alpic",
-			"constant": "ALPIC",
-			"env": "ALPIC_HOST"
-		},
-		{
-			"name": "Appcircle",
-			"constant": "APPCIRCLE",
-			"env": "AC_APPCIRCLE",
-			"pr": {
-				"env": "AC_GIT_PR",
-				"ne": "false"
-			}
-		},
-		{
-			"name": "AppVeyor",
-			"constant": "APPVEYOR",
-			"env": "APPVEYOR",
-			"pr": "APPVEYOR_PULL_REQUEST_NUMBER"
-		},
-		{
-			"name": "AWS CodeBuild",
-			"constant": "CODEBUILD",
-			"env": "CODEBUILD_BUILD_ARN",
-			"pr": {
-				"env": "CODEBUILD_WEBHOOK_EVENT",
-				"any": [
-					"PULL_REQUEST_CREATED",
-					"PULL_REQUEST_UPDATED",
-					"PULL_REQUEST_REOPENED"
-				]
-			}
-		},
-		{
-			"name": "Azure Pipelines",
-			"constant": "AZURE_PIPELINES",
-			"env": "TF_BUILD",
-			"pr": { "BUILD_REASON": "PullRequest" }
-		},
-		{
-			"name": "Bamboo",
-			"constant": "BAMBOO",
-			"env": "bamboo_planKey"
-		},
-		{
-			"name": "Bitbucket Pipelines",
-			"constant": "BITBUCKET",
-			"env": "BITBUCKET_COMMIT",
-			"pr": "BITBUCKET_PR_ID"
-		},
-		{
-			"name": "Bitrise",
-			"constant": "BITRISE",
-			"env": "BITRISE_IO",
-			"pr": "BITRISE_PULL_REQUEST"
-		},
-		{
-			"name": "Buddy",
-			"constant": "BUDDY",
-			"env": "BUDDY_WORKSPACE_ID",
-			"pr": "BUDDY_EXECUTION_PULL_REQUEST_ID"
-		},
-		{
-			"name": "Buildkite",
-			"constant": "BUILDKITE",
-			"env": "BUILDKITE",
-			"pr": {
-				"env": "BUILDKITE_PULL_REQUEST",
-				"ne": "false"
-			}
-		},
-		{
-			"name": "CircleCI",
-			"constant": "CIRCLE",
-			"env": "CIRCLECI",
-			"pr": "CIRCLE_PULL_REQUEST"
-		},
-		{
-			"name": "Cirrus CI",
-			"constant": "CIRRUS",
-			"env": "CIRRUS_CI",
-			"pr": "CIRRUS_PR"
-		},
-		{
-			"name": "Cloudflare Pages",
-			"constant": "CLOUDFLARE_PAGES",
-			"env": "CF_PAGES"
-		},
-		{
-			"name": "Cloudflare Workers",
-			"constant": "CLOUDFLARE_WORKERS",
-			"env": "WORKERS_CI"
-		},
-		{
-			"name": "Codefresh",
-			"constant": "CODEFRESH",
-			"env": "CF_BUILD_ID",
-			"pr": { "any": ["CF_PULL_REQUEST_NUMBER", "CF_PULL_REQUEST_ID"] }
-		},
-		{
-			"name": "Codemagic",
-			"constant": "CODEMAGIC",
-			"env": "CM_BUILD_ID",
-			"pr": "CM_PULL_REQUEST"
-		},
-		{
-			"name": "Codeship",
-			"constant": "CODESHIP",
-			"env": { "CI_NAME": "codeship" }
-		},
-		{
-			"name": "Drone",
-			"constant": "DRONE",
-			"env": "DRONE",
-			"pr": { "DRONE_BUILD_EVENT": "pull_request" }
-		},
-		{
-			"name": "dsari",
-			"constant": "DSARI",
-			"env": "DSARI"
-		},
-		{
-			"name": "Earthly",
-			"constant": "EARTHLY",
-			"env": "EARTHLY_CI"
-		},
-		{
-			"name": "Expo Application Services",
-			"constant": "EAS",
-			"env": "EAS_BUILD"
-		},
-		{
-			"name": "Gerrit",
-			"constant": "GERRIT",
-			"env": "GERRIT_PROJECT"
-		},
-		{
-			"name": "Gitea Actions",
-			"constant": "GITEA_ACTIONS",
-			"env": "GITEA_ACTIONS"
-		},
-		{
-			"name": "GitHub Actions",
-			"constant": "GITHUB_ACTIONS",
-			"env": "GITHUB_ACTIONS",
-			"pr": { "GITHUB_EVENT_NAME": "pull_request" }
-		},
-		{
-			"name": "GitLab CI",
-			"constant": "GITLAB",
-			"env": "GITLAB_CI",
-			"pr": "CI_MERGE_REQUEST_ID"
-		},
-		{
-			"name": "GoCD",
-			"constant": "GOCD",
-			"env": "GO_PIPELINE_LABEL"
-		},
-		{
-			"name": "Google Cloud Build",
-			"constant": "GOOGLE_CLOUD_BUILD",
-			"env": "BUILDER_OUTPUT"
-		},
-		{
-			"name": "Harness CI",
-			"constant": "HARNESS",
-			"env": "HARNESS_BUILD_ID"
-		},
-		{
-			"name": "Heroku",
-			"constant": "HEROKU",
-			"env": {
-				"env": "NODE",
-				"includes": "/app/.heroku/node/bin/node"
-			}
-		},
-		{
-			"name": "Hudson",
-			"constant": "HUDSON",
-			"env": "HUDSON_URL"
-		},
-		{
-			"name": "Jenkins",
-			"constant": "JENKINS",
-			"env": ["JENKINS_URL", "BUILD_ID"],
-			"pr": { "any": ["ghprbPullId", "CHANGE_ID"] }
-		},
-		{
-			"name": "LayerCI",
-			"constant": "LAYERCI",
-			"env": "LAYERCI",
-			"pr": "LAYERCI_PULL_REQUEST"
-		},
-		{
-			"name": "Magnum CI",
-			"constant": "MAGNUM",
-			"env": "MAGNUM"
-		},
-		{
-			"name": "Netlify CI",
-			"constant": "NETLIFY",
-			"env": "NETLIFY",
-			"pr": {
-				"env": "PULL_REQUEST",
-				"ne": "false"
-			}
-		},
-		{
-			"name": "Nevercode",
-			"constant": "NEVERCODE",
-			"env": "NEVERCODE",
-			"pr": {
-				"env": "NEVERCODE_PULL_REQUEST",
-				"ne": "false"
-			}
-		},
-		{
-			"name": "Prow",
-			"constant": "PROW",
-			"env": "PROW_JOB_ID"
-		},
-		{
-			"name": "ReleaseHub",
-			"constant": "RELEASEHUB",
-			"env": "RELEASE_BUILD_ID"
-		},
-		{
-			"name": "Render",
-			"constant": "RENDER",
-			"env": "RENDER",
-			"pr": { "IS_PULL_REQUEST": "true" }
-		},
-		{
-			"name": "Sail CI",
-			"constant": "SAIL",
-			"env": "SAILCI",
-			"pr": "SAIL_PULL_REQUEST_NUMBER"
-		},
-		{
-			"name": "Screwdriver",
-			"constant": "SCREWDRIVER",
-			"env": "SCREWDRIVER",
-			"pr": {
-				"env": "SD_PULL_REQUEST",
-				"ne": "false"
-			}
-		},
-		{
-			"name": "Semaphore",
-			"constant": "SEMAPHORE",
-			"env": "SEMAPHORE",
-			"pr": "PULL_REQUEST_NUMBER"
-		},
-		{
-			"name": "Sourcehut",
-			"constant": "SOURCEHUT",
-			"env": { "CI_NAME": "sourcehut" }
-		},
-		{
-			"name": "Strider CD",
-			"constant": "STRIDER",
-			"env": "STRIDER"
-		},
-		{
-			"name": "TaskCluster",
-			"constant": "TASKCLUSTER",
-			"env": ["TASK_ID", "RUN_ID"]
-		},
-		{
-			"name": "TeamCity",
-			"constant": "TEAMCITY",
-			"env": "TEAMCITY_VERSION"
-		},
-		{
-			"name": "Travis CI",
-			"constant": "TRAVIS",
-			"env": "TRAVIS",
-			"pr": {
-				"env": "TRAVIS_PULL_REQUEST",
-				"ne": "false"
-			}
-		},
-		{
-			"name": "Vela",
-			"constant": "VELA",
-			"env": "VELA",
-			"pr": { "VELA_PULL_REQUEST": "1" }
-		},
-		{
-			"name": "Vercel",
-			"constant": "VERCEL",
-			"env": { "any": ["NOW_BUILDER", "VERCEL"] },
-			"pr": "VERCEL_GIT_PULL_REQUEST_ID"
-		},
-		{
-			"name": "Visual Studio App Center",
-			"constant": "APPCENTER",
-			"env": "APPCENTER_BUILD_ID"
-		},
-		{
-			"name": "Woodpecker",
-			"constant": "WOODPECKER",
-			"env": { "CI": "woodpecker" },
-			"pr": { "CI_BUILD_EVENT": "pull_request" }
-		},
-		{
-			"name": "Xcode Cloud",
-			"constant": "XCODE_CLOUD",
-			"env": "CI_XCODE_PROJECT",
-			"pr": "CI_PULL_REQUEST_NUMBER"
-		},
-		{
-			"name": "Xcode Server",
-			"constant": "XCODE_SERVER",
-			"env": "XCS"
-		}
-	];
-}));
-//#endregion
-//#region ../../0-framework/3-tooling/cli/dist/engine-cli-BXXH4fM-.mjs
-var import_ci_info = (/* @__PURE__ */ __commonJSMin(((exports) => {
-	const vendors = require_vendors();
-	const env = process.env;
-	Object.defineProperty(exports, "_vendors", { value: vendors.map(function(v) {
-		return v.constant;
-	}) });
-	exports.name = null;
-	exports.isPR = null;
-	exports.id = null;
-	if (env.CI !== "false") vendors.forEach(function(vendor) {
-		const isCI = (Array.isArray(vendor.env) ? vendor.env : [vendor.env]).every(function(obj) {
-			return checkEnv(obj);
-		});
-		exports[vendor.constant] = isCI;
-		if (!isCI) return;
-		exports.name = vendor.name;
-		exports.isPR = checkPR(vendor);
-		exports.id = vendor.constant;
-	});
-	exports.isCI = !!(env.CI !== "false" && (env.BUILD_ID || env.BUILD_NUMBER || env.CI || env.CI_APP_ID || env.CI_BUILD_ID || env.CI_BUILD_NUMBER || env.CI_NAME || env.CONTINUOUS_INTEGRATION || env.RUN_ID || exports.name || false));
-	function checkEnv(obj) {
-		if (typeof obj === "string") return !!env[obj];
-		if ("env" in obj) return env[obj.env] && env[obj.env].includes(obj.includes);
-		if ("any" in obj) return obj.any.some(function(k) {
-			return !!env[k];
-		});
-		return Object.keys(obj).every(function(k) {
-			return env[k] === obj[k];
-		});
-	}
-	function checkPR(vendor) {
-		switch (typeof vendor.pr) {
-			case "string": return !!env[vendor.pr];
-			case "object": if ("env" in vendor.pr) if ("any" in vendor.pr) return vendor.pr.any.some(function(key) {
-				return env[vendor.pr.env] === key;
-			});
-			else return vendor.pr.env in env && env[vendor.pr.env] !== vendor.pr.ne;
-			else if ("any" in vendor.pr) return vendor.pr.any.some(function(key) {
-				return !!env[key];
-			});
-			else return checkEnv(vendor.pr);
-			default: return null;
-		}
-	}
-})))();
-/**
-* 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",
-				status: "ok",
-				text: "Deployed."
-			}] : [{
-				kind: "summary",
-				status: "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",
-			status: "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`).
-* `undefined` when the CLI was run directly rather than through a manager — a
-* normal case, not a failure, so nothing is inferred from the filesystem, and
-* the engine falls back to its own detection from the project at cwd.
-*/
-function detectPackageManager(env) {
-	const agent = env["npm_config_user_agent"];
-	if (agent === void 0) return void 0;
-	const name = agent.split("/")[0];
-	switch (name) {
-		case "npm":
-		case "pnpm":
-		case "yarn":
-		case "bun":
-		case "deno": return name;
-		default: return;
-	}
-}
-/**
-* 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`.
-*
-* `inCI` is the one thing here not derived from the host: `ci-info` answers it
-* from the real `process.env` at import, which is what the engine's `isCI` doc
-* asks a host to wire and what the `prisma` bin already does. Production passes
-* nothing. It is a parameter so a test can still drive CI state without
-* touching a process global.
-*/
-function createRuntime(host, loadConfig, inCI = import_ci_info.isCI) {
-	const env = host.env;
-	const apiBaseUrl = env["PRISMA_MANAGEMENT_API_URL"] ?? DEFAULT_MANAGEMENT_API_BASE_URL;
-	const packageManager = detectPackageManager(env);
-	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 !== void 0 && { packageManager },
-		isCI: inCI
-	};
-}
-/**
-* 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
-//#region ../../0-framework/3-tooling/cli/dist/cli-C8cVG9HU.mjs
-/**
-* The `prisma-composer` entrypoint: adapt this process into the engine's
-* `HostProcess`, run one invocation of composer's own CLI, and hand back an
-* exit code. Grammar, help, argument validation, output framing, exit codes
-* and signal policy all belong to the engine — this module contributes the
-* process and the version, and nothing else.
-*
-* Node's `process` already satisfies `HostProcess` structurally, so there is
-* no adapter object here; that is the whole point of the engine taking a host
-* surface rather than reading globals.
-*/
-/** Printed for a throw that escapes the engine entirely — by the shared base-type rules that is a bug, not a user failure. */
-const REPORT_HINT = "This is a bug in prisma-composer, not in your app — please report it: https://github.com/prisma/composer/issues";
-const UNKNOWN_VERSION = "unknown";
-/**
-* The version the CLI reports, read from the manifest of the package this
-* module was BUNDLED INTO — `@prisma/composer` for the published bin, since
-* that is the package whose executable the user installed. Walking up from the
-* module's own location is what makes that true in both layouts: the published
-* `dist/bin.mjs` finds `@prisma/composer`'s manifest, and a direct run of
-* `src/bin.ts` finds this package's.
-*/
-function shippedVersion(fromDir = path.dirname(fileURLToPath(import.meta.url))) {
-	let dir = fromDir;
-	while (true) {
-		const manifest = path.join(dir, "package.json");
-		if (fs.existsSync(manifest)) try {
-			const version = JSON.parse(fs.readFileSync(manifest, "utf-8")).version;
-			return typeof version === "string" ? version : UNKNOWN_VERSION;
-		} catch {
-			return UNKNOWN_VERSION;
-		}
-		const parent = path.dirname(dir);
-		if (parent === dir) return UNKNOWN_VERSION;
-		dir = parent;
-	}
-}
-/**
-* Runs `prisma-composer` end to end and returns the process exit code. The
-* caller assigns it to `process.exitCode` rather than exiting, so the streams
-* drain — the engine returns a code for exactly this reason.
-*
-* The catch is not error handling for commands: the engine renders every
-* command failure itself. It catches a throw that escaped the engine — a
-* construction fault, a broken config load — which by ADR-0044 is a bug in
-* this CLI and exits 1 with a report hint.
-*/
-async function cli(argv = process.argv.slice(2)) {
-	try {
-		return await runComposerCli(argv, process, { version: shippedVersion() });
-	} catch (error) {
-		console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
-		console.error(REPORT_HINT);
-		return 1;
-	}
-}
-//#endregion
-//#region ../../0-framework/3-tooling/cli/dist/bin.mjs
-process.exitCode = await cli();
-//#endregion
-export {};
-
-//# sourceMappingURL=bin.mjs.map