@prisma/composer 0.2.0 → 0.3.0-dev.1

package/dist/bin.mjs

@@ -2,50 +2,60 @@
 import { Cli, Command, Option, UsageError } from "clipanion";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { join, relative, resolve, sep } from "node:path";
+import "alchemy";
+import "effect/Effect";
+import "effect/Layer";
 import * as c12 from "c12";
 import { pathToFileURL } from "node:url";
 import { spawnSync } from "node:child_process";
-//#region ../../0-framework/3-tooling/assemble/dist/index.mjs
-/**
-* A user-facing assembly failure with a message that already names the fix
-* (mirrors @internal/cli's CliError contract). This package must not import
-* CliError — its second consumer is the future programmatic deploy API, not
-* just the CLI — so it throws its own typed error; the CLI maps it (or lets
-* it propagate, since bin.ts already treats every Error uniformly: print the
-* message, exit nonzero).
-*/
-var AssembleError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "AssembleError";
+import { stat, unwatchFile, watch, watchFile } from "fs";
+import { lstat, open, readdir, realpath, stat as stat$1 } from "fs/promises";
+import { EventEmitter } from "events";
+import * as sysPath from "path";
+import { lstat as lstat$1, readdir as readdir$1, realpath as realpath$1, stat as stat$2 } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { type } from "os";
+//#region ../../0-framework/1-core/core/dist/container-transport-DKmKg5JQ.mjs
+/** '@prisma/composer-prisma-cloud' → 'PRISMA_COMPOSER_CONTAINER_PRISMA_COMPOSER_PRISMA_CLOUD' */
+function containerEnvVarName(extensionId) {
+	return `PRISMA_COMPOSER_CONTAINER_${extensionId.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+}
+function collisionError(a, b, varName) {
+	return /* @__PURE__ */ new Error(`Extension ids "${a}" and "${b}" both mangle to the container transport variable "${varName}" — rename one of the extensions.`);
+}
+function emptySerializeError(extensionId) {
+	return /* @__PURE__ */ new Error(`Extension "${extensionId}"'s container instance serialized to an empty string — ContainerInstance.serialize() must return a non-empty string.`);
+}
+/** The env entries the CLI sets on the alchemy process: `{ [containerEnvVarName(id)]: instance.serialize() }` for every resolved instance. */
+function containerEnv(instances) {
+	const env = {};
+	const ownerByVarName = /* @__PURE__ */ new Map();
+	for (const [extensionId, instance] of instances) {
+		const varName = containerEnvVarName(extensionId);
+		const owner = ownerByVarName.get(varName);
+		if (owner !== void 0) throw collisionError(owner, extensionId, varName);
+		ownerByVarName.set(varName, extensionId);
+		const serialized = instance.serialize();
+		if (serialized.length === 0) throw emptySerializeError(extensionId);
+		env[varName] = serialized;
 	}
-};
+	return env;
+}
+//#endregion
+//#region ../../0-framework/1-core/core/dist/app-config-joXc-BKm.mjs
+/** `<cwd>/.prisma-composer/dev` — the dev instance's app-scoped state directory (ADR-0041, ADR-0004's tool-state rule). "dev" names the user-facing feature/dir (naming, operator 2026-07-23) — this constant's name and value are unchanged by the localTarget rename. */
+const DEV_DIR = ".prisma-composer/dev";
 /**
-* The registry route for one service's build: extension by
-* `build.extension`, node descriptor by `build.type`, kind must be "build".
-* The CLI's coverage validation reports the same misses earlier with the
-* config fix; these errors are the backstop for programmatic callers.
+* True when an extension only participates in assembly (every `nodes` entry
+* is `kind: 'build'`, and it declares none of `providers`/`application`/
+* `provisions`/`container`) — it owns no resources or services, so it has
+* nothing to emulate and is exempt from local-target-capability requirements
+* (ADR-0041). Shared by `localTargetProviders` and every local-target hook
+* iteration.
 */
-function buildDescriptorAssemble(config, node, address, cwd) {
-	const { extension, type } = node.build;
-	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
-	if (extensionDescriptor === void 0) throw new AssembleError(`No extension "${extension}" is configured (needed by service "${node.name}"'s build) — add it to prisma-composer.config.ts's \`extensions\`.`);
-	const nodeDescriptor = extensionDescriptor.nodes[type];
-	if (nodeDescriptor === void 0) throw new AssembleError(`Extension "${extension}" has no descriptor for build type "${type}" (known: ${Object.keys(extensionDescriptor.nodes).join(", ")}).`);
-	if (nodeDescriptor.kind !== "build") throw new AssembleError(`Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor — assembling a service build needs a "build" descriptor.`);
-	return nodeDescriptor.assemble({
-		build: node.build,
-		address,
-		cwd
-	});
-}
-async function assembleServices(graph, config, cwd, run) {
-	const runAssembler = run ?? ((node, address, nodeCwd) => buildDescriptorAssemble(config, node, address, nodeCwd));
-	const serviceNodes = graph.nodes.filter((n) => n.node.kind === "service");
-	if (serviceNodes.length === 0) throw new AssembleError("The loaded graph has no service to assemble.");
-	const bundles = {};
-	for (const { id, node } of serviceNodes) bundles[id] = await runAssembler(node, id, cwd);
-	return { bundles };
+function isBuildOnlyExtension(extension) {
+	return Object.values(extension.nodes).every((node) => node.kind === "build") && extension.providers === void 0 && extension.application === void 0 && extension.provisions === void 0 && extension.container === void 0;
 }
 //#endregion
 //#region ../../0-framework/0-foundation/foundation/dist/casts.mjs
@@ -88,7 +98,7 @@ function blindCast(input) {
 	return input;
 }
 //#endregion
-//#region ../../0-framework/1-core/core/dist/graph-BmrUEdo9.mjs
+//#region ../../0-framework/1-core/core/dist/graph-CP16cJyH.mjs
 /** Thrown by Load when the graph is malformed. */
 var LoadError = class extends Error {
 	constructor(message) {
@@ -112,6 +122,15 @@ function isParamSource(value) {
 	return typeof value === "object" && value !== null && blindCast(value)[PARAM_SOURCE] === true;
 }
 /**
+* Core's grammar for every name that becomes a config-key segment —
+* addresses, input/param/secret names: ASCII letters and digits only.
+* Conservative by design so any target medium — POSIX env-var keys
+* included — can uppercase and "_"-join segments without escaping.
+*/
+function isConfigKeySegment(name) {
+	return /^[A-Za-z0-9]+$/.test(name);
+}
+/**
 * True if `value` was constructed by this module's factories. Checks the
 * brand only, never a prototype — a graph may mix nodes from a different
 * installed copy of core (dual-package hazard).
@@ -399,7 +418,7 @@ function flatten(moduleNode, address, wiring, secretWiring, paramWiring, nodes,
 		const provisionSecrets = opts?.secrets;
 		const provisionParams = opts?.params;
 		if (typeof id !== "string" || id.length === 0) throw new LoadError(`provision() requires a non-empty id (module "${moduleNode.name}").`);
-		if (id.includes("_") || id.includes(".")) throw new LoadError(`provision() id "${id}" (module "${moduleNode.name}") may not contain "_" or "." — "_" is the config-key separator and "." the node-id path separator; either inside an id collides with the joined form of other names.`);
+		if (!isConfigKeySegment(id)) throw new LoadError(`provision() id "${id}" (module "${moduleNode.name}") must contain only ASCII letters and digits ([A-Za-z0-9]) — the id becomes an address segment, and addresses derive deterministic config keys (segments uppercased and joined with "_"). "${id}" would put "${id.toUpperCase()}" inside the derived key. ("_" collides with the key separator and "." with the address separator.)`);
 		if (localIds.has(id)) throw new LoadError(`Duplicate provision id "${id}" in module "${moduleNode.name}".`);
 		const untrusted = child;
 		if (!isNode(untrusted) || untrusted.kind !== "service" && untrusted.kind !== "resource" && untrusted.kind !== "module") throw new LoadError(`provision("${id}") expects a branded service, resource, or module node (construct it with the service()/resource()/module() factories or a pack's own).`);
@@ -575,129 +594,1675 @@ function Load(root, opts) {
 	throw new LoadError("Load expects a service or module root (received another node kind).");
 }
 //#endregion
-//#region ../../0-framework/1-core/core/dist/container-transport-DKmKg5JQ.mjs
-/** '@prisma/composer-prisma-cloud' → 'PRISMA_COMPOSER_CONTAINER_PRISMA_COMPOSER_PRISMA_CLOUD' */
-function containerEnvVarName(extensionId) {
-	return `PRISMA_COMPOSER_CONTAINER_${extensionId.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
-}
-function collisionError(a, b, varName) {
-	return /* @__PURE__ */ new Error(`Extension ids "${a}" and "${b}" both mangle to the container transport variable "${varName}" — rename one of the extensions.`);
-}
-function emptySerializeError(extensionId) {
-	return /* @__PURE__ */ new Error(`Extension "${extensionId}"'s container instance serialized to an empty string — ContainerInstance.serialize() must return a non-empty string.`);
-}
-/** The env entries the CLI sets on the alchemy process: `{ [containerEnvVarName(id)]: instance.serialize() }` for every resolved instance. */
-function containerEnv(instances) {
-	const env = {};
-	const ownerByVarName = /* @__PURE__ */ new Map();
-	for (const [extensionId, instance] of instances) {
-		const varName = containerEnvVarName(extensionId);
-		const owner = ownerByVarName.get(varName);
-		if (owner !== void 0) throw collisionError(owner, extensionId, varName);
-		ownerByVarName.set(varName, extensionId);
-		const serialized = instance.serialize();
-		if (serialized.length === 0) throw emptySerializeError(extensionId);
-		env[varName] = serialized;
+//#region ../../0-framework/1-core/core/dist/deploy-H3PKi0ZR.mjs
+var LowerError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LowerError";
 	}
-	return env;
+};
+//#endregion
+//#region ../../0-framework/1-core/core/dist/local-target.mjs
+/** The local-target stack's own provider aggregation (ADR-0041; naming, operator 2026-07-23 — the seam is `localTarget`, "dev" names the user-facing feature only) — the local-target counterpart of `deploy.ts`'s `mergedProviders`, kept in its own module so `lower()` learns nothing about it (deploy.ts's REVISED — operator review of #162). */
+function noLocalTargetSupportError(id) {
+	return new LowerError(`extension "${id}" has no dev support — it declares no \`localTarget\` descriptor (ADR-0041).`);
+}
+/**
+* Resolves every non-build-only configured extension's lazy `localTarget`
+* thunk, once (ADR-0041's lazy local-target reference — operator directive:
+* the production control entry carries only the thunk, never the
+* descriptor, so resolving it is this module's job, not something a deploy
+* path ever does). A build-only extension (`isBuildOnlyExtension`) owns no
+* resources or services and is skipped entirely — never even checked for a
+* `localTarget` thunk. Every other configured extension must be
+* local-target-capable, or the dev command cannot bring the app up at all,
+* so a missing thunk throws naming the extension. The generated dev stack
+* module calls this once and threads the resolved map through every
+* subsequent hook, including `localTargetProviders`.
+*/
+async function resolveLocalTargets(config) {
+	const entries = await Promise.all(config.extensions.flatMap((extension) => {
+		if (isBuildOnlyExtension(extension)) return [];
+		if (extension.localTarget === void 0) throw noLocalTargetSupportError(extension.id);
+		return [extension.localTarget().then((descriptor) => [extension.id, descriptor])];
+	}));
+	return new Map(entries);
 }
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/cli-Bc6_i0ls.mjs
+//#region ../../0-framework/3-tooling/assemble/dist/index.mjs
 /**
-* A user-facing failure with a message that already names the fix (deploy-cli.md
-* § Error surface). `bin.ts` catches this — and any other Error, including
-* core's LoadError/LowerError — uniformly: print the message, exit nonzero.
+* A user-facing assembly failure with a message that already names the fix
+* (mirrors @internal/cli's CliError contract). This package must not import
+* CliError — its second consumer is the future programmatic deploy API, not
+* just the CLI — so it throws its own typed error; the CLI maps it (or lets
+* it propagate, since bin.ts already treats every Error uniformly: print the
+* message, exit nonzero).
 */
-var CliError = class extends Error {
+var AssembleError = class extends Error {
 	constructor(message) {
 		super(message);
-		this.name = "CliError";
+		this.name = "AssembleError";
 	}
 };
-/** Pipeline step 6: writes a regenerated-every-run, independently runnable stack module at `.prisma-composer/alchemy.run.ts`. */
-const GENERATED_DIR = ".prisma-composer";
-const GENERATED_FILE = "alchemy.run.ts";
-/** A relative import specifier from `.prisma-composer/alchemy.run.ts` to `target` (posix separators). */
-function relativeImportSpecifier(generatedDir, target) {
-	const rel = path.relative(generatedDir, target).split(path.sep).join("/");
-	return rel.startsWith(".") ? rel : `./${rel}`;
-}
-function quote(value) {
-	return JSON.stringify(value);
-}
-function renderBundle(bundle) {
-	return `{ dir: ${quote(bundle.dir)}, entry: ${quote(bundle.entry)} }`;
-}
-function renderOptions(input) {
-	const lines = [];
-	lines.push(`  name: ${quote(input.name)},`);
-	lines.push("  bundles: {");
-	for (const [id, bundle] of Object.entries(input.assembled.bundles)) lines.push(`    ${quote(id)}: ${renderBundle(bundle)},`);
-	lines.push("  },");
-	lines.push("  report: deploymentReport,");
-	return lines.join("\n");
+/**
+* The registry route for one service's build: extension by
+* `build.extension`, node descriptor by `build.type`, kind must be "build".
+* The CLI's coverage validation reports the same misses earlier with the
+* config fix; these errors are the backstop for programmatic callers.
+*/
+function buildDescriptorAssemble(config, node, address, cwd) {
+	const { extension, type } = node.build;
+	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
+	if (extensionDescriptor === void 0) throw new AssembleError(`No extension "${extension}" is configured (needed by service "${node.name}"'s build) — add it to prisma-composer.config.ts's \`extensions\`.`);
+	const nodeDescriptor = extensionDescriptor.nodes[type];
+	if (nodeDescriptor === void 0) throw new AssembleError(`Extension "${extension}" has no descriptor for build type "${type}" (known: ${Object.keys(extensionDescriptor.nodes).join(", ")}).`);
+	if (nodeDescriptor.kind !== "build") throw new AssembleError(`Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor — assembling a service build needs a "build" descriptor.`);
+	return nodeDescriptor.assemble({
+		build: node.build,
+		address,
+		cwd
+	});
 }
-/** Renders the stack module's source (tests assert on it without touching disk) — uses `//` headers, not a block comment, since a cwd path with a star-slash could close one early. */
-function renderStackFile(input) {
-	const generatedDir = path.join(input.cwd, GENERATED_DIR);
-	const appImport = relativeImportSpecifier(generatedDir, input.entryPath);
-	const configImport = relativeImportSpecifier(generatedDir, input.configPath);
-	return `// Generated by \`prisma-composer deploy\`/\`prisma-composer destroy\` — overwritten on every
-// run; do not edit by hand. Independently runnable from ${quote(input.cwd)}:
-//
-//   alchemy deploy ${GENERATED_DIR}/${GENERATED_FILE}
-//
-// bisects a CLI bug from an Alchemy bug (deploy-cli.md § Implementation decisions).
-import { lower } from '@prisma/composer/deploy';
-import { deploymentReport } from '@prisma/composer/report';
-import config from ${quote(configImport)};
-import app from ${quote(appImport)};
-
-export default lower(app, config, {
-${renderOptions(input)}
-});
-`;
+async function assembleServices(graph, config, cwd, run) {
+	const runAssembler = run ?? ((node, address, nodeCwd) => buildDescriptorAssemble(config, node, address, nodeCwd));
+	const serviceNodes = graph.nodes.filter((n) => n.node.kind === "service");
+	if (serviceNodes.length === 0) throw new AssembleError("The loaded graph has no service to assemble.");
+	const bundles = {};
+	for (const { id, node } of serviceNodes) bundles[id] = await runAssembler(node, id, cwd);
+	return { bundles };
 }
-/** Writes the stack file, returning its absolute path. */
-function writeStackFile(input) {
-	const generatedDir = path.join(input.cwd, GENERATED_DIR);
-	fs.mkdirSync(generatedDir, { recursive: true });
-	const filePath = path.join(generatedDir, GENERATED_FILE);
-	fs.writeFileSync(filePath, renderStackFile(input));
-	return filePath;
+//#endregion
+//#region ../../0-framework/3-tooling/cli/node_modules/readdirp/esm/index.js
+const EntryTypes = {
+	FILE_TYPE: "files",
+	DIR_TYPE: "directories",
+	FILE_DIR_TYPE: "files_directories",
+	EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+	root: ".",
+	fileFilter: (_entryInfo) => true,
+	directoryFilter: (_entryInfo) => true,
+	type: EntryTypes.FILE_TYPE,
+	lstat: false,
+	depth: 2147483648,
+	alwaysStat: false,
+	highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set([
+	"ENOENT",
+	"EPERM",
+	"EACCES",
+	"ELOOP",
+	RECURSIVE_ERROR_CODE
+]);
+const ALL_TYPES = [
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = /* @__PURE__ */ new Set([
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = /* @__PURE__ */ new Set([
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+	if (filter === void 0) return emptyFn;
+	if (typeof filter === "function") return filter;
+	if (typeof filter === "string") {
+		const fl = filter.trim();
+		return (entry) => entry.basename === fl;
+	}
+	if (Array.isArray(filter)) {
+		const trItems = filter.map((item) => item.trim());
+		return (entry) => trItems.some((f) => entry.basename === f);
+	}
+	return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+var ReaddirpStream = class extends Readable {
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const { root, type } = opts;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat$1 : stat$2;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth ?? defaultOptions.depth;
+		this._wantsDir = type ? DIR_TYPES.has(type) : false;
+		this._wantsFile = type ? FILE_TYPES.has(type) : false;
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		this.parents = [this._exploreDir(root, 1)];
+		this.reading = false;
+		this.parent = void 0;
+	}
+	async _read(batch) {
+		if (this.reading) return;
+		this.reading = true;
+		try {
+			while (!this.destroyed && batch > 0) {
+				const par = this.parent;
+				const fil = par && par.files;
+				if (fil && fil.length > 0) {
+					const { path, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+					const awaited = await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						const entryType = await this._getEntryType(entry);
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+							if (this._wantsDir) {
+								this.push(entry);
+								batch--;
+							}
+						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+							if (this._wantsFile) {
+								this.push(entry);
+								batch--;
+							}
+						}
+					}
+				} else {
+					const parent = this.parents.pop();
+					if (!parent) {
+						this.push(null);
+						break;
+					}
+					this.parent = await parent;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path, depth) {
+		let files;
+		try {
+			files = await readdir$1(path, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path
+		};
+	}
+	async _formatEntry(dirent, path) {
+		let entry;
+		const basename = this._isDirent ? dirent.name : dirent;
+		try {
+			const fullPath = resolve(join(path, basename));
+			entry = {
+				path: relative(this._root, fullPath),
+				fullPath,
+				basename
+			};
+			entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+		} catch (err) {
+			this._onError(err);
+			return;
+		}
+		return entry;
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	async _getEntryType(entry) {
+		if (!entry && this._statsProp in entry) return "";
+		const stats = entry[this._statsProp];
+		if (stats.isFile()) return "file";
+		if (stats.isDirectory()) return "directory";
+		if (stats && stats.isSymbolicLink()) {
+			const full = entry.fullPath;
+			try {
+				const entryRealPath = await realpath$1(full);
+				const entryRealPathStats = await lstat$1(entryRealPath);
+				if (entryRealPathStats.isFile()) return "file";
+				if (entryRealPathStats.isDirectory()) {
+					const len = entryRealPath.length;
+					if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+						const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+						recursiveError.code = RECURSIVE_ERROR_CODE;
+						return this._onError(recursiveError);
+					}
+					return "directory";
+				}
+			} catch (error) {
+				this._onError(error);
+				return "";
+			}
+		}
+	}
+	_includeAsFile(entry) {
+		const stats = entry && entry[this._statsProp];
+		return stats && this._wantsEverything && !stats.isDirectory();
+	}
+};
+/**
+* Streaming version: Reads all files and directories in given root recursively.
+* Consumes ~constant small amount of RAM.
+* @param root Root directory
+* @param options Options to specify root (start directory), filters and recursion depth
+*/
+function readdirp(root, options = {}) {
+	let type = options.entryType || options.type;
+	if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
+	if (type) options.type = type;
+	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+	else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	options.root = root;
+	return new ReaddirpStream(options);
 }
-const GENERATED_STACK_RELATIVE_PATH = path.join(GENERATED_DIR, GENERATED_FILE);
+//#endregion
+//#region ../../0-framework/3-tooling/cli/node_modules/chokidar/esm/handler.js
+const STR_DATA = "data";
+const STR_CLOSE = "close";
+const EMPTY_FN = () => {};
+const pl = process.platform;
+const isWindows = pl === "win32";
+const isMacos = pl === "darwin";
+const isLinux = pl === "linux";
+const isFreeBSD = pl === "freebsd";
+const isIBMi = type() === "OS400";
+const EVENTS = {
+	ALL: "all",
+	READY: "ready",
+	ADD: "add",
+	CHANGE: "change",
+	ADD_DIR: "addDir",
+	UNLINK: "unlink",
+	UNLINK_DIR: "unlinkDir",
+	RAW: "raw",
+	ERROR: "error"
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = "watch";
+const statMethods = {
+	lstat,
+	stat: stat$1
+};
+const KEY_LISTENERS = "listeners";
+const KEY_ERR = "errHandlers";
+const KEY_RAW = "rawEmitters";
+const HANDLER_KEYS = [
+	KEY_LISTENERS,
+	KEY_ERR,
+	KEY_RAW
+];
+const binaryExtensions = /* @__PURE__ */ new Set([
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"afdesign",
+	"afphoto",
+	"afpub",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+const foreach = (val, fn) => {
+	if (val instanceof Set) val.forEach(fn);
+	else fn(val);
+};
+const addAndConvert = (main, prop, item) => {
+	let container = main[prop];
+	if (!(container instanceof Set)) main[prop] = container = /* @__PURE__ */ new Set([container]);
+	container.add(item);
+};
+const clearItem = (cont) => (key) => {
+	const set = cont[key];
+	if (set instanceof Set) set.clear();
+	else delete cont[key];
+};
+const delFromSet = (main, prop, item) => {
+	const container = main[prop];
+	if (container instanceof Set) container.delete(item);
+	else if (container === item) delete main[prop];
+};
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+const FsWatchInstances = /* @__PURE__ */ new Map();
 /**
-* Pipeline step: find and load `prisma-composer.config.ts` (ADR-0017) — the ONE
-* file that imports control-plane code. Discovery is the standard walk-up
-* from the deploy entry's directory (mirrors prisma-next's config-loader);
-* loading is c12 with that explicit path (rc/global/package.json lookups
-* disabled), so the config file's own static imports resolve from the app
-* root by whatever package manager runs — no specifier construction, no
-* anchoring. The loaded shape is validated field-by-field with CliErrors
-* naming the field.
+* Instantiates the fs_watch interface
+* @param path to be watched
+* @param options to be passed to fs_watch
+* @param listener main event handler
+* @param errHandler emits info about errors
+* @param emitRaw emits raw event data
+* @returns {NativeFsWatcher}
 */
-const CONFIG_FILENAME = "prisma-composer.config.ts";
-/** Walks UP from the entry file's directory looking for the literal CONFIG_FILENAME; undefined when the walk hits the filesystem root. */
-function findConfigPathForEntry(entryPath) {
-	let current = path.dirname(path.resolve(entryPath));
-	while (true) {
-		const candidate = path.join(current, CONFIG_FILENAME);
-		if (fs.existsSync(candidate)) return candidate;
-		const parent = path.dirname(current);
-		if (parent === current) return void 0;
-		current = parent;
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+	const handleEvent = (rawEvent, evPath) => {
+		listener(path);
+		emitRaw(rawEvent, evPath, { watchedPath: path });
+		if (evPath && path !== evPath) fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+	};
+	try {
+		return watch(path, { persistent: options.persistent }, handleEvent);
+	} catch (error) {
+		errHandler(error);
+		return;
 	}
 }
-function missingConfigError(entryPath) {
-	return new CliError(`No ${CONFIG_FILENAME} found walking up from "${path.dirname(path.resolve(entryPath))}" — the deploy needs the app's config file. Create one next to (or above) the entry, default-exporting defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.`);
-}
-function fieldError(field, requirement) {
-	return new CliError(`${CONFIG_FILENAME}: \`${field}\` ${requirement} — see defineConfig() in '@prisma/composer/config'.`);
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
+/**
+* Helper for passing fs_watch event data to a collection of listeners
+* @param fullPath absolute path bound to fs_watch instance
+*/
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+	const cont = FsWatchInstances.get(fullPath);
+	if (!cont) return;
+	foreach(cont[listenerType], (listener) => {
+		listener(val1, val2, val3);
+	});
+};
+/**
+* Instantiates the fs_watch interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path
+* @param fullPath absolute path
+* @param options to be passed to fs_watch
+* @param handlers container for event listener functions
+*/
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+	const { listener, errHandler, rawEmitter } = handlers;
+	let cont = FsWatchInstances.get(fullPath);
+	let watcher;
+	if (!options.persistent) {
+		watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+		if (!watcher) return;
+		return watcher.close.bind(watcher);
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_ERR, errHandler);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+		if (!watcher) return;
+		watcher.on(EV.ERROR, async (error) => {
+			const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+			if (cont) cont.watcherUnusable = true;
+			if (isWindows && error.code === "EPERM") try {
+				await (await open(path, "r")).close();
+				broadcastErr(error);
+			} catch (err) {}
+			else broadcastErr(error);
+		});
+		cont = {
+			listeners: listener,
+			errHandlers: errHandler,
+			rawEmitters: rawEmitter,
+			watcher
+		};
+		FsWatchInstances.set(fullPath, cont);
+	}
+	return () => {
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_ERR, errHandler);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			cont.watcher.close();
+			FsWatchInstances.delete(fullPath);
+			HANDLER_KEYS.forEach(clearItem(cont));
+			cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+const FsWatchFileInstances = /* @__PURE__ */ new Map();
+/**
+* Instantiates the fs_watchFile interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path to be watched
+* @param fullPath absolute path
+* @param options options to be passed to fs_watchFile
+* @param handlers container for event listener functions
+* @returns closer
+*/
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+	const { listener, rawEmitter } = handlers;
+	let cont = FsWatchFileInstances.get(fullPath);
+	const copts = cont && cont.options;
+	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+		unwatchFile(fullPath);
+		cont = void 0;
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		cont = {
+			listeners: listener,
+			rawEmitters: rawEmitter,
+			options,
+			watcher: watchFile(fullPath, options, (curr, prev) => {
+				foreach(cont.rawEmitters, (rawEmitter) => {
+					rawEmitter(EV.CHANGE, fullPath, {
+						curr,
+						prev
+					});
+				});
+				const currmtime = curr.mtimeMs;
+				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path, curr));
+			})
+		};
+		FsWatchFileInstances.set(fullPath, cont);
+	}
+	return () => {
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			FsWatchFileInstances.delete(fullPath);
+			unwatchFile(fullPath);
+			cont.options = cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+/**
+* @mixin
+*/
+var NodeFsHandler = class {
+	constructor(fsW) {
+		this.fsw = fsW;
+		this._boundHandleError = (error) => fsW._handleError(error);
+	}
+	/**
+	* Watch file for changes with fs_watchFile or fs_watch.
+	* @param path to file or dir
+	* @param listener on fs change
+	* @returns closer for the watcher instance
+	*/
+	_watchWithNodeFs(path, listener) {
+		const opts = this.fsw.options;
+		const directory = sysPath.dirname(path);
+		const basename = sysPath.basename(path);
+		this.fsw._getWatchedDir(directory).add(basename);
+		const absolutePath = sysPath.resolve(path);
+		const options = { persistent: opts.persistent };
+		if (!listener) listener = EMPTY_FN;
+		let closer;
+		if (opts.usePolling) {
+			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+			closer = setFsWatchFileListener(path, absolutePath, options, {
+				listener,
+				rawEmitter: this.fsw._emitRaw
+			});
+		} else closer = setFsWatchListener(path, absolutePath, options, {
+			listener,
+			errHandler: this._boundHandleError,
+			rawEmitter: this.fsw._emitRaw
+		});
+		return closer;
+	}
+	/**
+	* Watch a file and emit add event if warranted.
+	* @returns closer for the watcher instance
+	*/
+	_handleFile(file, stats, initialAdd) {
+		if (this.fsw.closed) return;
+		const dirname = sysPath.dirname(file);
+		const basename = sysPath.basename(file);
+		const parent = this.fsw._getWatchedDir(dirname);
+		let prevStats = stats;
+		if (parent.has(basename)) return;
+		const listener = async (path, newStats) => {
+			if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+			if (!newStats || newStats.mtimeMs === 0) try {
+				const newStats = await stat$1(file);
+				if (this.fsw.closed) return;
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+					this.fsw._closeFile(path);
+					prevStats = newStats;
+					const closer = this._watchWithNodeFs(file, listener);
+					if (closer) this.fsw._addPathCloser(path, closer);
+				} else prevStats = newStats;
+			} catch (error) {
+				this.fsw._remove(dirname, basename);
+			}
+			else if (parent.has(basename)) {
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				prevStats = newStats;
+			}
+		};
+		const closer = this._watchWithNodeFs(file, listener);
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+			if (!this.fsw._throttle(EV.ADD, file, 0)) return;
+			this.fsw._emit(EV.ADD, file, stats);
+		}
+		return closer;
+	}
+	/**
+	* Handle symlinks encountered while reading a dir.
+	* @param entry returned by readdirp
+	* @param directory path of dir being read
+	* @param path of this item
+	* @param item basename of this item
+	* @returns true if no more processing is needed for this entry.
+	*/
+	async _handleSymlink(entry, directory, path, item) {
+		if (this.fsw.closed) return;
+		const full = entry.fullPath;
+		const dir = this.fsw._getWatchedDir(directory);
+		if (!this.fsw.options.followSymlinks) {
+			this.fsw._incrReadyCount();
+			let linkPath;
+			try {
+				linkPath = await realpath(path);
+			} catch (e) {
+				this.fsw._emitReady();
+				return true;
+			}
+			if (this.fsw.closed) return;
+			if (dir.has(item)) {
+				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+					this.fsw._symlinkPaths.set(full, linkPath);
+					this.fsw._emit(EV.CHANGE, path, entry.stats);
+				}
+			} else {
+				dir.add(item);
+				this.fsw._symlinkPaths.set(full, linkPath);
+				this.fsw._emit(EV.ADD, path, entry.stats);
+			}
+			this.fsw._emitReady();
+			return true;
+		}
+		if (this.fsw._symlinkPaths.has(full)) return true;
+		this.fsw._symlinkPaths.set(full, true);
+	}
+	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+		directory = sysPath.join(directory, "");
+		throttler = this.fsw._throttle("readdir", directory, 1e3);
+		if (!throttler) return;
+		const previous = this.fsw._getWatchedDir(wh.path);
+		const current = /* @__PURE__ */ new Set();
+		let stream = this.fsw._readdirp(directory, {
+			fileFilter: (entry) => wh.filterPath(entry),
+			directoryFilter: (entry) => wh.filterDir(entry)
+		});
+		if (!stream) return;
+		stream.on(STR_DATA, async (entry) => {
+			if (this.fsw.closed) {
+				stream = void 0;
+				return;
+			}
+			const item = entry.path;
+			let path = sysPath.join(directory, item);
+			current.add(item);
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
+			if (this.fsw.closed) {
+				stream = void 0;
+				return;
+			}
+			if (item === target || !target && !previous.has(item)) {
+				this.fsw._incrReadyCount();
+				path = sysPath.join(dir, sysPath.relative(dir, path));
+				this._addToNodeFs(path, initialAdd, wh, depth + 1);
+			}
+		}).on(EV.ERROR, this._boundHandleError);
+		return new Promise((resolve, reject) => {
+			if (!stream) return reject();
+			stream.once("end", () => {
+				if (this.fsw.closed) {
+					stream = void 0;
+					return;
+				}
+				const wasThrottled = throttler ? throttler.clear() : false;
+				resolve(void 0);
+				previous.getChildren().filter((item) => {
+					return item !== directory && !current.has(item);
+				}).forEach((item) => {
+					this.fsw._remove(directory, item);
+				});
+				stream = void 0;
+				if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+			});
+		});
+	}
+	/**
+	* Read directory to add / remove files from `@watched` list and re-read it on change.
+	* @param dir fs path
+	* @param stats
+	* @param initialAdd
+	* @param depth relative to user-supplied path
+	* @param target child path targeted for watch
+	* @param wh Common watch helpers for this path
+	* @param realpath
+	* @returns closer for the watcher instance.
+	*/
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+		const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+		const tracked = parentDir.has(sysPath.basename(dir));
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
+		parentDir.add(sysPath.basename(dir));
+		this.fsw._getWatchedDir(dir);
+		let throttler;
+		let closer;
+		const oDepth = this.fsw.options.depth;
+		if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+			if (!target) {
+				await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+				if (this.fsw.closed) return;
+			}
+			closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+				if (stats && stats.mtimeMs === 0) return;
+				this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+			});
+		}
+		return closer;
+	}
+	/**
+	* Handle added file, directory, or glob pattern.
+	* Delegates call to _handleFile / _handleDir after checks.
+	* @param path to file or ir
+	* @param initialAdd was the file added at watch instantiation?
+	* @param priorWh depth relative to user-supplied path
+	* @param depth Child path actually targeted for watch
+	* @param target Child path actually targeted for watch
+	*/
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+		const ready = this.fsw._emitReady;
+		if (this.fsw._isIgnored(path) || this.fsw.closed) {
+			ready();
+			return false;
+		}
+		const wh = this.fsw._getWatchHelpers(path);
+		if (priorWh) {
+			wh.filterPath = (entry) => priorWh.filterPath(entry);
+			wh.filterDir = (entry) => priorWh.filterDir(entry);
+		}
+		try {
+			const stats = await statMethods[wh.statMethod](wh.watchPath);
+			if (this.fsw.closed) return;
+			if (this.fsw._isIgnored(wh.watchPath, stats)) {
+				ready();
+				return false;
+			}
+			const follow = this.fsw.options.followSymlinks;
+			let closer;
+			if (stats.isDirectory()) {
+				const absPath = sysPath.resolve(path);
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+				if (this.fsw.closed) return;
+				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
+			} else if (stats.isSymbolicLink()) {
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				const parent = sysPath.dirname(wh.watchPath);
+				this.fsw._getWatchedDir(parent).add(wh.watchPath);
+				this.fsw._emit(EV.ADD, wh.watchPath, stats);
+				closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+				if (this.fsw.closed) return;
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
+			ready();
+			if (closer) this.fsw._addPathCloser(path, closer);
+			return false;
+		} catch (error) {
+			if (this.fsw._handleError(error)) {
+				ready();
+				return path;
+			}
+		}
+	}
+};
+//#endregion
+//#region ../../0-framework/3-tooling/cli/node_modules/chokidar/esm/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const SLASH = "/";
+const SLASH_SLASH = "//";
+const ONE_DOT = ".";
+const TWO_DOTS = "..";
+const STRING_TYPE = "string";
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+	return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+	if (typeof matcher === "function") return matcher;
+	if (typeof matcher === "string") return (string) => matcher === string;
+	if (matcher instanceof RegExp) return (string) => matcher.test(string);
+	if (typeof matcher === "object" && matcher !== null) return (string) => {
+		if (matcher.path === string) return true;
+		if (matcher.recursive) {
+			const relative = sysPath.relative(matcher.path, string);
+			if (!relative) return false;
+			return !relative.startsWith("..") && !sysPath.isAbsolute(relative);
+		}
+		return false;
+	};
+	return () => false;
+}
+function normalizePath(path) {
+	if (typeof path !== "string") throw new Error("string expected");
+	path = sysPath.normalize(path);
+	path = path.replace(/\\/g, "/");
+	let prepend = false;
+	if (path.startsWith("//")) prepend = true;
+	const DOUBLE_SLASH_RE = /\/\//;
+	while (path.match(DOUBLE_SLASH_RE)) path = path.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path = "/" + path;
+	return path;
+}
+function matchPatterns(patterns, testString, stats) {
+	const path = normalizePath(testString);
+	for (let index = 0; index < patterns.length; index++) {
+		const pattern = patterns[index];
+		if (pattern(path, stats)) return true;
+	}
+	return false;
+}
+function anymatch(matchers, testString) {
+	if (matchers == null) throw new TypeError("anymatch: specify first argument");
+	const patterns = arrify(matchers).map((matcher) => createPattern(matcher));
+	if (testString == null) return (testString, stats) => {
+		return matchPatterns(patterns, testString, stats);
+	};
+	return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+	const paths = arrify(paths_).flat();
+	if (!paths.every((p) => typeof p === STRING_TYPE)) throw new TypeError(`Non-string provided as watch path: ${paths}`);
+	return paths.map(normalizePathToUnix);
+};
+const toUnix = (string) => {
+	let str = string.replace(BACK_SLASH_RE, SLASH);
+	let prepend = false;
+	if (str.startsWith(SLASH_SLASH)) prepend = true;
+	while (str.match(DOUBLE_SLASH_RE)) str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	if (prepend) str = SLASH + str;
+	return str;
+};
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+const normalizeIgnored = (cwd = "") => (path) => {
+	if (typeof path === "string") return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+	else return path;
+};
+const getAbsolutePath = (path, cwd) => {
+	if (sysPath.isAbsolute(path)) return path;
+	return sysPath.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+/**
+* Directory entry.
+*/
+var DirEntry = class {
+	constructor(dir, removeWatcher) {
+		this.path = dir;
+		this._removeWatcher = removeWatcher;
+		this.items = /* @__PURE__ */ new Set();
+	}
+	add(item) {
+		const { items } = this;
+		if (!items) return;
+		if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+	}
+	async remove(item) {
+		const { items } = this;
+		if (!items) return;
+		items.delete(item);
+		if (items.size > 0) return;
+		const dir = this.path;
+		try {
+			await readdir(dir);
+		} catch (err) {
+			if (this._removeWatcher) this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+		}
+	}
+	has(item) {
+		const { items } = this;
+		if (!items) return;
+		return items.has(item);
+	}
+	getChildren() {
+		const { items } = this;
+		if (!items) return [];
+		return [...items.values()];
+	}
+	dispose() {
+		this.items.clear();
+		this.path = "";
+		this._removeWatcher = EMPTY_FN;
+		this.items = EMPTY_SET;
+		Object.freeze(this);
+	}
+};
+const STAT_METHOD_F = "stat";
+const STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+	constructor(path, follow, fsw) {
+		this.fsw = fsw;
+		const watchPath = path;
+		this.path = path = path.replace(REPLACER_RE, "");
+		this.watchPath = watchPath;
+		this.fullWatchPath = sysPath.resolve(watchPath);
+		this.dirParts = [];
+		this.dirParts.forEach((parts) => {
+			if (parts.length > 1) parts.pop();
+		});
+		this.followSymlinks = follow;
+		this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+	}
+	entryPath(entry) {
+		return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+	}
+	filterPath(entry) {
+		const { stats } = entry;
+		if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+		const resolvedPath = this.entryPath(entry);
+		return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+	}
+	filterDir(entry) {
+		return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+	}
+};
+/**
+* Watches files & directories for changes. Emitted events:
+* `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+*
+*     new FSWatcher()
+*       .add(directories)
+*       .on('add', path => log('File', path, 'was added'))
+*/
+var FSWatcher = class extends EventEmitter {
+	constructor(_opts = {}) {
+		super();
+		this.closed = false;
+		this._closers = /* @__PURE__ */ new Map();
+		this._ignoredPaths = /* @__PURE__ */ new Set();
+		this._throttled = /* @__PURE__ */ new Map();
+		this._streams = /* @__PURE__ */ new Set();
+		this._symlinkPaths = /* @__PURE__ */ new Map();
+		this._watched = /* @__PURE__ */ new Map();
+		this._pendingWrites = /* @__PURE__ */ new Map();
+		this._pendingUnlinks = /* @__PURE__ */ new Map();
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		const awf = _opts.awaitWriteFinish;
+		const DEF_AWF = {
+			stabilityThreshold: 2e3,
+			pollInterval: 100
+		};
+		const opts = {
+			persistent: true,
+			ignoreInitial: false,
+			ignorePermissionErrors: false,
+			interval: 100,
+			binaryInterval: 300,
+			followSymlinks: true,
+			usePolling: false,
+			atomic: true,
+			..._opts,
+			ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+			awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? {
+				...DEF_AWF,
+				...awf
+			} : false
+		};
+		if (isIBMi) opts.usePolling = true;
+		if (opts.atomic === void 0) opts.atomic = !opts.usePolling;
+		const envPoll = process.env.CHOKIDAR_USEPOLLING;
+		if (envPoll !== void 0) {
+			const envLower = envPoll.toLowerCase();
+			if (envLower === "false" || envLower === "0") opts.usePolling = false;
+			else if (envLower === "true" || envLower === "1") opts.usePolling = true;
+			else opts.usePolling = !!envLower;
+		}
+		const envInterval = process.env.CHOKIDAR_INTERVAL;
+		if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
+		let readyCalls = 0;
+		this._emitReady = () => {
+			readyCalls++;
+			if (readyCalls >= this._readyCount) {
+				this._emitReady = EMPTY_FN;
+				this._readyEmitted = true;
+				process.nextTick(() => this.emit(EVENTS.READY));
+			}
+		};
+		this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+		this._boundRemove = this._remove.bind(this);
+		this.options = opts;
+		this._nodeFsHandler = new NodeFsHandler(this);
+		Object.freeze(opts);
+	}
+	_addIgnoredPath(matcher) {
+		if (isMatcherObject(matcher)) {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) return;
+		}
+		this._ignoredPaths.add(matcher);
+	}
+	_removeIgnoredPath(matcher) {
+		this._ignoredPaths.delete(matcher);
+		if (typeof matcher === "string") {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher) this._ignoredPaths.delete(ignored);
+		}
+	}
+	/**
+	* Adds paths to be watched on an existing FSWatcher instance.
+	* @param paths_ file or file list. Other arguments are unused
+	*/
+	add(paths_, _origAdd, _internal) {
+		const { cwd } = this.options;
+		this.closed = false;
+		this._closePromise = void 0;
+		let paths = unifyPaths(paths_);
+		if (cwd) paths = paths.map((path) => {
+			return getAbsolutePath(path, cwd);
+		});
+		paths.forEach((path) => {
+			this._removeIgnoredPath(path);
+		});
+		this._userIgnored = void 0;
+		if (!this._readyCount) this._readyCount = 0;
+		this._readyCount += paths.length;
+		Promise.all(paths.map(async (path) => {
+			const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+			if (res) this._emitReady();
+			return res;
+		})).then((results) => {
+			if (this.closed) return;
+			results.forEach((item) => {
+				if (item) this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+			});
+		});
+		return this;
+	}
+	/**
+	* Close watchers or start ignoring events from specified paths.
+	*/
+	unwatch(paths_) {
+		if (this.closed) return this;
+		const paths = unifyPaths(paths_);
+		const { cwd } = this.options;
+		paths.forEach((path) => {
+			if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+				if (cwd) path = sysPath.join(cwd, path);
+				path = sysPath.resolve(path);
+			}
+			this._closePath(path);
+			this._addIgnoredPath(path);
+			if (this._watched.has(path)) this._addIgnoredPath({
+				path,
+				recursive: true
+			});
+			this._userIgnored = void 0;
+		});
+		return this;
+	}
+	/**
+	* Close watchers and remove all listeners from watched paths.
+	*/
+	close() {
+		if (this._closePromise) return this._closePromise;
+		this.closed = true;
+		this.removeAllListeners();
+		const closers = [];
+		this._closers.forEach((closerList) => closerList.forEach((closer) => {
+			const promise = closer();
+			if (promise instanceof Promise) closers.push(promise);
+		}));
+		this._streams.forEach((stream) => stream.destroy());
+		this._userIgnored = void 0;
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		this._watched.forEach((dirent) => dirent.dispose());
+		this._closers.clear();
+		this._watched.clear();
+		this._streams.clear();
+		this._symlinkPaths.clear();
+		this._throttled.clear();
+		this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+		return this._closePromise;
+	}
+	/**
+	* Expose list of watched paths
+	* @returns for chaining
+	*/
+	getWatched() {
+		const watchList = {};
+		this._watched.forEach((entry, dir) => {
+			const index = (this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir) || ONE_DOT;
+			watchList[index] = entry.getChildren().sort();
+		});
+		return watchList;
+	}
+	emitWithAll(event, args) {
+		this.emit(event, ...args);
+		if (event !== EVENTS.ERROR) this.emit(EVENTS.ALL, event, ...args);
+	}
+	/**
+	* Normalize and emit events.
+	* Calling _emit DOES NOT MEAN emit() would be called!
+	* @param event Type of event
+	* @param path File or directory path
+	* @param stats arguments to be passed with event
+	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	async _emit(event, path, stats) {
+		if (this.closed) return;
+		const opts = this.options;
+		if (isWindows) path = sysPath.normalize(path);
+		if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+		const args = [path];
+		if (stats != null) args.push(stats);
+		const awf = opts.awaitWriteFinish;
+		let pw;
+		if (awf && (pw = this._pendingWrites.get(path))) {
+			pw.lastChange = /* @__PURE__ */ new Date();
+			return this;
+		}
+		if (opts.atomic) {
+			if (event === EVENTS.UNLINK) {
+				this._pendingUnlinks.set(path, [event, ...args]);
+				setTimeout(() => {
+					this._pendingUnlinks.forEach((entry, path) => {
+						this.emit(...entry);
+						this.emit(EVENTS.ALL, ...entry);
+						this._pendingUnlinks.delete(path);
+					});
+				}, typeof opts.atomic === "number" ? opts.atomic : 100);
+				return this;
+			}
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+				event = EVENTS.CHANGE;
+				this._pendingUnlinks.delete(path);
+			}
+		}
+		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+			const awfEmit = (err, stats) => {
+				if (err) {
+					event = EVENTS.ERROR;
+					args[0] = err;
+					this.emitWithAll(event, args);
+				} else if (stats) {
+					if (args.length > 1) args[1] = stats;
+					else args.push(stats);
+					this.emitWithAll(event, args);
+				}
+			};
+			this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+			return this;
+		}
+		if (event === EVENTS.CHANGE) {
+			if (!this._throttle(EVENTS.CHANGE, path, 50)) return this;
+		}
+		if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+			const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+			let stats;
+			try {
+				stats = await stat$1(fullPath);
+			} catch (err) {}
+			if (!stats || this.closed) return;
+			args.push(stats);
+		}
+		this.emitWithAll(event, args);
+		return this;
+	}
+	/**
+	* Common handler for errors
+	* @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	_handleError(error) {
+		const code = error && error.code;
+		if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) this.emit(EVENTS.ERROR, error);
+		return error || this.closed;
+	}
+	/**
+	* Helper utility for throttling
+	* @param actionType type being throttled
+	* @param path being acted upon
+	* @param timeout duration of time to suppress duplicate actions
+	* @returns tracking object or false if action should be suppressed
+	*/
+	_throttle(actionType, path, timeout) {
+		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
+		const action = this._throttled.get(actionType);
+		if (!action) throw new Error("invalid throttle");
+		const actionPath = action.get(path);
+		if (actionPath) {
+			actionPath.count++;
+			return false;
+		}
+		let timeoutObject;
+		const clear = () => {
+			const item = action.get(path);
+			const count = item ? item.count : 0;
+			action.delete(path);
+			clearTimeout(timeoutObject);
+			if (item) clearTimeout(item.timeoutObject);
+			return count;
+		};
+		timeoutObject = setTimeout(clear, timeout);
+		const thr = {
+			timeoutObject,
+			clear,
+			count: 0
+		};
+		action.set(path, thr);
+		return thr;
+	}
+	_incrReadyCount() {
+		return this._readyCount++;
+	}
+	/**
+	* Awaits write operation to finish.
+	* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+	* @param path being acted upon
+	* @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+	* @param event
+	* @param awfEmit Callback to be called when ready for event to be emitted.
+	*/
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
+		const awf = this.options.awaitWriteFinish;
+		if (typeof awf !== "object") return;
+		const pollInterval = awf.pollInterval;
+		let timeoutHandler;
+		let fullPath = path;
+		if (this.options.cwd && !sysPath.isAbsolute(path)) fullPath = sysPath.join(this.options.cwd, path);
+		const now = /* @__PURE__ */ new Date();
+		const writes = this._pendingWrites;
+		function awaitWriteFinishFn(prevStat) {
+			stat(fullPath, (err, curStat) => {
+				if (err || !writes.has(path)) {
+					if (err && err.code !== "ENOENT") awfEmit(err);
+					return;
+				}
+				const now = Number(/* @__PURE__ */ new Date());
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path).lastChange = now;
+				if (now - writes.get(path).lastChange >= threshold) {
+					writes.delete(path);
+					awfEmit(void 0, curStat);
+				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+			});
+		}
+		if (!writes.has(path)) {
+			writes.set(path, {
+				lastChange: now,
+				cancelWait: () => {
+					writes.delete(path);
+					clearTimeout(timeoutHandler);
+					return event;
+				}
+			});
+			timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+		}
+	}
+	/**
+	* Determines whether user has asked to ignore this path.
+	*/
+	_isIgnored(path, stats) {
+		if (this.options.atomic && DOT_RE.test(path)) return true;
+		if (!this._userIgnored) {
+			const { cwd } = this.options;
+			const ignored = (this.options.ignored || []).map(normalizeIgnored(cwd));
+			const list = [...[...this._ignoredPaths].map(normalizeIgnored(cwd)), ...ignored];
+			this._userIgnored = anymatch(list, void 0);
+		}
+		return this._userIgnored(path, stats);
+	}
+	_isntIgnored(path, stat) {
+		return !this._isIgnored(path, stat);
+	}
+	/**
+	* Provides a set of common helpers and properties relating to symlink handling.
+	* @param path file or directory pattern being watched
+	*/
+	_getWatchHelpers(path) {
+		return new WatchHelper(path, this.options.followSymlinks, this);
+	}
+	/**
+	* Provides directory tracking objects
+	* @param directory path of the directory
+	*/
+	_getWatchedDir(directory) {
+		const dir = sysPath.resolve(directory);
+		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+		return this._watched.get(dir);
+	}
+	/**
+	* Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+	*/
+	_hasReadPermissions(stats) {
+		if (this.options.ignorePermissionErrors) return true;
+		return Boolean(Number(stats.mode) & 256);
+	}
+	/**
+	* Handles emitting unlink events for
+	* files and directories, and via recursion, for
+	* files and directories within directories that are unlinked
+	* @param directory within which the following item is located
+	* @param item      base path of item/directory
+	*/
+	_remove(directory, item, isDirectory) {
+		const path = sysPath.join(directory, item);
+		const fullPath = sysPath.resolve(path);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path, 100)) return;
+		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
+		this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, nested));
+		const parent = this._getWatchedDir(directory);
+		const wasTracked = parent.has(item);
+		parent.remove(item);
+		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
+		let relPath = path;
+		if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
+		}
+		this._watched.delete(path);
+		this._watched.delete(fullPath);
+		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+		if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+		this._closePath(path);
+	}
+	/**
+	* Closes all watchers for a path
+	*/
+	_closePath(path) {
+		this._closeFile(path);
+		const dir = sysPath.dirname(path);
+		this._getWatchedDir(dir).remove(sysPath.basename(path));
+	}
+	/**
+	* Closes only file-specific watchers
+	*/
+	_closeFile(path) {
+		const closers = this._closers.get(path);
+		if (!closers) return;
+		closers.forEach((closer) => closer());
+		this._closers.delete(path);
+	}
+	_addPathCloser(path, closer) {
+		if (!closer) return;
+		let list = this._closers.get(path);
+		if (!list) {
+			list = [];
+			this._closers.set(path, list);
+		}
+		list.push(closer);
+	}
+	_readdirp(root, opts) {
+		if (this.closed) return;
+		let stream = readdirp(root, {
+			type: EVENTS.ALL,
+			alwaysStat: true,
+			lstat: true,
+			...opts,
+			depth: 0
+		});
+		this._streams.add(stream);
+		stream.once(STR_CLOSE, () => {
+			stream = void 0;
+		});
+		stream.once("end", () => {
+			if (stream) {
+				this._streams.delete(stream);
+				stream = void 0;
+			}
+		});
+		return stream;
+	}
+};
+/**
+* Instantiates watcher with paths to be tracked.
+* @param paths file / directory paths
+* @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+* @returns an instance of FSWatcher for chaining.
+* @example
+* const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+* watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+*/
+function watch$1(paths, options = {}) {
+	const watcher = new FSWatcher(options);
+	watcher.add(paths);
+	return watcher;
+}
+var esm_default = {
+	watch: watch$1,
+	FSWatcher
+};
+//#endregion
+//#region ../../0-framework/3-tooling/cli/dist/cli-CH8Ewf_a.mjs
+/**
+* A user-facing failure with a message that already names the fix (deploy-cli.md
+* § Error surface). `bin.ts` catches this — and any other Error, including
+* core's LoadError/LowerError — uniformly: print the message, exit nonzero.
+*/
+var CliError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CliError";
+	}
+};
+/**
+* Pipeline step: find and load `prisma-composer.config.ts` (ADR-0017) — the ONE
+* file that imports control-plane code. Discovery is the standard walk-up
+* from the deploy entry's directory (mirrors prisma-next's config-loader);
+* loading is c12 with that explicit path (rc/global/package.json lookups
+* disabled), so the config file's own static imports resolve from the app
+* root by whatever package manager runs — no specifier construction, no
+* anchoring. The loaded shape is validated field-by-field with CliErrors
+* naming the field.
+*/
+const CONFIG_FILENAME = "prisma-composer.config.ts";
+/** Walks UP from the entry file's directory looking for the literal CONFIG_FILENAME; undefined when the walk hits the filesystem root. */
+function findConfigPathForEntry(entryPath) {
+	let current = path.dirname(path.resolve(entryPath));
+	while (true) {
+		const candidate = path.join(current, CONFIG_FILENAME);
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
+function missingConfigError(entryPath) {
+	return new CliError(`No ${CONFIG_FILENAME} found walking up from "${path.dirname(path.resolve(entryPath))}" — the deploy needs the app's config file. Create one next to (or above) the entry, default-exporting defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.`);
+}
+function fieldError(field, requirement) {
+	return new CliError(`${CONFIG_FILENAME}: \`${field}\` ${requirement} — see defineConfig() in '@prisma/composer/config'.`);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
 /**
 * Field-by-field validation of the loaded default export — deliberately no
 * schema library: each check is a CliError naming the offending field.
@@ -742,6 +2307,41 @@ async function loadAppConfig(configPath) {
 	};
 }
 /**
+* `loadEntry` imports a user's topology with the host runtime's own module
+* loader — under node (the CLI's shebang runtime), that loader strips
+* TypeScript types but has no JSX transform (ADR-0005: the framework
+* doesn't bundle or transform the app's code; deploy loading is no
+* exception). A `.tsx`/`.jsx` file anywhere in the topology's import graph
+* dies with node's raw `ERR_UNKNOWN_FILE_EXTENSION`, which names the file
+* but not the cause or the fix. This turns that one case into a CliError
+* message that does — every other load failure (syntax errors, missing
+* files, non-JSX unknown extensions) is untouched, re-thrown as-is.
+*/
+const UNKNOWN_EXTENSION_CODE = "ERR_UNKNOWN_FILE_EXTENSION";
+const JSX_EXTENSIONS = [".tsx", ".jsx"];
+function errorCode(error) {
+	return "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function unknownExtensionPath(error) {
+	if (!(error instanceof Error)) return void 0;
+	if (errorCode(error) !== UNKNOWN_EXTENSION_CODE) return void 0;
+	return /Unknown file extension "\.\w+" for (.+)$/.exec(error.message)?.[1];
+}
+/**
+* Returns a CliError-ready message when `error` is node's
+* `ERR_UNKNOWN_FILE_EXTENSION` for a `.tsx`/`.jsx` file — `undefined` for
+* every other error (including unknown-extension failures for some other
+* extension), so the caller can fall through to its normal rethrow.
+*/
+function explainJsxLoadError(error, entryPath) {
+	const offendingPath = unknownExtensionPath(error);
+	if (offendingPath === void 0) return void 0;
+	if (!JSX_EXTENSIONS.some((ext) => offendingPath.endsWith(ext))) return void 0;
+	return `"${offendingPath}" can't be loaded: deploy loads "${entryPath}"'s topology with node's own module loader, which strips TypeScript types but has no JSX transform — so a .tsx/.jsx file can't sit anywhere in that import graph.
+
+Precompile that file in your own build (transform the JSX away, keep the real npm packages external) and import the compiled output instead of the raw .tsx/.jsx — see examples/email/scripts/build.ts in the prisma/composer repo for a worked example.`;
+}
+/**
 * Pipeline step 1 (deploy-cli.md § The pipeline): import the entry module
 * (resolved against cwd) and require its default export to be a node — a
 * service or module, branded by core's factories. Whatever this module exports
@@ -749,13 +2349,106 @@ async function loadAppConfig(configPath) {
 */
 async function loadEntry(entryArg, cwd) {
 	const resolvedPath = path.resolve(cwd, entryArg);
-	const root = (await import(pathToFileURL(resolvedPath).href)).default;
+	let mod;
+	try {
+		mod = await import(pathToFileURL(resolvedPath).href);
+	} catch (error) {
+		const explained = explainJsxLoadError(error, resolvedPath);
+		if (explained !== void 0) throw new CliError(explained);
+		throw error;
+	}
+	const root = blindCast(mod).default;
 	if (!isNode(root) || root.kind === "dependency" || root.kind === "resource") throw new CliError(`Entry module "${resolvedPath}" must default-export a node (a service or a module) — construct it with service() or module() from @prisma/composer.`);
 	return {
 		path: resolvedPath,
 		root: blindCast(root)
 	};
 }
+function lookup(extensions, extension, type, expectedKind, what) {
+	const ext = extensions.get(extension);
+	if (ext === void 0) throw new CliError(`No extension "${extension}" is configured (needed by ${what}) — add it to ${CONFIG_FILENAME}'s \`extensions\` (import its /control entry and list its descriptor).`);
+	const descriptor = ext.nodes[type];
+	if (descriptor === void 0) throw new CliError(`Extension "${extension}" has no descriptor for node type "${type}" (needed by ${what}; known: ${Object.keys(ext.nodes).join(", ")}).`);
+	if (descriptor.kind !== expectedKind) throw new CliError(`Extension "${extension}"'s descriptor for node type "${type}" is a "${descriptor.kind}" descriptor — ${what} needs a "${expectedKind}" descriptor.`);
+}
+/** Throws a CliError on the first uncovered `(extension, type)`; silent when the config covers the whole graph. */
+function validateRegistryCoverage(graph, config) {
+	const extensions = new Map(config.extensions.map((descriptor) => [descriptor.id, descriptor]));
+	for (const { id, node } of graph.nodes) {
+		if (node.kind === "resource") {
+			lookup(extensions, node.extension, node.type, "resource", `resource node "${id}"`);
+			continue;
+		}
+		if (node.kind !== "service") continue;
+		lookup(extensions, node.extension, node.type, "service", `service node "${id}"`);
+		lookup(extensions, node.build.extension, node.build.type, "build", `service node "${id}"'s build descriptor`);
+	}
+}
+/**
+* The shared prefix of `deploy`/`destroy`/`dev` (deploy-cli.md § The
+* pipeline; local-dev spec § 6): config discovery/load, entry load, Load,
+* registry coverage validation, name resolution, assemble. Deploy and dev
+* diverge after this — deploy resolves containers/preflight/stack file
+* against the hosted providers, dev against the local ones — so everything
+* up to and including assemble lives here once, consumed verbatim by both
+* `run()` (main.ts) and `runDev()` (dev/run-dev.ts), so the two pipelines
+* cannot drift.
+*/
+/**
+* The pipeline's front — config discovery/load, entry load, name resolution —
+* WITHOUT Load, coverage, or assemble. `log` needs only who the app is (its
+* config and resolved name) to reach the already-running local instance; it
+* neither builds nor provisions, so it must not require the user's built
+* output the way the full pipeline does.
+*/
+async function resolveAppIdentity(entry, overrideName, cwd, deps = {}) {
+	const resolvedEntryPath = path.resolve(cwd, entry);
+	const configPath = findConfigPathForEntry(resolvedEntryPath);
+	if (configPath === void 0) throw missingConfigError(resolvedEntryPath);
+	const config = deps.config ?? (await loadAppConfig(configPath)).config;
+	const entryModule = await loadEntry(entry, cwd);
+	const name = overrideName ?? entryModule.root.name;
+	if (name.length === 0) throw new CliError("The root node has no name — name it at authoring, or pass --name.");
+	return {
+		configPath,
+		config,
+		name
+	};
+}
+/**
+* Runs config discovery/load, entry load, Load, registry coverage, name
+* resolution, and assemble — steps 1–6 of `run()`. `onAssembleError`, when
+* given, lets a caller decorate an assemble failure with command-specific
+* guidance (destroy's "build first" hint) without this shared step knowing
+* about any one command.
+*/
+async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError) {
+	const resolvedEntryPath = path.resolve(cwd, entry);
+	const configPath = findConfigPathForEntry(resolvedEntryPath);
+	if (configPath === void 0) throw missingConfigError(resolvedEntryPath);
+	const config = deps.config ?? (await loadAppConfig(configPath)).config;
+	const entryModule = await loadEntry(entry, cwd);
+	const graph = Load(entryModule.root);
+	if (graph.root.node.kind !== "module") throw new CliError("The deploy root must be a module — wrap your service, e.g. export default module('name', ({ provision }) => { provision(service); }).");
+	validateRegistryCoverage(graph, config);
+	const name = overrideName ?? entryModule.root.name;
+	if (name.length === 0) throw new CliError("The root node has no name — name it at authoring, or pass --name.");
+	let assembled;
+	try {
+		assembled = await assembleServices(graph, config, cwd, deps.runAssembler);
+	} catch (error) {
+		if (onAssembleError !== void 0 && error instanceof Error) throw onAssembleError(error);
+		throw error;
+	}
+	return {
+		configPath,
+		config,
+		entryModule,
+		graph,
+		name,
+		assembled
+	};
+}
 /**
 * Pipeline step 7 (deploy-cli.md § The pipeline; design-notes.md's "Driving
 * Alchemy" call): shell out to the generated stack file. Resolves the
@@ -796,25 +2489,489 @@ function runAlchemy(input) {
 	if (result.error !== void 0) throw result.error;
 	return result.status ?? 1;
 }
-function lookup(extensions, extension, type, expectedKind, what) {
-	const ext = extensions.get(extension);
-	if (ext === void 0) throw new CliError(`No extension "${extension}" is configured (needed by ${what}) — add it to ${CONFIG_FILENAME}'s \`extensions\` (import its /control entry and list its descriptor).`);
-	const descriptor = ext.nodes[type];
-	if (descriptor === void 0) throw new CliError(`Extension "${extension}" has no descriptor for node type "${type}" (needed by ${what}; known: ${Object.keys(ext.nodes).join(", ")}).`);
-	if (descriptor.kind !== expectedKind) throw new CliError(`Extension "${extension}"'s descriptor for node type "${type}" is a "${descriptor.kind}" descriptor — ${what} needs a "${expectedKind}" descriptor.`);
+/**
+* Local-dev spec § 6 `generate-dev-stack.ts`: like generate-stack.ts but at
+* `.prisma-composer/dev/alchemy.run.ts`, always Alchemy stage `dev`, using
+* Alchemy's own `localState()` and no `report` — dev prints its own front
+* door (run-dev.ts), so core's presentation-free lower() gets nothing to
+* call back into. The generated module IS the one orchestration point where
+* dev provenance is resolved (spec § 3 REVISED): it deserializes the
+* containers, top-level-awaits `resolveLocalTargets(config)` (the lazy
+* `localTarget` thunks, ADR-0041), and passes
+* `providers: localTargetProviders(...)` + `state: localState()` explicitly
+* — `lower()` learns nothing about dev.
+*/
+const DEV_GENERATED_DIR = ".prisma-composer/dev";
+const DEV_GENERATED_FILE = "alchemy.run.ts";
+/** A relative import specifier from `.prisma-composer/dev/alchemy.run.ts` to `target` (posix separators). */
+function relativeImportSpecifier$1(generatedDir, target) {
+	const rel = path.relative(generatedDir, target).split(path.sep).join("/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
 }
-/** Throws a CliError on the first uncovered `(extension, type)`; silent when the config covers the whole graph. */
-function validateRegistryCoverage(graph, config) {
-	const extensions = new Map(config.extensions.map((descriptor) => [descriptor.id, descriptor]));
-	for (const { id, node } of graph.nodes) {
-		if (node.kind === "resource") {
-			lookup(extensions, node.extension, node.type, "resource", `resource node "${id}"`);
+function quote$1(value) {
+	return JSON.stringify(value);
+}
+function renderBundle$1(bundle) {
+	return `{ dir: ${quote$1(bundle.dir)}, entry: ${quote$1(bundle.entry)} }`;
+}
+function renderOptions$1(input) {
+	const lines = [];
+	lines.push(`  name: ${quote$1(input.name)},`);
+	lines.push("  bundles: {");
+	for (const [id, bundle] of Object.entries(input.assembled.bundles)) lines.push(`    ${quote$1(id)}: ${renderBundle$1(bundle)},`);
+	lines.push("  },");
+	lines.push("  providers: localTargetProviders(resolved, containers, devDir),");
+	lines.push("  state: localState(),");
+	return lines.join("\n");
+}
+/** Renders the dev stack module's source (tests assert on it without touching disk). */
+function renderDevStackFile(input) {
+	const generatedDir = path.join(input.cwd, DEV_GENERATED_DIR);
+	const appImport = relativeImportSpecifier$1(generatedDir, input.entryPath);
+	const configImport = relativeImportSpecifier$1(generatedDir, input.configPath);
+	return `// Generated by \`prisma-composer dev\` — overwritten on every run; do not
+// edit by hand. Independently runnable from ${quote$1(input.cwd)}:
+//
+//   alchemy deploy ${DEV_GENERATED_DIR}/${DEV_GENERATED_FILE} --stage dev
+//
+// bisects a CLI bug from an Alchemy bug (deploy-cli.md § Implementation decisions).
+import * as path from 'node:path';
+import { deserializeContainers } from '@prisma/composer/config';
+import { lower } from '@prisma/composer/deploy';
+import { DEV_DIR, localTargetProviders, resolveLocalTargets } from '@prisma/composer/local-target';
+import { localState } from 'alchemy/State/LocalState';
+import config from ${quote$1(configImport)};
+import app from ${quote$1(appImport)};
+
+const containers = deserializeContainers(config.extensions, process.env);
+const resolved = await resolveLocalTargets(config);
+const devDir = path.join(process.cwd(), DEV_DIR);
+
+export default lower(app, config, {
+${renderOptions$1(input)}
+});
+`;
+}
+/** Writes the dev stack file, returning its absolute path. */
+function writeDevStackFile(input) {
+	const generatedDir = path.join(input.cwd, DEV_GENERATED_DIR);
+	fs.mkdirSync(generatedDir, { recursive: true });
+	const filePath = path.join(generatedDir, DEV_GENERATED_FILE);
+	fs.writeFileSync(filePath, renderDevStackFile(input));
+	return filePath;
+}
+const DEV_STACK_RELATIVE_PATH = path.join(DEV_GENERATED_DIR, DEV_GENERATED_FILE);
+/**
+* Local-dev spec § 6 `watch.ts`: watches each assembled bundle's declared
+* `watch` paths (a directory watched recursively, a file watched through
+* its parent — see `startWatch`), debounced 300 ms and coalesced across
+* every service — one edit across several files/services still fires
+* exactly one rebuild.
+*
+* The watch ENGINE is `chokidar` v4 (operator decision, design tip 74272d8:
+* don't-reinvent-the-wheel beats the no-new-deps contract here — it absorbs
+* the atomic-rename class and the cross-platform recursive-watch
+* differences; v4 is pure JS, no native code, no glob surface — irrelevant
+* here anyway, since every target is a literal file or directory path,
+* never a pattern). The parent-directory indirection for FILE targets stays
+* OURS (`startWatch` explains why), as does the debounce: chokidar's own
+* `awaitWriteFinish` is a per-file "has this file's size stopped changing"
+* poll, a different semantic from "coalesce a burst across many files into
+* one callback," which is what the dev loop actually needs.
+*/
+const DEBOUNCE_MS = 300;
+/** Bundles → watch targets, plus the addresses with nothing watchable (the pinned one-line startup note). */
+function watchTargetsFrom(bundles) {
+	const targets = [];
+	const unwatchable = [];
+	for (const [address, bundle] of Object.entries(bundles)) {
+		const paths = bundle.watch;
+		if (paths === void 0 || paths.length === 0) {
+			unwatchable.push(address);
 			continue;
 		}
-		if (node.kind !== "service") continue;
-		lookup(extensions, node.extension, node.type, "service", `service node "${id}"`);
-		lookup(extensions, node.build.extension, node.build.type, "build", `service node "${id}"'s build descriptor`);
+		targets.push({
+			address,
+			paths
+		});
+	}
+	return {
+		targets,
+		unwatchable
+	};
+}
+/**
+* Watches every target's paths via chokidar, debounced 300 ms and coalesced
+* across every service, invoking `onChange` once per burst.
+*
+* File targets are watched THROUGH their parent directory, filtered to the
+* exact path: a watch bound directly to a file dies with the file's inode
+* on Linux, so `rm -rf dist && bun build --outfile dist/x.mjs` — every
+* rebuild's shape — would go silently unobserved after the first delete
+* (chokidar absorbs atomic renames, not unlink+recreate of a directly
+* watched file; proven by the delete-recreate test failing on Linux CI
+* only). Directory targets are watched recursively as themselves; a
+* nonexistent path is treated as a file target, so it starts reporting the
+* moment something creates it.
+*/
+function startWatch(targets, onChange) {
+	let timer;
+	const trigger = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = void 0;
+			onChange();
+		}, DEBOUNCE_MS);
+	};
+	const fileTargets = /* @__PURE__ */ new Set();
+	const directoryRoots = /* @__PURE__ */ new Set();
+	const parentRoots = /* @__PURE__ */ new Set();
+	for (const target of targets) for (const p of target.paths) {
+		const abs = path.resolve(p);
+		let isDirectory = false;
+		try {
+			isDirectory = fs.statSync(abs).isDirectory();
+		} catch {}
+		if (isDirectory) directoryRoots.add(abs);
+		else {
+			fileTargets.add(abs);
+			parentRoots.add(path.dirname(abs));
+		}
+	}
+	const reportError = (error) => {
+		console.error(`[dev] watch error: ${error instanceof Error ? error.message : String(error)}`);
+	};
+	const watchers = [];
+	if (directoryRoots.size > 0) {
+		const directoryWatcher = esm_default.watch([...directoryRoots], { ignoreInitial: true });
+		directoryWatcher.on("all", () => trigger());
+		directoryWatcher.on("error", reportError);
+		watchers.push(directoryWatcher);
+	}
+	if (parentRoots.size > 0) {
+		const parentWatcher = esm_default.watch([...parentRoots], {
+			ignoreInitial: true,
+			depth: 0
+		});
+		parentWatcher.on("all", (_event, eventPath) => {
+			if (fileTargets.has(path.resolve(eventPath))) trigger();
+		});
+		parentWatcher.on("error", reportError);
+		watchers.push(parentWatcher);
+	}
+	let markReady = () => {};
+	const allReady = Promise.all(watchers.map((watcher) => new Promise((resolve) => watcher.on("ready", () => resolve())))).then(() => {});
+	return {
+		ready: Promise.race([allReady, new Promise((resolve) => markReady = resolve)]),
+		stop: () => {
+			if (timer !== void 0) clearTimeout(timer);
+			markReady();
+			for (const watcher of watchers) watcher.close();
+		}
+	};
+}
+/**
+* Local-dev spec § 6 `run-dev.ts`: `prisma-composer dev <entry>` — steps 1–6
+* of `run()` reused via pipeline.ts, then the dev-only pipeline: capability
+* check, containers, `--fresh` teardown, preflight, emulators, converge
+* against a generated dev stack file, attach (front door + merged logs),
+* watch loop until interrupted.
+*/
+function toCliError$1(error) {
+	return error instanceof CliError ? error : new CliError(error instanceof Error ? error.message : String(error));
+}
+/** `[dev] ready:` then one line per endpoint, ordered by address depth (fewest dots first) then lexicographic. Exported for tests. */
+function renderFrontDoor(endpoints) {
+	return ["[dev] ready:", ...[...endpoints].sort((a, b) => {
+		const depthA = a.address.split(".").length;
+		const depthB = b.address.split(".").length;
+		if (depthA !== depthB) return depthA - depthB;
+		return a.address < b.address ? -1 : a.address > b.address ? 1 : 0;
+	}).map((e) => `[dev] ${e.address}  ${e.url}`)];
+}
+function printFrontDoor(endpoints) {
+	for (const line of renderFrontDoor(endpoints)) console.log(line);
+}
+const EMULATOR_RETRY_ATTEMPTS = 5;
+const EMULATOR_RETRY_DELAY_MS = 500;
+/** An emulator admin call right after a converge that just PUT dozens of resources through the same daemon can hit a transient refused/reset connection — a brief loopback hiccup under load, not a real failure. Retried before giving up. Applies to every attach admin call the dev session makes (`startServices`, `endpoints`). */
+async function withEmulatorRetry(call) {
+	let lastError;
+	for (let attempt = 1; attempt <= EMULATOR_RETRY_ATTEMPTS; attempt += 1) try {
+		return await call();
+	} catch (error) {
+		lastError = error;
+		if (attempt < EMULATOR_RETRY_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, EMULATOR_RETRY_DELAY_MS));
 	}
+	throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function mergedEndpoints(attachments) {
+	return (await Promise.all(attachments.map((a) => withEmulatorRetry(() => a.endpoints())))).flat();
+}
+/** Runs the full dev pipeline; returns the process exit code. */
+async function runDev(args, deps = {}) {
+	if (process.platform === "win32") throw new CliError("local dev is not supported on Windows yet.");
+	const cwd = process.cwd();
+	const devDir = path.join(cwd, DEV_DIR);
+	const pipelineDeps = {
+		runAssembler: deps.runAssembler,
+		config: deps.config
+	};
+	const { configPath, config, entryModule, graph, name, assembled } = await runPipeline(args.entry, args.name, cwd, pipelineDeps);
+	let resolved;
+	try {
+		resolved = await resolveLocalTargets(config);
+	} catch (error) {
+		throw toCliError$1(error);
+	}
+	const containers = /* @__PURE__ */ new Map();
+	for (const [id, dev] of resolved) try {
+		containers.set(id, await dev.container.ensure({
+			appName: name,
+			stage: void 0
+		}));
+	} catch (error) {
+		throw toCliError$1(error);
+	}
+	if (args.fresh) for (const [id, dev] of resolved) {
+		if (dev.teardown === void 0) continue;
+		try {
+			await dev.teardown({
+				container: containers.get(id),
+				stage: void 0
+			});
+		} catch (error) {
+			throw toCliError$1(error);
+		}
+	}
+	for (const [id, dev] of resolved) {
+		if (dev.preflight === void 0) continue;
+		try {
+			await dev.preflight({
+				graph,
+				container: containers.get(id),
+				stage: void 0
+			});
+		} catch (error) {
+			throw toCliError$1(error);
+		}
+	}
+	for (const [id, dev] of resolved) {
+		if (dev.emulators === void 0) continue;
+		try {
+			await dev.emulators({
+				graph,
+				container: containers.get(id),
+				devDir
+			});
+		} catch (error) {
+			throw toCliError$1(error);
+		}
+	}
+	const converge = () => {
+		const stackPath = writeDevStackFile({
+			entryPath: entryModule.path,
+			cwd,
+			configPath,
+			name,
+			assembled
+		});
+		const status = (deps.alchemy ?? runAlchemy)({
+			command: "deploy",
+			stackFileRelativePath: DEV_STACK_RELATIVE_PATH,
+			cwd,
+			stage: "dev",
+			containerEnv: containerEnv(containers)
+		});
+		if (status !== 0) {
+			console.error(`\nGenerated stack file: ${stackPath}`);
+			console.error(`Run \`alchemy deploy ${DEV_STACK_RELATIVE_PATH} --yes --stage dev\` from ${cwd} to reproduce this directly.`);
+		}
+		return status;
+	};
+	const firstStatus = converge();
+	if (firstStatus !== 0) return firstStatus;
+	const attachments = [];
+	for (const [id, dev] of resolved) attachments.push(await dev.attach({
+		container: containers.get(id),
+		devDir
+	}));
+	const started = [];
+	for (const attachment of attachments) try {
+		await withEmulatorRetry(() => attachment.startServices());
+		started.push(attachment);
+	} catch (error) {
+		await Promise.all(started.map((a) => a.stopServices().catch(() => void 0)));
+		throw toCliError$1(error);
+	}
+	printFrontDoor(await mergedEndpoints(attachments));
+	console.log(`[dev] logs: prisma-composer log ${args.entry}`);
+	const { targets, unwatchable } = watchTargetsFrom(assembled.bundles);
+	for (const address of unwatchable) console.log(`[dev] ${address} has no watchable inputs`);
+	const watch = startWatch(targets, () => {
+		(async () => {
+			try {
+				const rePipeline = await runPipeline(args.entry, args.name, cwd, pipelineDeps);
+				writeDevStackFile({
+					entryPath: rePipeline.entryModule.path,
+					cwd,
+					configPath: rePipeline.configPath,
+					name: rePipeline.name,
+					assembled: rePipeline.assembled
+				});
+				if ((deps.alchemy ?? runAlchemy)({
+					command: "deploy",
+					stackFileRelativePath: DEV_STACK_RELATIVE_PATH,
+					cwd,
+					stage: "dev",
+					containerEnv: containerEnv(containers)
+				}) !== 0) {
+					console.error("[dev] converge failed — the running app is untouched; still watching.");
+					return;
+				}
+				printFrontDoor(await mergedEndpoints(attachments));
+			} catch (error) {
+				console.error(`[dev] rebuild failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		})();
+	});
+	await watch.ready;
+	await new Promise((resolve) => {
+		let stopping = false;
+		const finish = () => {
+			if (stopping) return;
+			stopping = true;
+			console.log("[dev] stopping — the app's services are stopping; emulators and data stay up.");
+			watch.stop();
+			(async () => {
+				for (const attachment of attachments) await attachment.stopServices().catch(() => void 0);
+				console.log("[dev] stopped.");
+				resolve();
+			})();
+		};
+		process.removeAllListeners("SIGINT");
+		process.removeAllListeners("SIGTERM");
+		process.on("SIGINT", finish);
+		process.on("SIGTERM", finish);
+	});
+	return 0;
+}
+/** Pipeline step 6: writes a regenerated-every-run, independently runnable stack module at `.prisma-composer/alchemy.run.ts`. */
+const GENERATED_DIR = ".prisma-composer";
+const GENERATED_FILE = "alchemy.run.ts";
+/** A relative import specifier from `.prisma-composer/alchemy.run.ts` to `target` (posix separators). */
+function relativeImportSpecifier(generatedDir, target) {
+	const rel = path.relative(generatedDir, target).split(path.sep).join("/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function quote(value) {
+	return JSON.stringify(value);
+}
+function renderBundle(bundle) {
+	return `{ dir: ${quote(bundle.dir)}, entry: ${quote(bundle.entry)} }`;
+}
+function renderOptions(input) {
+	const lines = [];
+	lines.push(`  name: ${quote(input.name)},`);
+	lines.push("  bundles: {");
+	for (const [id, bundle] of Object.entries(input.assembled.bundles)) lines.push(`    ${quote(id)}: ${renderBundle(bundle)},`);
+	lines.push("  },");
+	lines.push("  report: deploymentReport,");
+	return lines.join("\n");
+}
+/** Renders the stack module's source (tests assert on it without touching disk) — uses `//` headers, not a block comment, since a cwd path with a star-slash could close one early. */
+function renderStackFile(input) {
+	const generatedDir = path.join(input.cwd, GENERATED_DIR);
+	const appImport = relativeImportSpecifier(generatedDir, input.entryPath);
+	const configImport = relativeImportSpecifier(generatedDir, input.configPath);
+	return `// Generated by \`prisma-composer deploy\`/\`prisma-composer destroy\` — overwritten on every
+// run; do not edit by hand. Independently runnable from ${quote(input.cwd)}:
+//
+//   alchemy deploy ${GENERATED_DIR}/${GENERATED_FILE}
+//
+// bisects a CLI bug from an Alchemy bug (deploy-cli.md § Implementation decisions).
+import { lower } from '@prisma/composer/deploy';
+import { deploymentReport } from '@prisma/composer/report';
+import config from ${quote(configImport)};
+import app from ${quote(appImport)};
+
+export default lower(app, config, {
+${renderOptions(input)}
+});
+`;
+}
+/** Writes the stack file, returning its absolute path. */
+function writeStackFile(input) {
+	const generatedDir = path.join(input.cwd, GENERATED_DIR);
+	fs.mkdirSync(generatedDir, { recursive: true });
+	const filePath = path.join(generatedDir, GENERATED_FILE);
+	fs.writeFileSync(filePath, renderStackFile(input));
+	return filePath;
+}
+const GENERATED_STACK_RELATIVE_PATH = path.join(GENERATED_DIR, GENERATED_FILE);
+/**
+* `prisma-composer log <entry> [address]` — tail the merged logs of an
+* already-running local app. It resolves the app the way `dev` does (config →
+* localTarget → container → attach) but calls only the attachment's `logs()`
+* view: it neither builds, provisions, starts, nor stops anything. `dev` no
+* longer streams logs inline (that drowned the front door once it supervises
+* more than one service); this is where logs live.
+*/
+function toCliError(error) {
+	return error instanceof CliError ? error : new CliError(error instanceof Error ? error.message : String(error));
+}
+/** Runs the log tail until interrupted; returns the process exit code. */
+async function runLog(args, deps = {}) {
+	if (process.platform === "win32") throw new CliError("local dev is not supported on Windows yet.");
+	const cwd = process.cwd();
+	const devDir = path.join(cwd, DEV_DIR);
+	const { config, name } = deps.identity ?? await resolveAppIdentity(args.entry, args.name, cwd, { config: deps.config });
+	let resolved;
+	try {
+		resolved = await resolveLocalTargets(config);
+	} catch (error) {
+		throw toCliError(error);
+	}
+	const attachments = [];
+	for (const target of resolved.values()) try {
+		const container = await target.container.ensure({
+			appName: name,
+			stage: void 0
+		});
+		attachments.push(await target.attach({
+			container,
+			devDir
+		}));
+	} catch (error) {
+		throw toCliError(error);
+	}
+	const services = (await Promise.all(attachments.map((a) => a.endpoints()))).flat();
+	if (services.length === 0) {
+		console.error(`[log] no running services for "${name}" — start it first with \`prisma-composer dev ${args.entry}\`.`);
+		return 0;
+	}
+	if (args.address !== void 0 && !services.some((s) => s.address === args.address)) throw new CliError(`no service "${args.address}" in "${name}" — running services: ${services.map((s) => s.address).join(", ")}.`);
+	const controller = new AbortController();
+	const finish = () => controller.abort();
+	process.on("SIGINT", finish);
+	process.on("SIGTERM", finish);
+	try {
+		await Promise.all(attachments.map(async (attachment) => {
+			try {
+				for await (const { service, line } of attachment.logs(controller.signal, { tail: args.tail })) {
+					if (controller.signal.aborted) return;
+					if (args.address !== void 0 && service !== args.address) continue;
+					console.log(`[${service}] ${line}`);
+				}
+			} catch (error) {
+				if (!controller.signal.aborted) console.error(`[log] stream failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}));
+	} finally {
+		process.off("SIGINT", finish);
+		process.off("SIGTERM", finish);
+	}
+	return 0;
 }
 /** A stage name must be a valid git ref (deploy-cli.md) — checked via `git check-ref-format`, never silently normalized. Runs before anything platform-specific. */
 function validateStageName(stage) {
@@ -854,8 +3011,44 @@ var DestroyCommand = class extends DeployCliCommand {
 	});
 	action = "destroy";
 };
+/** `<entry>`/`--name`/`--fresh` only — no `--stage`/`--production` (local-dev spec § 6: a working directory has exactly one dev instance, no stages). */
+var DevCommand = class extends Command {
+	static paths = [["dev"]];
+	static usage = Command.Usage({
+		description: "Bring up the application whose root node is <entry>'s default export, entirely on this machine, credential-free.",
+		examples: [["Run an app locally", "$0 dev src/service.ts"]]
+	});
+	entry = Option.String({ name: "entry" });
+	name = Option.String("--name", { description: "Override the root node's name — the dev instance's application name." });
+	fresh = Option.Boolean("--fresh", false, { description: "Destroy the dev stack and wipe the dev state directory before starting." });
+	async execute() {
+		return 0;
+	}
+};
+var LogCommand = class extends Command {
+	static paths = [["log"]];
+	static usage = Command.Usage({
+		description: "Tail the merged logs of the locally-running application whose root node is <entry>'s default export.",
+		examples: [["Tail every service", "$0 log src/service.ts"], ["Tail one service", "$0 log src/service.ts catalog.service"]]
+	});
+	entry = Option.String({ name: "entry" });
+	address = Option.String({
+		name: "address",
+		required: false
+	});
+	name = Option.String("--name", { description: "Override the root node's name — the dev instance's application name." });
+	tail = Option.String("--tail", { description: `How many trailing history lines to show before live output (default ${String(DEFAULT_LOG_TAIL)}).` });
+	async execute() {
+		return 0;
+	}
+};
 function buildCli() {
-	return Cli.from([DeployCommand, DestroyCommand], {
+	return Cli.from([
+		DeployCommand,
+		DestroyCommand,
+		DevCommand,
+		LogCommand
+	], {
 		binaryName: BINARY_NAME,
 		binaryLabel: "The prisma-composer deploy CLI"
 	});
@@ -868,6 +3061,8 @@ function isUnknownSyntaxError(error) {
 	const meta = error.clipanion;
 	return typeof meta === "object" && meta !== null && meta.type === "none";
 }
+/** `log`'s default backlog: an empty screen reads as broken, so show a little recent history before going live. */
+const DEFAULT_LOG_TAIL = 20;
 /** Exported for direct testing (main.test.ts) — not part of the package's public barrel (see index.ts). */
 function parseArgs(argv) {
 	const cli = buildCli();
@@ -883,8 +3078,31 @@ function parseArgs(argv) {
 		entry: command.entry,
 		name: command.name,
 		stage: command.stage,
-		production: command.production
+		production: command.production,
+		fresh: false
+	};
+	if (command instanceof DevCommand) return {
+		command: "dev",
+		entry: command.entry,
+		name: command.name,
+		stage: void 0,
+		production: false,
+		fresh: command.fresh
 	};
+	if (command instanceof LogCommand) {
+		const tail = command.tail === void 0 ? DEFAULT_LOG_TAIL : Number.parseInt(command.tail, 10);
+		if (Number.isNaN(tail) || tail < 0) throw new UsageError("`--tail` must be a non-negative integer.");
+		return {
+			command: "log",
+			entry: command.entry,
+			name: command.name,
+			stage: void 0,
+			production: false,
+			fresh: false,
+			address: command.address,
+			tail
+		};
+	}
 	if (argv.includes("--help") || argv.includes("-h")) throw new HelpRequested(cli.usage(null, { detailed: true }));
 	throw new UsageError(cli.usage(null, { detailed: true }));
 }
@@ -916,27 +3134,23 @@ async function run(argv, deps = {}) {
 		}
 		throw error;
 	}
+	if (args.command === "dev") return runDev(args, deps);
+	if (args.command === "log") return runLog({
+		entry: args.entry,
+		name: args.name,
+		address: args.address,
+		tail: args.tail ?? DEFAULT_LOG_TAIL
+	}, { config: deps.config });
 	const stage = effectiveStage(args);
 	if (stage !== void 0) validateStageName(stage);
 	const cwd = process.cwd();
 	if (args.command === "destroy") warnIfNoLocalDeployState(cwd);
-	const resolvedEntryPath = path.resolve(cwd, args.entry);
-	const configPath = findConfigPathForEntry(resolvedEntryPath);
-	if (configPath === void 0) throw missingConfigError(resolvedEntryPath);
-	const config = deps.config ?? (await loadAppConfig(configPath)).config;
-	const entryModule = await loadEntry(args.entry, cwd);
-	const graph = Load(entryModule.root);
-	if (graph.root.node.kind !== "module") throw new CliError("The deploy root must be a module — wrap your service, e.g. export default module('name', ({ provision }) => { provision(service); }).");
-	validateRegistryCoverage(graph, config);
-	const name = args.name ?? entryModule.root.name;
-	if (name.length === 0) throw new CliError("The root node has no name — name it at authoring, or pass --name.");
-	let assembled;
-	try {
-		assembled = await assembleServices(graph, config, cwd, deps.runAssembler);
-	} catch (error) {
-		if (args.command === "destroy" && error instanceof Error) throw new CliError(`${error.message}\n\ndestroy evaluates the same stack program as deploy, which packages the built artifacts — so the app must be built first. Run the build, then retry the destroy.`);
-		throw error;
-	}
+	const pipelineDeps = {
+		runAssembler: deps.runAssembler,
+		config: deps.config
+	};
+	const onAssembleError = args.command === "destroy" ? (error) => new CliError(`${error.message}\n\ndestroy evaluates the same stack program as deploy, which packages the built artifacts — so the app must be built first. Run the build, then retry the destroy.`) : void 0;
+	const { configPath, config, entryModule, graph, name, assembled } = await runPipeline(args.entry, args.name, cwd, pipelineDeps, onAssembleError);
 	const containers = /* @__PURE__ */ new Map();
 	for (const extension of config.extensions) {
 		if (extension.container === void 0) continue;