nomen-lang 0.0.14 → 0.0.16

package/dist/index.mjs

@@ -1,12 +1,1631 @@
 #! /usr/bin/env node
 import { execFileSync, execSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
+import fs, { stat, unwatchFile, watch, watchFile } from "node:fs";
+import * as sp from "node:path";
+import path, { join, resolve, sep } from "node:path";
+import { EventEmitter } from "node:events";
+import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { type } from "node:os";
 import { fileURLToPath } from "node:url";
-//#region node_modules/chokidar/index.mjs
-var chokidar_default = { watch() {
-	throw new Error("chokidar stub: watch mode unavailable");
-} };
+//#region ../node_modules/.pnpm/readdirp@5.1.1/node_modules/readdirp/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: 256
+};
+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;
+};
+var ReaddirpStream = class extends Readable {
+	/**
+	* Directories discovered but not yet emitted from. Listings are read
+	* lazily (on pop, plus one prefetch) instead of eagerly on discovery:
+	* keeping whole listings for every queued dir balloons RAM on wide trees.
+	*/
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
+	_relStart;
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark ?? defaultOptions.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const root = opts.root ?? defaultOptions.root;
+		const type = opts.type ?? defaultOptions.type;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat : stat$1;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = DIR_TYPES.has(type);
+		this._wantsFile = FILE_TYPES.has(type);
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._relStart = this._root.endsWith(sep) ? this._root.length : this._root.length + 1;
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		const rootDir = {
+			path: this._root,
+			depth: 1
+		};
+		rootDir.pending = this._exploreDir(this._root, 1);
+		this.parents = [rootDir];
+		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 = this._isDirent ? slice : await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						let entryType = this._getEntryType(entry);
+						if (typeof entryType !== "string") entryType = await entryType;
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push({
+								path: entry.fullPath,
+								depth: 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;
+					}
+					const dir = parent.pending ?? this._exploreDir(parent.path, parent.depth);
+					const next = this.parents[this.parents.length - 1];
+					if (next && !next.pending) next.pending = this._exploreDir(next.path, next.depth);
+					this.parent = await dir;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path, depth) {
+		let files;
+		try {
+			files = await readdir(path, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path
+		};
+	}
+	_formatEntry(dirent, path) {
+		const basename = this._isDirent ? dirent.name : dirent;
+		const fullPath = join(path, basename);
+		const entry = {
+			path: fullPath.slice(this._relStart),
+			fullPath,
+			basename
+		};
+		if (this._isDirent) {
+			entry.dirent = dirent;
+			return entry;
+		}
+		return this._stat(fullPath).then((stats) => {
+			entry.stats = stats;
+			return entry;
+		}, (err) => {
+			this._onError(err);
+		});
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	_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.isSymbolicLink()) return this._getSymlinkEntryType(entry);
+		return "";
+	}
+	async _getSymlinkEntryType(entry) {
+		const full = entry.fullPath;
+		try {
+			const entryRealPath = await realpath(full);
+			const entryRealPathStats = await lstat(entryRealPath);
+			if (entryRealPathStats.isFile()) return "file";
+			if (entryRealPathStats.isDirectory()) {
+				const len = entryRealPath.length;
+				if (full.startsWith(entryRealPath) && full[len] === sep) {
+					const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+					recursiveError.code = RECURSIVE_ERROR_CODE;
+					this._onError(recursiveError);
+					return "";
+				}
+				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 (!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(", ")}`);
+	const opts = {
+		...options,
+		root
+	};
+	if (type) opts.type = type;
+	return new ReaddirpStream(opts);
+}
+//#endregion
+//#region ../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/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(sp.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(sp.resolve(path, evPath), KEY_LISTENERS, sp.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 {
+	fsw;
+	_boundHandleError;
+	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 = sp.dirname(path);
+		const basename = sp.basename(path);
+		this.fsw._getWatchedDir(directory).add(basename);
+		const absolutePath = sp.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 = sp.dirname(file);
+		const basename = sp.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 = sp.join(directory, "");
+		const throttleKey = target ? `${directory}:${target}` : directory;
+		throttler = this.fsw._throttle("readdir", throttleKey, 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 = sp.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 = sp.join(dir, sp.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(sp.dirname(dir));
+		const tracked = parentDir.has(sp.basename(dir));
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
+		parentDir.add(sp.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 = sp.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 = sp.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(sp.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 ../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/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 = /\/\//g;
+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 = sp.relative(matcher.path, string);
+			if (!relative) return false;
+			return !relative.startsWith("..") && !sp.isAbsolute(relative);
+		}
+		return false;
+	};
+	return () => false;
+}
+function normalizePath(path) {
+	if (typeof path !== "string") throw new Error("string expected");
+	path = sp.normalize(path);
+	path = path.replace(/\\/g, "/");
+	let prepend = false;
+	if (path.startsWith("//")) prepend = true;
+	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;
+	str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	if (prepend) str = SLASH + str;
+	return str;
+};
+const normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));
+const normalizeIgnored = (cwd = "") => (path) => {
+	if (typeof path === "string") return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));
+	else return path;
+};
+const getAbsolutePath = (path, cwd) => {
+	if (sp.isAbsolute(path)) return path;
+	return sp.join(cwd, path);
+};
+const EMPTY_SET$1 = Object.freeze(/* @__PURE__ */ new Set());
+/**
+* Directory entry.
+*/
+var DirEntry = class {
+	path;
+	_removeWatcher;
+	items;
+	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(sp.dirname(dir), sp.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$1;
+		Object.freeze(this);
+	}
+};
+const STAT_METHOD_F = "stat";
+const STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+	fsw;
+	path;
+	watchPath;
+	fullWatchPath;
+	dirParts;
+	followSymlinks;
+	statMethod;
+	constructor(path, follow, fsw) {
+		this.fsw = fsw;
+		const watchPath = path;
+		this.path = path = path.replace(REPLACER_RE, "");
+		this.watchPath = watchPath;
+		this.fullWatchPath = sp.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 sp.join(this.watchPath, sp.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 {
+	closed;
+	options;
+	_closers;
+	_ignoredPaths;
+	_throttled;
+	_streams;
+	_symlinkPaths;
+	_watched;
+	_pendingWrites;
+	_pendingUnlinks;
+	_readyCount;
+	_emitReady;
+	_closePromise;
+	_userIgnored;
+	_readyEmitted;
+	_emitRaw;
+	_boundRemove;
+	_nodeFsHandler;
+	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(sp.dirname(item), sp.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 (!sp.isAbsolute(path) && !this._closers.has(path)) {
+				if (cwd) path = sp.join(cwd, path);
+				path = sp.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 ? sp.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 = sp.normalize(path);
+		if (opts.cwd) path = sp.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 ? sp.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 && !sp.isAbsolute(path)) fullPath = sp.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 = sp.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 = sp.join(directory, item);
+		const fullPath = sp.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 = sp.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 = sp.dirname(path);
+		this._getWatchedDir(dir).remove(sp.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 chokidar_default = {
+	watch: watch$1,
+	FSWatcher
+};
 //#endregion
 //#region ../src/nodes/BaseNode.ts
 /**
@@ -2519,37 +4138,46 @@ var SwitchNode = class extends BaseNode {
 };
 //#endregion
 //#region ../src/build_aarch64/utils/scan_force_heap_strings.ts
-function scan_force_heap_strings(statements) {
+function scan_force_heap_strings(statements, structs) {
 	const result = /* @__PURE__ */ new Set();
-	walk$1(statements, result);
+	walk$1(statements, result, structs);
 	return result;
 }
-function walk$1(statements, result) {
+function walk$1(statements, result, structs) {
 	if (!statements) return;
-	for (const stmt of statements) visit(stmt, result);
+	for (const stmt of statements) visit(stmt, result, structs);
 }
-function visit(node, result) {
+function visit(node, result, structs) {
 	if (!node) return;
 	switch (node.node_type) {
 		case "assign": {
 			const a = node;
 			if (a.left_value.node_type === "value" && is_fresh_heap_string(a.right_value)) result.add(a.left_value.value);
+			visit(a.right_value, result, structs);
+			break;
+		}
+		case "access": {
+			const n = node;
+			if (n.access.node_type === "access_func" && n.target.node_type === "value") {
+				const target = n.target;
+				if (target.type?.name === "string" && structs?.find((s) => s.name === "string")?.functions.find((f) => f.name === n.access.name)?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref))) result.add(target.value);
+			}
 			break;
 		}
 		case "while":
 		case "for":
-			walk$1(node.statements, result);
+			walk$1(node.statements, result, structs);
 			break;
 		case "if": {
 			const n = node;
-			walk$1(n.if_branch?.statements, result);
-			walk$1(n.else_branch?.statements, result);
+			walk$1(n.if_branch?.statements, result, structs);
+			walk$1(n.else_branch?.statements, result, structs);
 			break;
 		}
 		case "switch": {
 			const n = node;
-			for (const c of n.cases) walk$1(c.branch?.statements, result);
-			walk$1(n.else_branch?.statements, result);
+			for (const c of n.cases) walk$1(c.branch?.statements, result, structs);
+			walk$1(n.else_branch?.statements, result, structs);
 			break;
 		}
 	}
@@ -2891,7 +4519,7 @@ function build_function_node$1(node, status) {
 		pidx++;
 	}
 	const old_force_heap = status.force_heap_strings;
-	status.force_heap_strings = scan_force_heap_strings(node.statements);
+	status.force_heap_strings = scan_force_heap_strings(node.statements, status.structs);
 	status.buffer_data_cache = void 0;
 	build_block_node$1(node, status);
 	status.force_heap_strings = old_force_heap;
@@ -3672,8 +5300,10 @@ function build_assignment_node$1(node, status) {
 				emit_compound_op(node.operator, status);
 				status.code += `${ref_store_op} ${ref_store_reg}, [x2]\n`;
 			} else {
+				status.last_result_is_heap = false;
 				build_node$1(node.right_value, status);
 				if (!status.code.endsWith("\n")) status.code += "\n";
+				if (ref_type_name === "string" && !status.last_result_is_heap) emit_strdup(status);
 				load_ref_param_pointer("x2", name, status);
 				status.code += `${ref_store_op} ${ref_store_reg}, [x2]\n`;
 			}
@@ -5753,7 +7383,16 @@ function build_declaration_node$1(node, status) {
 		if (node.value.node_type === "op" && node.value.type?.name === "string") {
 			const op = node.value;
 			const str_result = resolve_string_op(op, status);
-			if (str_result !== null) {
+			if (str_result !== null && status.force_heap_strings?.has(node.name)) {
+				const offset = allocate_stack_space(status, 8);
+				status.stack_offsets.set(node.name, offset);
+				const label = `_str_fold_${decl_const_counter++}`;
+				emit_data(status, `${label}: .asciz ${escape_asciz(str_result)}\n.p2align 2\n`);
+				status.code += `adr x0, ${label}\n`;
+				emit_strdup(status);
+				status.code += `str x0, [x29, #${offset}]\n`;
+				mark_heap_string(status, node.name);
+			} else if (str_result !== null) {
 				if (status.function_return_label) emit_data(status, `${node.name}: .asciz ${escape_asciz(str_result)}\n.p2align 2\n`);
 				else status.code += `${node.name}: .asciz ${escape_asciz(str_result)}\n.p2align 2\n`;
 				status.string_literal_names.add(node.name);
@@ -5775,7 +7414,7 @@ function build_declaration_node$1(node, status) {
 			const value_node = node.value;
 			const raw = get_raw_value$1(value_node);
 			const is_literal = /^(\+|-)?\d+(\.\d+)?$/.test(raw) || raw.startsWith("\"") || raw === "true" || raw === "false";
-			if (status.function_return_label && (node.declaration === "var" || !is_literal)) {
+			if (!!status.function_return_label) {
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(node.name, offset);
 				if (node.type.name === "string" && !is_literal && status.heap_strings?.has(raw)) {
@@ -8127,6 +9766,155 @@ function build_value_node$1(node, status) {
 	}
 }
 //#endregion
+//#region ../src/build_common/scan_string_length_hoists.ts
+const NON_IDENTIFIERS = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null",
+	"self",
+	"as",
+	"default"
+]);
+function is_identifier(value) {
+	return !!value && !NON_IDENTIFIERS.has(value) && !/^(\+|-)?\d+(\.\d+)?$/.test(value) && !value.startsWith("\"") && !value.startsWith("'");
+}
+function root_name(node) {
+	if (!node) return void 0;
+	if (node.node_type === "value") return node.value;
+	if (node.node_type === "access") return root_name(node.target);
+}
+/**
+* Find the bare `string` variables whose `.length` is read inside a while
+* loop (condition, body, or update clause) and that the loop never
+* rebinds — the set of variables for which a single hoisted `strlen` before
+* the loop is equivalent to the per-evaluation `strlen` the backends
+* otherwise emit. Returns variable name → the `.length` target node.
+*
+* A variable is rejected when the loop subtree contains any of:
+* - an assignment whose left-hand root name is the variable (rebinds it)
+* - a declaration/parameter/for-item with the same name (shadows it)
+* - a call passing it `ref`/`mov`/`swap` (callee may rebind or drain it)
+* - a mutating (`ref self`) string method dispatched on it (e.g. `set`,
+*   which can change the effective strlen in place)
+* - any reference inside a nested `func`/`async_block` boundary (those
+*   bodies are emitted outside the loop's scope, where the hoisted temp
+*   or slot is not visible)
+* - any `raw` block anywhere (its code is opaque and may rebind anything)
+* Nullable strings are also rejected: hoisting would evaluate `strlen`
+* before the first condition check, moving a null dereference that today
+* only happens if the condition is actually reached.
+*/
+function scan_string_length_hoists(condition, statements, update, status) {
+	const candidates = /* @__PURE__ */ new Map();
+	const invalidated = /* @__PURE__ */ new Set();
+	const boundary_refs = /* @__PURE__ */ new Set();
+	let has_raw = false;
+	const is_string_target = (target) => {
+		const t = target.type;
+		if (t?.is_view || t?.is_nullable) return false;
+		if (t?.name) return t.name === "string";
+		const vt = status.variable_types?.get(target.value);
+		if (vt) return vt.name === "string" && !vt.is_view && !vt.is_nullable;
+		const decl = status.scoped_declarations?.findLast((d) => d.name === target.value);
+		if (!decl?.type) return false;
+		return decl.type.name === "string" && !decl.type.is_view && !decl.type.is_nullable;
+	};
+	const is_mutating_string_call = (call) => {
+		const method = (status.structs?.find((s) => s.name === "string"))?.functions?.find((f) => f.name === call.name || f.name === `#${call.name}`);
+		if (!method) return false;
+		const self_param = method.params?.[0];
+		return !!self_param?.is_self_param && self_param.declaration === "var";
+	};
+	const walk_children = (n, in_boundary) => {
+		const record = n;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "scope" || key === "node_type") continue;
+			walk(record[key], in_boundary);
+		}
+	};
+	const walk = (value, in_boundary) => {
+		if (!value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			for (const item of value) walk(item, in_boundary);
+			return;
+		}
+		const n = value;
+		if (typeof n.node_type !== "string") return;
+		switch (n.node_type) {
+			case "raw":
+				has_raw = true;
+				return;
+			case "func":
+			case "async_block":
+				walk_children(n, true);
+				return;
+			case "value": {
+				const v = n.value;
+				if (in_boundary && is_identifier(v)) boundary_refs.add(v);
+				return;
+			}
+			case "access": {
+				const access = n;
+				if (!in_boundary && access.access.node_type === "access_field" && access.access.name === "length" && access.target.node_type === "value") {
+					const target = access.target;
+					if (is_identifier(target.value) && is_string_target(target)) candidates.set(target.value, target);
+				}
+				if (!in_boundary && access.access.node_type === "access_func" && access.target.node_type === "value") {
+					const target = access.target;
+					if (is_string_target(target) && is_mutating_string_call(access.access)) invalidated.add(target.value);
+				}
+				walk_children(n, in_boundary);
+				return;
+			}
+			case "assign": {
+				const assign = n;
+				const lhs = root_name(assign.left_value);
+				if (lhs) invalidated.add(lhs);
+				const swap = root_name(assign.swap);
+				if (swap) invalidated.add(swap);
+				walk_children(n, in_boundary);
+				return;
+			}
+			case "declare":
+			case "param": {
+				const name = n.name;
+				if (name) invalidated.add(name);
+				walk_children(n, in_boundary);
+				return;
+			}
+			case "for": {
+				const item = n.item;
+				if (item?.value) invalidated.add(item.value);
+				walk_children(n, in_boundary);
+				return;
+			}
+			case "func_call":
+			case "access_func": {
+				const call = n;
+				for (const indices of [call.ref_param_indices, call.mov_param_indices]) for (const i of indices ?? []) {
+					const arg = root_name(call.params?.[i]);
+					if (arg) invalidated.add(arg);
+				}
+				if (call.swap_params) {
+					for (const [i, swap] of call.swap_params) for (const arg of [root_name(call.params?.[i]), root_name(swap)]) if (arg) invalidated.add(arg);
+				}
+				walk_children(n, in_boundary);
+				return;
+			}
+			default:
+				walk_children(n, in_boundary);
+				return;
+		}
+	};
+	walk(condition, false);
+	walk(statements, false);
+	if (update) walk(update, false);
+	for (const name of invalidated) candidates.delete(name);
+	for (const name of boundary_refs) candidates.delete(name);
+	if (has_raw) candidates.clear();
+	return candidates;
+}
+//#endregion
 //#region ../src/build_aarch64/build_while_loop_node.ts
 const CALLEE_SAVED_REGS = [
 	"x23",
@@ -8279,6 +10067,20 @@ function build_while_loop_node$1(node, status) {
 			for (const p of promoted) status.callee_saved_regs_used.add(p.reg);
 		}
 	}
+	const old_length_slots = status.string_length_slots;
+	const hoists = scan_string_length_hoists(node.condition, node.statements, node.update, status);
+	if (hoists.size) {
+		if (!status.string_length_slots) status.string_length_slots = /* @__PURE__ */ new Map();
+		for (const [name, target] of hoists) {
+			if (status.string_length_slots.has(name)) continue;
+			const offset = allocate_stack_space(status, 8);
+			status.string_length_slots.set(name, offset);
+			build_node$1(target, status);
+			if (!status.code.endsWith("\n")) status.code += "\n";
+			status.code += `bl _strlen\n`;
+			status.code += `str x0, [x29, #${offset}]\n`;
+		}
+	}
 	status.code += `${start_label}:\n`;
 	if (!(node.condition.node_type === "value" && node.condition.value === "true")) {
 		build_node$1(node.condition, status);
@@ -8298,6 +10100,7 @@ function build_while_loop_node$1(node, status) {
 	if (saved_reg_allocs) status.register_allocations = saved_reg_allocs;
 	else status.register_allocations = void 0;
 	status.buffer_data_cache = saved_buffer_cache;
+	status.string_length_slots = old_length_slots;
 	status.loop_labels.pop();
 	exit_scope_frame(status, old_scoped_declarations);
 }
@@ -9362,10 +11165,12 @@ function build_struct_functions$1(node, status) {
 		status.code += `stp x29, x30, [sp, #-16]!\n`;
 		const is_self_param = func.params[0]?.is_self_param;
 		const self_is_var = is_self_param && func.params[0]?.declaration === "var";
-		const needs_x19 = is_self_param && !self_is_var;
+		const self_is_ref = is_self_param && !!(func.params[0].is_ref || func.params[0].type?.is_ref);
+		const needs_x19 = is_self_param && (!self_is_var || self_is_ref && node.is_simple_type);
+		const x19_through_ref = needs_x19 && self_is_var;
 		if (needs_x19) {
 			status.code += `str x19, [sp, #-16]!\n`;
-			status.code += `mov x19, x0\n`;
+			status.code += x19_through_ref ? `ldr x19, [x0]\n` : `mov x19, x0\n`;
 		}
 		const param_regs = [
 			"x0",
@@ -9399,7 +11204,7 @@ function build_struct_functions$1(node, status) {
 			status.function_return_type = func.return_type;
 			status.struct_return_buffer = "x8";
 		}
-		if (needs_x19) status.function_param_regs.set("self", "x19");
+		if (needs_x19 && !self_is_var) status.function_param_regs.set("self", "x19");
 		let slot_idx = 0;
 		for (let i = 0; i < func.params.length; i++) {
 			const param = func.params[i];
@@ -9455,7 +11260,7 @@ function build_struct_functions$1(node, status) {
 				const offset = allocate_stack_space(status, size, size);
 				status.stack_offsets.set(param.name, offset);
 				if (param.is_self_param) {
-					const save_reg = needs_x19 ? "x19" : param_regs[second_slot_idx];
+					const save_reg = x19_through_ref ? "x0" : needs_x19 ? "x19" : param_regs[second_slot_idx];
 					status.code += `str ${save_reg}, [x29, #${offset}]\n`;
 				} else if (second_slot_idx < 8) {
 					const reg = param_regs[second_slot_idx];
@@ -9506,7 +11311,7 @@ function build_struct_functions$1(node, status) {
 				});
 			}
 		}
-		status.force_heap_strings = scan_force_heap_strings(func.statements);
+		status.force_heap_strings = scan_force_heap_strings(func.statements, status.structs);
 		status.buffer_data_cache = void 0;
 		const moved_before = new Set(status.moved ?? []);
 		if (!emit_owning_buffer_standalone_aarch64(node, func.name, status)) build_block_node$1(func, status);
@@ -10346,6 +12151,14 @@ function load_nursery_struct_address(target, status) {
 //#endregion
 //#region ../src/build_aarch64/build_access_node.ts
 function emit_string_length$1(target, status) {
+	if (target.node_type === "value") {
+		const slot = status.string_length_slots?.get(target.value);
+		if (slot !== void 0) {
+			status.last_result_is_heap = false;
+			status.code += `ldr x0, [x29, #${slot}]\n`;
+			return;
+		}
+	}
 	status.last_result_is_heap = false;
 	build_node$1(target, status);
 	if (!status.code.endsWith("\n")) status.code += "\n";
@@ -11176,6 +12989,7 @@ function build_access_method(node, access_func, status) {
 		if (specialized) mono_struct_name = specialized.name;
 	}
 	const method_name = access_func.mangled_name || `${mono_struct_name}_${access_func.name.replace(/#/g, "")}`;
+	const method_self_is_ref = !!status.structs.find((s) => s.name === mono_struct_name && !s.is_generic)?.functions.find((f) => f.name === access_func.name)?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
 	const return_struct = !access_func.type.is_view && !access_func.type.is_array && !!status.structs.find((s) => s.name === access_func.type.name && !s.is_simple_type && !s.is_class);
 	let temp_addr = "";
 	let temp_offset = 0;
@@ -11204,7 +13018,7 @@ function build_access_method(node, access_func, status) {
 					status.code += `ldr x0, [x0]\n`;
 					status.code += `add x0, x0, #8\n`;
 				} else if (target_type.is_array && (status.function_array_params?.has(name) || status.function_variadic_params?.has(name)) && !is_local_ref_var(name, status)) status.code += `ldr x0, [x0]\n`;
-				else if (target_is_simple && !target_type.is_array && (target_type.name !== "string" || has_stack_offset) && !is_local_ref_var(name, status)) {
+				else if (target_is_simple && !target_type.is_array && (target_type.name !== "string" || has_stack_offset) && !is_local_ref_var(name, status) && !method_self_is_ref) {
 					const size = aarch64_size(target_type.name);
 					const signed = target_type.name.startsWith("int") || target_type.name === "float" || target_type.name === "float32" || target_type.name === "float64";
 					if (size === 1) status.code += signed ? `ldrsb x0, [x0]\n` : `ldrb w0, [x0]\n`;
@@ -12110,13 +13924,7 @@ function build_spawn_node(node, status) {
 	if (!status.headers.includes("__nomen_pool_submit")) status.headers += POOL_HEADER;
 	const struct_name = `__nomen_spawn_${id}_args`;
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
-	const arg_c_types = [];
-	for (let i = 0; i < call.params.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(call.params[i]));
-		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
-		const is_trait = !!status.traits.find((t) => t.name === mono_name);
-		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
-	}
+	const arg_c_types = spawn_arg_c_types(call, status);
 	const return_type_name = node.function_return_type?.name;
 	const returns_value = !!(return_type_name && return_type_name !== "void" && return_type_name !== "?");
 	const is_class_ret = returns_value && !!status.structs.find((s) => s.name === return_type_name && s.is_class);
@@ -12189,6 +13997,98 @@ function build_spawn_node(node, status) {
 	}
 	status.code += `})\n`;
 }
+const C_BUILTIN_TYPES = /* @__PURE__ */ new Set([
+	"bool",
+	"int",
+	"uint",
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64",
+	"float",
+	"ufloat",
+	"float32",
+	"ufloat32",
+	"float64",
+	"ufloat64",
+	"char",
+	"string",
+	"func",
+	"void",
+	"null"
+]);
+/**
+* Resolve each spawn argument's C type. Classes/traits are pointers;
+* primitives and by-value structs use c_type's output directly. Generic
+* instantiations (e.g. Channel<uint64>) use the monomorphized C name
+* (`Channel_uint64`). The type comes from the CALLEE's declared parameter
+* whenever it can be resolved — an argument's own node type can differ
+* (e.g. an int literal `41` passed for a `uint64` param lowers to `long`,
+* conflicting with the emitted `unsigned long long` prototype). Falls back
+* to the argument's type when the callee (or its param type) can't be
+* resolved at build time.
+*/
+function spawn_arg_c_types(call, status) {
+	const arg_c_types = [];
+	const callee_params = find_spawn_callee(call.name, status)?.params?.filter((p) => !p.is_self_param) ?? [];
+	for (let i = 0; i < call.params.length; i++) {
+		const mono_name = mono_type_name(callee_params[i]?.type && is_resolvable_c_type(callee_params[i].type, status) ? callee_params[i].type : type_from_value_node$1(call.params[i]));
+		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
+		const is_trait = !!status.traits.find((t) => t.name === mono_name);
+		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
+	}
+	return arg_c_types;
+}
+/** Whether a Nomen type name lowers to a real C type in this build: a
+*  builtin primitive or a struct/enum the backend knows (post-monomorphization).
+*  Unresolved generic type params (`T`) fail this check. */
+function is_resolvable_c_type(type, status) {
+	if (C_BUILTIN_TYPES.has(type.name)) return true;
+	return !!status.structs.find((s) => s.name === type.name);
+}
+/**
+* Find the spawned function's definition — a top-level function, a function
+* nested in a block (parse wrappers hoist user code into `main`), or a
+* struct/trait method (matched by its mangled `Struct_method` name) — so the
+* trampoline's forward declaration can copy the callee's DECLARED parameter
+* types. Monomorphized clones are also reachable this way (they are appended
+* to the AST). A same-named pair would already collide at C level, so the
+* first match is as good as any.
+*/
+function find_spawn_callee(name, status) {
+	let found;
+	const visit = (node) => {
+		if (found || !node || typeof node !== "object") return;
+		if (node.node_type === "func") {
+			if (node.name === name) {
+				found = node;
+				return;
+			}
+		} else if (node.node_type === "struct" || node.node_type === "trait") {
+			const functions = node.functions ?? [];
+			for (const func of functions) {
+				const owner = node.name;
+				if (func.name === name || `${owner}_${func.name}` === name) {
+					found = func;
+					return;
+				}
+			}
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const v = node[key];
+			if (Array.isArray(v)) for (const item of v) visit(item);
+			else if (v && typeof v === "object" && "node_type" in v) visit(v);
+			if (found) return;
+		}
+	};
+	visit(status.root);
+	return found;
+}
 //#endregion
 //#region ../src/build_c/build_nursery_spawn.ts
 /**
@@ -12214,13 +14114,7 @@ function build_nursery_spawn(node, nursery_ptr, status) {
 	if (!status.headers.includes("__nomen_pool_submit")) status.headers += POOL_HEADER;
 	const struct_name = `__nomen_spawn_${id}_args`;
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
-	const arg_c_types = [];
-	for (let i = 0; i < args.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(args[i]));
-		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
-		const is_trait = !!status.traits.find((t) => t.name === mono_name);
-		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
-	}
+	const arg_c_types = spawn_arg_c_types(call, status);
 	const return_type_name = node.function_return_type?.name;
 	const returns_value = !!(return_type_name && return_type_name !== "void" && return_type_name !== "?");
 	const is_class_ret = returns_value && !!status.structs.find((s) => s.name === return_type_name && s.is_class);
@@ -12661,11 +14555,13 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 				status.code += "\n// Auto-free\n";
 				commented = true;
 			}
-			status.code += `free(${key});\n`;
+			const dot = key.indexOf(".");
+			status.code += `free(${c_function_name(key.substring(0, dot))}${key.substring(dot)});\n`;
 			if (!persist_string_field_records) status.heap_string_fields.delete(key);
 		}
 	}
 	for (const dec of decls) {
+		const cname = c_function_name(dec.name);
 		const struct = status.structs.find((s) => s.name === dec.type.name);
 		if (struct && struct.traits.includes("Disposable")) {
 			const trait = status.traits.find((t) => t.name === "Disposable");
@@ -12678,7 +14574,7 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 				const cast = "(void *(*)(void *))";
 				const traitIndex = status.traits.indexOf(trait);
 				const funcIndex = trait.functions.indexOf(func);
-				status.code += `(${cast}_get_trait_func((void *)&${dec.name}, ${traitIndex}, ${funcIndex}))(&${dec.name});\n`;
+				status.code += `(${cast}_get_trait_func((void *)&${cname}, ${traitIndex}, ${funcIndex}))(&${cname});\n`;
 			}
 		}
 		const is_destructured_field_access = dec.value?.node_type === "access" && dec.value.access.node_type === "access_field" && !dec.value.is_moved;
@@ -12697,15 +14593,15 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 				status.code += "\n// Auto-free\n";
 				commented = true;
 			}
-			if (dec.type.is_nullable) status.code += `if (${dec.name}) { ${trait_class_trait}_destroy(${dec.name}); free(${dec.name}); }\n`;
-			else status.code += `${trait_class_trait}_destroy(${dec.name}); free(${dec.name});\n`;
+			if (dec.type.is_nullable) status.code += `if (${cname}) { ${trait_class_trait}_destroy(${cname}); free(${cname}); }\n`;
+			else status.code += `${trait_class_trait}_destroy(${cname}); free(${cname});\n`;
 		}
 		if (!is_destructured_field_access && !is_borrowed_string && (!dec.type.is_static || value_is_heap_string || was_strdup_string_var || is_normalized_join_string) && dec.type.name === "string" && !dec.type.is_array) {
 			if (!commented) {
 				status.code += "\n// Auto-free\n";
 				commented = true;
 			}
-			status.code += `free(${dec.name});\n`;
+			status.code += `free(${cname});\n`;
 		}
 		if (!is_destructured_field_access && is_class_var && !dec.type.is_array) {
 			if (!commented) {
@@ -12716,10 +14612,10 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 			const mono_cls_name = cls ? mono_type_name(dec.type) : void 0;
 			const has_destroy_fn = !!cls?.functions.find((f) => f.name === "#destroy") || !!cls?.is_class;
 			if (cls) {
-				const destroy_call = has_destroy_fn ? `${mono_cls_name}_destroy(${dec.name}); ` : "";
-				if (dec.type.is_nullable) status.code += `if (${dec.name}) { ${destroy_call}free(${dec.name}); }\n`;
-				else status.code += `${destroy_call}free(${dec.name});\n`;
-			} else status.code += `free(${dec.name});\n`;
+				const destroy_call = has_destroy_fn ? `${mono_cls_name}_destroy(${cname}); ` : "";
+				if (dec.type.is_nullable) status.code += `if (${cname}) { ${destroy_call}free(${cname}); }\n`;
+				else status.code += `${destroy_call}free(${cname});\n`;
+			} else status.code += `free(${cname});\n`;
 		}
 		if (!is_destructured_field_access && !is_class_var && !dec.type.is_array && dec.type.name !== "string") {
 			const mono_name = mono_type_name(dec.type);
@@ -12729,7 +14625,7 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 					status.code += "\n// Auto-free\n";
 					commented = true;
 				}
-				emit_struct_destroys(status, struct_type, dec.name);
+				emit_struct_destroys(status, struct_type, cname);
 			}
 		}
 		if (!!status.traits.find((t) => t.name === dec.type.name) && !is_destructured_field_access && !dec.type.is_array && dec.value) {
@@ -12740,7 +14636,7 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 					status.code += "\n// Auto-free\n";
 					commented = true;
 				}
-				emit_struct_destroys(status, concrete, dec.name);
+				emit_struct_destroys(status, concrete, cname);
 			}
 		}
 		if (!is_destructured_field_access && !is_class_var && !dec.type.is_array && is_nullable_struct_type(dec.type, status)) {
@@ -12750,8 +14646,8 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 					status.code += "\n// Auto-free\n";
 					commented = true;
 				}
-				const body = capture_destroys(status, inner, dec.name, ".");
-				status.code += `if (${has_flag_name(dec.name)}) { ${body} }\n`;
+				const body = capture_destroys(status, inner, cname, ".");
+				status.code += `if (${has_flag_name(cname)}) { ${body} }\n`;
 			}
 		}
 		if (!is_destructured_field_access && dec.type.is_array && status.heap_array_vars?.has(dec.name)) {
@@ -12764,17 +14660,17 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 			const elem_is_string = elem_name === "string";
 			const elem_c_type = elem_is_class ? `struct ${elem_name}*` : elem_name;
 			if (elem_is_class) {
-				status.code += `for (long _i = 0; _i < ${dec.name}->length; _i++) {\n`;
-				status.code += `\t${elem_c_type}* _data = (${elem_c_type}*)((char*)${dec.name} + sizeof(struct Array_${elem_name}));\n`;
+				status.code += `for (long _i = 0; _i < ${cname}->length; _i++) {\n`;
+				status.code += `\t${elem_c_type}* _data = (${elem_c_type}*)((char*)${cname} + sizeof(struct Array_${elem_name}));\n`;
 				status.code += `\t${elem_name}_destroy(_data[_i]); free(_data[_i]);\n`;
 				status.code += `}\n`;
 			} else if (elem_is_string) {
-				status.code += `for (long _i = 0; _i < ${dec.name}->length; _i++) {\n`;
-				status.code += `\tchar** _data = (char**)((char*)${dec.name} + sizeof(struct Array_string));\n`;
+				status.code += `for (long _i = 0; _i < ${cname}->length; _i++) {\n`;
+				status.code += `\tchar** _data = (char**)((char*)${cname} + sizeof(struct Array_string));\n`;
 				status.code += `\tfree(_data[_i]);\n`;
 				status.code += `}\n`;
 			}
-			status.code += `free(${dec.name});\n`;
+			status.code += `free(${cname});\n`;
 		}
 		if (!is_destructured_field_access && dec.type.is_array && status.stack_array_vars?.has(dec.name)) {
 			if (!commented) {
@@ -12787,13 +14683,13 @@ function free_scoped_declarations(status, decls, persist_string_field_records =
 			const elem_is_string = elem_name === "string";
 			const elem_struct_type = status.structs.find((s) => s.name === elem_name && !s.is_simple_type && !s.is_generic);
 			const arr_len = status.stack_array_lengths?.get(dec.name) ?? "0";
-			if (elem_is_string) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${dec.name}[_i]); }\n`;
+			if (elem_is_string) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${cname}[_i]); }\n`;
 			else if (elem_is_class) {
-				if (has_destroy(elem_struct)) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { if (${dec.name}[_i]) { ${elem_name}_destroy(${dec.name}[_i]); free(${dec.name}[_i]); } }\n`;
-				else status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${dec.name}[_i]); }\n`;
+				if (has_destroy(elem_struct)) status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { if (${cname}[_i]) { ${elem_name}_destroy(${cname}[_i]); free(${cname}[_i]); } }\n`;
+				else status.code += `for (long _i = 0; _i < ${arr_len}; _i++) { free(${cname}[_i]); }\n`;
 			} else if (elem_struct_type && struct_needs_destroy(elem_struct_type, status)) {
 				status.code += `for (long _i = 0; _i < ${arr_len}; _i++) {\n`;
-				emit_struct_destroys(status, elem_struct_type, `${dec.name}[_i]`);
+				emit_struct_destroys(status, elem_struct_type, `${cname}[_i]`);
 				status.code += `}\n`;
 			}
 		}
@@ -13331,7 +15227,8 @@ function build_access_node(node, status) {
 				const label = access_func.mangled_name || trait_default_label || `${mono_struct_name}_${access_func.name.replace(/#/g, "")}`;
 				status.code += `${label}(`;
 				if (!access_func.is_static) {
-					if (!built_in_types.includes(method_type?.name || "")) {
+					const method_self_is_ref = !!target_method?.params?.some((p) => p.is_self_param && (p.is_ref || p.type?.is_ref));
+					if (!built_in_types.includes(method_type?.name || "") || method_self_is_ref) {
 						const target_value = node.target.node_type === "value" ? node.target.value : "";
 						const target_is_ref_class_param = !!status.ref_class_params?.has(target_value);
 						if (!(!!status.function_ref_params?.has(target_value) || !!status.class_vars?.has(target_value) || !!status.heap_array_vars?.has(target_value))) status.code += "&";
@@ -13404,6 +15301,13 @@ function resolve_access_field_type(node, status) {
 	return (status.structs.find((s) => s.name === base_type.name && !s.is_simple_type)?.fields.find((f) => f.name === field_name))?.type;
 }
 function emit_string_length(target, status) {
+	if (target.node_type === "value") {
+		const temp = status.string_length_temps?.get(target.value);
+		if (temp) {
+			status.code += temp;
+			return;
+		}
+	}
 	if (is_owned_heap_temp(target, status)) {
 		const id = status.label_counter = (status.label_counter ?? 0) + 1;
 		const tmp = `_slen_${id}`;
@@ -13517,12 +15421,14 @@ function build_assignment_node(node, status) {
 	if (!node.operator && node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field" && node.left_value.access.type?.name === "string" && !node.left_value.access.type?.is_ref && !node.left_value.access.type?.is_array) {
 		const access_lhs = node.left_value;
 		const field_access_node = access_lhs.access;
-		const target_type = type_from_value_node$1(access_lhs.target);
+		let target_type = type_from_value_node$1(access_lhs.target);
+		if (!target_type?.name && access_lhs.target.node_type === "value" && access_lhs.target.value === "self" && status.current_struct) target_type = new Type(status.current_struct.name);
 		const target_struct = target_type?.name ? status.structs.find((s) => s.name === target_type.name && !s.is_simple_type) : null;
 		const target_var = access_lhs.target.node_type === "value" ? access_lhs.target.value : "";
+		const self_target = target_var === "self";
 		const tracked_key = `${target_var}.${field_access_node.name}`;
 		const old_was_heap = !!target_struct?.is_class || !!status.heap_string_fields?.has(tracked_key);
-		if (target_struct && target_var && target_var !== "self") {
+		if (target_struct && target_var && (!self_target || target_struct.is_class)) {
 			const fresh_heap = is_owned_heap_temp(node.right_value, status);
 			const before_len = status.code.length;
 			build_node(node.left_value, status);
@@ -13637,6 +15543,12 @@ function build_assignment_node(node, status) {
 				}
 				status.code += `free(${lhs_name});\n`;
 			}
+			if (lhs_is_string && !node.swap && rhs_is_bare_value && rhs.value.length >= 2 && rhs.value.startsWith("\"") && rhs.value.endsWith("\"")) {
+				status.code += `${lhs_name} = strdup(`;
+				build_node(node.right_value, status);
+				status.code += `);\n`;
+				return;
+			}
 			if (rhs_is_bare_value) {
 				if (lhs_is_class) {
 					if (!node.swap) splice_decl_from_c_scopes(status, rhs.value);
@@ -13685,6 +15597,20 @@ function build_assignment_node(node, status) {
 		}
 		return;
 	}
+	if (!node.operator && !node.swap && node.left_value.node_type === "value") {
+		const lhs_name = node.left_value.value;
+		const lhs_type = type_from_value_node$1(node.left_value);
+		if (lhs_type?.name === "string" && !lhs_type.is_array && !!status.function_ref_params?.has(lhs_name) && !status.ref_class_params?.has(lhs_name)) {
+			const fresh_heap = is_owned_heap_temp(node.right_value, status);
+			build_node(node.left_value, status);
+			status.code += ` = `;
+			if (!fresh_heap) status.code += `strdup(`;
+			build_node(node.right_value, status);
+			if (!fresh_heap) status.code += `)`;
+			status.code += `;\n`;
+			return;
+		}
+	}
 	if (!node.operator && node.left_value.node_type === "value" && status.ref_local_vars?.has(node.left_value.value)) {
 		const lhs_name = node.left_value.value;
 		status.code += `${lhs_name} = &`;
@@ -15808,6 +17734,52 @@ function emit_nullable_arg_flag(arg, status) {
 	status.code += `1`;
 }
 //#endregion
+//#region ../src/build_c/utils/build_condition.ts
+/**
+* Build a controlling expression (an if/while/for condition or a switch-case
+* comparison) and emit it without redundant fully-wrapping outer parentheses.
+* The codegen wraps every binary operation in parens (build_default_binary),
+* so emitting the condition verbatim would read `if ((a == b))`, which clang
+* flags as -Wparentheses-equality ("equality comparison with extraneous
+* parentheses").
+*/
+function build_condition(node, status) {
+	const before = status.code.length;
+	build_node(node, status);
+	status.code = status.code.substring(0, before) + strip_outer_parens(status.code.substring(before));
+}
+/**
+* Strip outer paren layers that wrap the ENTIRE expression (the opening paren
+* matches only the final character). A layer is removed only when the inner
+* text does not start with `{` — a GCC/clang statement-expression
+* `({ ... })` must keep its wrapper to stay a valid expression. Parens
+* inside string/char literals can only make the scan conservative (they
+* unbalance the depth count, so nothing is stripped), never incorrect.
+*/
+function strip_outer_parens(expr) {
+	let code = expr.trim();
+	while (code.length > 1 && code.startsWith("(") && code.endsWith(")")) {
+		let depth = 0;
+		let wraps_whole = true;
+		for (let i = 0; i < code.length; i++) {
+			const ch = code[i];
+			if (ch === "(") depth++;
+			else if (ch === ")") {
+				depth--;
+				if (depth === 0 && i < code.length - 1) {
+					wraps_whole = false;
+					break;
+				}
+			}
+		}
+		if (!wraps_whole || depth !== 0) break;
+		const inner = code.slice(1, -1).trim();
+		if (inner.startsWith("{")) break;
+		code = inner;
+	}
+	return code;
+}
+//#endregion
 //#region ../src/build_c/build_if_else_node.ts
 function build_if_else_node(node, status) {
 	const old_scoped_declarations = status.scoped_declarations;
@@ -15816,7 +17788,7 @@ function build_if_else_node(node, status) {
 	status.deferred_frees = [];
 	emit_allocations(node.condition, status);
 	status.code += `if (`;
-	build_node(node.condition, status);
+	build_condition(node.condition, status);
 	status.code += `) {\n`;
 	if (node.if_branch) {
 		build_block_node(node.if_branch, status);
@@ -16229,6 +18201,7 @@ function build_switch_node(node, status) {
 		}
 		cond_code = cond_code.trim();
 		while (cond_code.startsWith("(") && !cond_code.endsWith(")")) cond_code = cond_code.substring(1).trim();
+		cond_code = strip_outer_parens(cond_code);
 		if (decls.length > 0) status.code += decls.join("\n") + "\n";
 		const prefix = status.code.endsWith("} else ") ? "" : "";
 		status.code += `${prefix}if (${cond_code}) {\n`;
@@ -16302,16 +18275,29 @@ function build_while_loop_node(node, status) {
 	const old_deferred_frees = status.deferred_frees;
 	status.deferred_frees = [];
 	push_c_loop_frame(status);
+	const old_length_temps = status.string_length_temps;
+	const hoists = scan_string_length_hoists(node.condition, node.statements, node.update, status);
+	if (hoists.size) {
+		if (!status.string_length_temps) status.string_length_temps = /* @__PURE__ */ new Map();
+		for (const [name, target] of hoists) {
+			if (status.string_length_temps.has(name)) continue;
+			const temp = `_slh_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+			status.string_length_temps.set(name, temp);
+			status.code += `const long ${temp} = (long)strlen(`;
+			build_node(target, status);
+			status.code += `);\n`;
+		}
+	}
 	emit_allocations(node.condition, status);
 	if (node.update) {
 		status.code += `for (; `;
-		build_node(node.condition, status);
+		build_condition(node.condition, status);
 		status.code += `; `;
 		build_node(node.update, status);
 		status.code += `) {\n`;
 	} else {
 		status.code += `while (`;
-		build_node(node.condition, status);
+		build_condition(node.condition, status);
 		status.code += `) {\n`;
 	}
 	build_block_node(node, status);
@@ -16321,6 +18307,7 @@ function build_while_loop_node(node, status) {
 	leave_c_scope(status);
 	status.scoped_declarations = old_scoped_declarations;
 	status.deferred_frees = old_deferred_frees;
+	status.string_length_temps = old_length_temps;
 }
 //#endregion
 //#region ../src/build_c/build_node.ts
@@ -16897,7 +18884,7 @@ const PREFIX_POSITIONS = /* @__PURE__ */ new Set([
 	"!"
 ]);
 /** Render a line's pieces with normalized spacing. */
-function join$1(pieces) {
+function join$2(pieces) {
 	let out = "";
 	for (let i = 0; i < pieces.length; i++) {
 		if (i > 0 && needs_space(pieces, i)) out += " ";
@@ -17529,19 +19516,19 @@ function is_continuation(previous, pieces) {
 }
 /** Emit a line, breaking its bracketed list up if it is over the print width. */
 function wrap(pieces, level, options) {
-	const text = join$1(pieces);
+	const text = join$2(pieces);
 	if (level * options.tab_width + text.length <= options.print_width) return [indent(level, options) + text];
 	const group = find_group(pieces);
 	if (!group) return [indent(level, options) + text];
 	const items = split_items(pieces.slice(group.open + 1, group.close));
 	if (items.length < 2) return [indent(level, options) + text];
 	const trailing = options.trailing_comma && group.is_list;
-	const out = [indent(level, options) + join$1(pieces.slice(0, group.open + 1))];
+	const out = [indent(level, options) + join$2(pieces.slice(0, group.open + 1))];
 	items.forEach((item, index) => {
 		const with_comma = !(index === items.length - 1) || trailing ? [...item, comma_piece()] : [...item];
 		out.push(...wrap(with_comma, level + 1, options));
 	});
-	out.push(indent(level, options) + join$1(pieces.slice(group.close)));
+	out.push(indent(level, options) + join$2(pieces.slice(group.close)));
 	return out;
 }
 /** The first bracket group on the line that opens and closes there and holds a list. */
@@ -17649,7 +19636,7 @@ function sort_imports(lines) {
 		let end = i;
 		while (end + 1 < lines.length && is_import(lines[end + 1])) end++;
 		if (end > i) {
-			const run = lines.slice(i, end + 1).sort((a, b) => join$1(a.pieces) < join$1(b.pieces) ? -1 : 1);
+			const run = lines.slice(i, end + 1).sort((a, b) => join$2(a.pieces) < join$2(b.pieces) ? -1 : 1);
 			lines.splice(i, end - i + 1, ...run);
 		}
 		i = end;
@@ -17766,7 +19753,7 @@ function fallback_lib_path() {
 	return default_lib_path;
 }
 let test_src_dir;
-function join(entry_file_path, lib_path, options) {
+function join$1(entry_file_path, lib_path, options) {
 	const folder_path = path.dirname(entry_file_path);
 	const file_path = path.basename(entry_file_path);
 	const inputs = /* @__PURE__ */ new Map();
@@ -22785,6 +24772,28 @@ function raw_c_type_name(name) {
 		default: return name;
 	}
 }
+/**
+* Whether a raw block's content is pure aarch64 assembly (`#arch: aarch64`).
+* asm immediates (`mov x3, #T_SIZE`) need the compiler's numeric layout
+* size; every other target (`#arch: c`, `aarch64_use_c`, or untagged) is C
+* source, where the size must be `sizeof(T)` — C lays out structs with
+* natural alignment (tail padding), so the compiler's unpadded numeric size
+* would disagree with C's own `sizeof`/pointer-arithmetic strides and
+* undersize heap slabs (heap-buffer-overflow on wide-struct elements).
+*/
+function raw_block_is_pure_asm(value) {
+	for (const line of value.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		if (trimmed.startsWith("#arch:")) {
+			const arches = trimmed.substring(6).split(",").map((a) => a.trim()).filter((a) => a.length > 0);
+			return arches.length > 0 && arches.every((a) => a === "aarch64");
+		}
+		if (trimmed.startsWith("#platform:") || trimmed.startsWith("#scope:")) continue;
+		break;
+	}
+	return false;
+}
 function substitute_raw_in_node(node, substitution, structs, deref_params = /* @__PURE__ */ new Set()) {
 	if (node.node_type === "raw") {
 		const raw = node;
@@ -22797,7 +24806,8 @@ function substitute_raw_in_node(node, substitution, structs, deref_params = /* @
 			else c_type_name = raw_c_type_name(type);
 			value = value.replace(new RegExp(`\\b${param}\\b`, "g"), c_type_name);
 			const size = raw_type_size(type, structs);
-			value = value.replace(new RegExp(`\\b${param}_SIZE\\b`, "g"), String(size));
+			const size_expr = raw_block_is_pure_asm(value) ? String(size) : `sizeof(${c_type_name})`;
+			value = value.replace(new RegExp(`\\b${param}_SIZE\\b`, "g"), size_expr);
 			value = value.replace(new RegExp(`\\b${param}_destroy\\b`, "g"), `${type}_destroy`);
 			value = value.replace(new RegExp(`\\b${param}_NEEDS_STRDUP\\b`, "g"), type === "string" ? "1" : "0");
 		}
@@ -23211,6 +25221,11 @@ function check_access_node(node, status) {
 		add_error(status, `Unknown target: ${value_from_value_node(node.target)}`, node.target.start);
 		return false;
 	}
+	if ((node.target.node_type === "func_call" || node.target.node_type === "access" && node.target.access.node_type === "access_func") && is_owning_struct_type_requiring_move(target_type, status)) {
+		const decl = new DeclarationNode(node.target.start, "private", "const", `_recv_${status.var_name_counter.value++}`, target_type, node.target);
+		status.allocations.push(decl);
+		node.target = new ValueNode(node.target.start, decl.name, target_type);
+	}
 	if (node.access.node_type === "access_field") {
 		const af = node.access;
 		if (af.is_destructure) {
@@ -28243,7 +30258,7 @@ function run_test_file(entry_path, lib_path, arch) {
 		ms: 0
 	};
 	const resolved = path.resolve(entry_path);
-	const input = join(resolved, lib_path);
+	const input = join$1(resolved, lib_path);
 	const library = lib_path ? get_library(lib_path) : void 0;
 	const parsed = parse(input + "\n" + harness, library, resolved);
 	if (parsed.errors.length) {
@@ -28609,7 +30624,7 @@ function processFile(filename, config, mode, program_args) {
 	if (!config.lib) config.lib = resolve_lib(resolved);
 	let startTime = performance.now();
 	const resolved_path = path.resolve(filename);
-	const input = join(resolved_path, config.lib);
+	const input = join$1(resolved_path, config.lib);
 	const parsed = parse(input, config.lib ? get_library(config.lib) : void 0, resolved_path);
 	let errors = parsed.errors;
 	if (errors.length) {