@prisma/composer-cli 0.6.0-dev.21

package/dist/execute-dev-BMTFWfFc-B1whS-Rr.mjs

@@ -0,0 +1,2011 @@
+import { c as CliStructuredError, n as ok, s as toStructured, t as notOk } from "./result-B4XjxVK6.mjs";
+import { n as alchemyInvocation, r as spawnAlchemy } from "./run-alchemy-D44OZlyB-DA7s331N.mjs";
+import { n as runPipeline } from "./pipeline-AoW8zq4I-C6Qe0VaZ.mjs";
+import { t as containerEnv } from "./container-transport-DKmKg5JQ-CoY4XPma.mjs";
+import { n as withEmulatorRetry, r as DEV_DIR, t as resolveLocalTargets } from "./local-target-H0IWu_FM.mjs";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { join, relative, resolve, sep } from "node:path";
+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/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);
+}
+//#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();
+/**
+* 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}
+*/
+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;
+	}
+}
+/**
+* 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/execute-dev-BMTFWfFc.mjs
+/**
+* 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(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("  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(generatedDir, input.entryPath);
+	const configImport = relativeImportSpecifier(generatedDir, input.configPath);
+	return `// Generated by \`prisma-composer dev\` — overwritten on every run; do not
+// edit by hand. Independently runnable from ${quote(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(configImport)};
+import app from ${quote(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(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;
+		}
+		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, onError) {
+	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) => {
+		onError?.(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();
+		}
+	};
+}
+/**
+* The dev executor — run-dev.ts's pipeline (local-dev spec § 6) with console
+* and signal handling removed: events out through `onEvent`, lifetime owned by
+* the returned DevSession. The operation NEVER touches process signal
+* handlers — the host does (see run-dev.ts). Reached only by lazy import
+* from dev.ts — this module's static graph transitively loads alchemy's
+* provider tree, so the control entry must never import it statically.
+*/
+function failureMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function mergedEndpoints(attachments) {
+	return (await Promise.all(attachments.map((a) => withEmulatorRetry(() => a.endpoints())))).flat();
+}
+/** Runs the full dev pipeline; resolves to a running session or a structured failure. */
+async function executeDev(input, deps, cwd) {
+	if (process.platform === "win32") return notOk(new CliStructuredError("DEV.PLATFORM_UNSUPPORTED", "local dev is not supported on Windows yet."));
+	const { onEvent } = input;
+	const devDir = path.join(cwd, DEV_DIR);
+	let pipeline;
+	let resolved;
+	const containers = /* @__PURE__ */ new Map();
+	try {
+		const pipelineDeps = {
+			runAssembler: deps.runAssembler,
+			config: deps.config,
+			configPath: deps.configPath
+		};
+		pipeline = await runPipeline(input.entry, input.name, cwd, pipelineDeps);
+		const { config, graph, name } = pipeline;
+		resolved = await resolveLocalTargets(config);
+		for (const [id, dev] of resolved) try {
+			containers.set(id, await dev.container.ensure({
+				appName: name,
+				stage: void 0
+			}));
+		} catch (error) {
+			throw toStructured("DEV.CONTAINER_FAILED", error);
+		}
+		if (input.fresh === true) 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 toStructured("DEV.TEARDOWN_FAILED", 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 toStructured("DEV.PREFLIGHT_FAILED", 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 toStructured("DEV.EMULATOR_FAILED", error);
+			}
+		}
+	} catch (error) {
+		if (CliStructuredError.is(error)) return notOk(error);
+		throw error;
+	}
+	const reproduceCommand = `alchemy deploy ${DEV_STACK_RELATIVE_PATH} --yes --stage dev`;
+	const converge = async () => {
+		let stackPath;
+		try {
+			stackPath = writeDevStackFile({
+				entryPath: pipeline.entryModule.path,
+				cwd,
+				configPath: pipeline.configPath,
+				name: pipeline.name,
+				assembled: pipeline.assembled
+			});
+		} catch (error) {
+			throw toStructured("DEV.STACK_WRITE_FAILED", error);
+		}
+		let outcome;
+		try {
+			outcome = await (deps.alchemy ?? spawnAlchemy)(alchemyInvocation({
+				command: "deploy",
+				stackFileRelativePath: DEV_STACK_RELATIVE_PATH,
+				cwd,
+				stage: "dev",
+				containerEnv: containerEnv(containers)
+			}));
+		} catch (error) {
+			if (CliStructuredError.is(error)) throw error;
+			throw new CliStructuredError("DEV.CONVERGE_FAILED", failureMessage(error), {
+				cause: error,
+				meta: { diagnostics: {
+					exitCode: void 0,
+					stackFilePath: stackPath,
+					reproduceCommand,
+					cwd
+				} }
+			});
+		}
+		return {
+			outcome,
+			stackPath
+		};
+	};
+	let first;
+	try {
+		first = await converge();
+	} catch (error) {
+		if (CliStructuredError.is(error)) return notOk(error);
+		throw error;
+	}
+	const firstStatus = first.outcome.signal !== null ? null : first.outcome.exitCode ?? 1;
+	if (firstStatus !== 0) return notOk(new CliStructuredError("DEV.CONVERGE_FAILED", first.outcome.signal !== null ? `alchemy deploy was interrupted by ${first.outcome.signal}.` : `alchemy deploy exited with status ${String(firstStatus)}.`, { meta: {
+		...first.outcome.signal !== null ? { signal: first.outcome.signal } : { exitCode: firstStatus },
+		diagnostics: {
+			exitCode: firstStatus ?? void 0,
+			...first.outcome.signal !== null ? { signal: first.outcome.signal } : {},
+			stackFilePath: first.stackPath,
+			reproduceCommand,
+			cwd
+		}
+	} }));
+	const emit = (event) => {
+		try {
+			onEvent?.(event);
+		} catch {}
+	};
+	const attachments = [];
+	const started = [];
+	let watch;
+	try {
+		for (const [id, dev] of resolved) try {
+			attachments.push(await dev.attach({
+				container: containers.get(id),
+				devDir
+			}));
+		} catch (error) {
+			throw toStructured("DEV.ATTACH_FAILED", error);
+		}
+		for (const attachment of attachments) {
+			started.push(attachment);
+			try {
+				await withEmulatorRetry(() => attachment.startServices());
+			} catch (error) {
+				throw toStructured("DEV.SERVICE_START_FAILED", error);
+			}
+		}
+		let endpoints;
+		try {
+			endpoints = await mergedEndpoints(attachments);
+		} catch (error) {
+			throw toStructured("DEV.ATTACH_FAILED", error);
+		}
+		emit({
+			kind: "ready",
+			endpoints
+		});
+		const { targets, unwatchable } = watchTargetsFrom(pipeline.assembled.bundles);
+		for (const address of unwatchable) emit({
+			kind: "unwatchable",
+			address
+		});
+		const watchDeps = {
+			runAssembler: deps.runAssembler,
+			config: deps.config,
+			configPath: deps.configPath
+		};
+		watch = startWatch(targets, () => {
+			(async () => {
+				try {
+					const rePipeline = await runPipeline(input.entry, input.name, cwd, watchDeps);
+					const stackPath = writeDevStackFile({
+						entryPath: rePipeline.entryModule.path,
+						cwd,
+						configPath: rePipeline.configPath,
+						name: rePipeline.name,
+						assembled: rePipeline.assembled
+					});
+					const outcome = await (deps.alchemy ?? spawnAlchemy)(alchemyInvocation({
+						command: "deploy",
+						stackFileRelativePath: DEV_STACK_RELATIVE_PATH,
+						cwd,
+						stage: "dev",
+						containerEnv: containerEnv(containers)
+					}));
+					if (outcome.signal !== null || outcome.exitCode !== 0) {
+						emit({
+							kind: "converge-failed",
+							stackFilePath: stackPath,
+							reproduceCommand,
+							cwd
+						});
+						return;
+					}
+					emit({
+						kind: "ready",
+						endpoints: await mergedEndpoints(attachments)
+					});
+				} catch (error) {
+					emit({
+						kind: "rebuild-failed",
+						message: failureMessage(error)
+					});
+				}
+			})();
+		}, (error) => emit({
+			kind: "watch-error",
+			message: failureMessage(error)
+		}));
+		const startedWatch = watch;
+		await watch.ready;
+		let stopping = false;
+		let resolveClosed = () => void 0;
+		const closed = new Promise((resolve) => {
+			resolveClosed = resolve;
+		});
+		const stop = () => {
+			if (!stopping) {
+				stopping = true;
+				emit({ kind: "stopping" });
+				startedWatch.stop();
+				(async () => {
+					for (const attachment of attachments) try {
+						await attachment.stopServices();
+					} catch (error) {
+						emit({
+							kind: "stop-error",
+							message: failureMessage(error)
+						});
+					}
+					emit({ kind: "stopped" });
+					resolveClosed();
+				})();
+			}
+			return closed;
+		};
+		return ok({
+			endpoints,
+			stop,
+			closed
+		});
+	} catch (error) {
+		watch?.stop();
+		await Promise.all(started.map((a) => a.stopServices().catch(() => void 0)));
+		if (CliStructuredError.is(error)) return notOk(error);
+		throw error;
+	}
+}
+//#endregion
+export { executeDev };
+
+//# sourceMappingURL=execute-dev-BMTFWfFc-B1whS-Rr.mjs.map