@deepseek-ai/dsh-experimental-webworker-runtime 0.2.1-alpha.3 → 0.2.1-alpha.4

package/lib/worker.js

@@ -101,6 +101,202 @@ function createAlsRuntime(causality) {
 		}
 	};
 }
+//#endregion
+//#region src/node/notImplementedFail.ts
+/**
+* Structural not-implemented stubs: a replaced module must expose every symbol
+* its importers name (a missing CommonJS symbol degrades to `undefined` at call
+* time instead of failing at link time), and every one of those symbols must
+* report exactly what is unavailable when it is finally called. The refusal
+* carries Node's `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` code, so a caller that
+* can run without the feature distinguishes it from other failures.
+*/
+/**
+* Build a function that throws naming its module and symbol. The refusal is
+* also written to the console before it propagates: callers routinely swallow
+* these errors far from their cause, and the console line is what places the
+* failure while debugging a worker session.
+*
+* `Face` is the Node declaration this stub stands in for, so the replaced module
+* publishes the type its importers compile against. The value is one throwing
+* function whatever that declaration says: a caller reaches the throw before any
+* declared parameter, return value, or `new` result exists, so the assertion
+* below cannot be observed as a lie. It is a function expression rather than an
+* arrow because a stub standing in for a class must refuse under `new` too, and
+* an arrow has no construct behavior to reach.
+* @param module - module specifier being stubbed.
+* @param symbol - exported symbol name.
+* @returns the throwing stand-in, typed as the member it replaces.
+*/
+function notImplementedFail(module, symbol) {
+	return (function refuse() {
+		throw notAvailableError(module, symbol);
+	});
+}
+/** Node's standard code for a feature the running platform cannot provide. */
+const FEATURE_UNAVAILABLE_ON_PLATFORM = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+/**
+* Build the refusal error and write it to the console first, for stubs that
+* cannot be a plain throwing function (constructors, methods on structural
+* fakes).
+* @param module - module specifier being stubbed.
+* @param symbol - unavailable member, named as the importer sees it.
+* @returns the error to throw, with `code` set to Node's `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`.
+*/
+function notAvailableError(module, symbol) {
+	const message = `web-preview: ${module}.${symbol} is not available in the worker host`;
+	console.error(message);
+	return Object.assign(new Error(message), { code: FEATURE_UNAVAILABLE_ON_PLATFORM });
+}
+//#endregion
+//#region src/node/internal_modules/module-map.ts
+/**
+* `internal/modules/esm/module_map` for the Worker, following Node v24.18.0. The Worker evaluates no ES module
+* jobs, so a {@link LoadCache} stays empty and refuses to store one.
+* @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/internal_modules/module-map
+*/
+/** Job slot Node uses when an import names no `type` attribute. */
+const IMPLICIT_TYPE_ATTRIBUTE = "javascript";
+/**
+* Node's `validateString` refusal.
+* @param value - Argument to check.
+* @param name - Argument name in the message.
+*/
+function validateString(value, name) {
+	if (typeof value === "string") return;
+	throw Object.assign(/* @__PURE__ */ new TypeError(`The "${name}" argument must be of type string. Received ${typeof value}`), { code: "ERR_INVALID_ARG_TYPE" });
+}
+/** Resolutions keyed by parent URL, then by serialized module request. */
+var ResolveCache = class extends Map {
+	/**
+	* Serialize a module request: the specifier and its import attributes sorted by key.
+	* @param specifier - Requested module.
+	* @param importAttributes - Import attributes of the request.
+	* @returns The cache key Node uses for this request.
+	*/
+	serializeKey(specifier, importAttributes) {
+		const keys = Object.keys(importAttributes);
+		if (keys.length === 0) return `${specifier}::`;
+		return `${specifier}::${keys.sort().map((key) => JSON.stringify(key) + JSON.stringify(importAttributes[key])).join(",")}`;
+	}
+	#imports(parentURL) {
+		const existing = super.get(parentURL);
+		if (existing !== void 0) return existing;
+		const created = Object.create(null);
+		super.set(parentURL, created);
+		return created;
+	}
+	/**
+	* Read one cached resolution.
+	* @param serializedKey - Key from {@link serializeKey}.
+	* @param parentURL - URL of the importing module.
+	* @returns The cached resolution, if any.
+	*/
+	get(serializedKey, parentURL) {
+		return this.#imports(parentURL)[serializedKey];
+	}
+	/**
+	* Store one resolution.
+	* @param serializedKey - Key from {@link serializeKey}.
+	* @param parentURL - URL of the importing module.
+	* @param result - Resolution to cache.
+	* @returns This cache.
+	*/
+	set(serializedKey, parentURL, result) {
+		this.#imports(parentURL)[serializedKey] = result;
+		return this;
+	}
+	/**
+	* Check for one cached resolution.
+	* @param serializedKey - Key from {@link serializeKey}.
+	* @param parentURL - URL of the importing module.
+	* @returns Whether the request has a cached resolution.
+	*/
+	has(serializedKey, parentURL) {
+		return serializedKey in this.#imports(parentURL);
+	}
+};
+/** Module jobs keyed by URL, then by import `type` attribute; always empty in the Worker. */
+var LoadCache = class extends Map {
+	/**
+	* Read the job for one URL and type.
+	* @param url - Module URL.
+	* @param type - Import `type` attribute.
+	* @returns The cached job, if any.
+	*/
+	get(url, type = IMPLICIT_TYPE_ATTRIBUTE) {
+		validateString(url, "url");
+		validateString(type, "type");
+		return super.get(url)?.[type];
+	}
+	/**
+	* Refuse to store a job: the Worker creates no ES module jobs.
+	* @param url - Module URL.
+	* @param type - Import `type` attribute.
+	* @param _job - Job Node would store.
+	* @returns Never; always throws.
+	*/
+	set(url, type = IMPLICIT_TYPE_ATTRIBUTE, _job) {
+		validateString(url, "url");
+		validateString(type, "type");
+		throw notAvailableError("internal/modules/esm/module_map", "LoadCache.set");
+	}
+	/**
+	* Check for the job of one URL and type.
+	* @param url - Module URL.
+	* @param type - Import `type` attribute.
+	* @returns Whether a job is cached.
+	*/
+	has(url, type = IMPLICIT_TYPE_ATTRIBUTE) {
+		validateString(url, "url");
+		validateString(type, "type");
+		return super.get(url)?.[type] !== void 0;
+	}
+};
+//#endregion
+//#region src/node/internal_modules/esm-loader.ts
+/**
+* `internal/modules/esm/loader` cascaded loader for the Worker. {@link createCascadedLoader} builds the object with
+* the Node v24.18.0 (v2) loader members this repository calls: `resolveSync` and `import` over one Worker module
+* loader, and an empty `loadCache`. ES module jobs are unavailable on this platform.
+* @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/internal_modules/esm-loader
+*/
+/**
+* Translate a Worker resolution failure into the code Node's ESM resolver reports.
+* @param error - Failure thrown by the Worker module loader.
+* @returns The same failure with an ESM resolution code.
+*/
+function esmResolutionError(error) {
+	if (error instanceof Error && error.code === "MODULE_NOT_FOUND") return Object.assign(error, { code: "ERR_MODULE_NOT_FOUND" });
+	return error;
+}
+/**
+* Build the cascaded loader for one Worker module loader.
+* @param source - The Worker module loader's resolution and loading operations.
+* @returns A cascaded loader delegating to `source`.
+*/
+function createCascadedLoader(source) {
+	return {
+		loadCache: new LoadCache(),
+		resolveSync(parentURL, request) {
+			try {
+				const { url, format } = source.resolveSync(request.specifier, parentURL);
+				return {
+					url,
+					format
+				};
+			} catch (error) {
+				throw esmResolutionError(error);
+			}
+		},
+		import(specifier, parentURL) {
+			return source.import(specifier, parentURL);
+		},
+		getOrCreateModuleJob() {
+			throw notAvailableError("internal/modules/esm/loader", "getOrCreateModuleJob");
+		}
+	};
+}
 /**
 * Collapse `.` and `..` segments.
 * @param path - Path with any number of separators.
@@ -236,10 +432,11 @@ const WRAPPER_PARAMS = [
 //#endregion
 //#region src/module-system/module-loader.ts
 /**
-* CommonJS module loader over the worker VFS. It fills the `loader.internal`
-* seam Cordis uses for every entry import, and backs the `node:module`
-* `createRequire` proxy that `typert-loader`, `client-modules`, and the plugin
-* package inventory resolve package metadata through.
+* CommonJS module loader over the worker VFS. It backs the Node internal ESM
+* loader that `node-addon-require-builtin` answers, which Cordis's Loader uses
+* for every entry import, and the `node:module` `createRequire` proxy that
+* `typert-loader`, `client-modules`, and the plugin package inventory resolve
+* package metadata through.
 *
 * Resolution is a narrowed Node `require` algorithm: `exports` walk with a
 * fixed condition order, extension probing, and one cache keyed by resolved
@@ -275,9 +472,11 @@ var WorkerModuleLoader = class {
 	modules = /* @__PURE__ */ new Map();
 	manifests = /* @__PURE__ */ new Map();
 	stack = [];
+	cascaded;
 	/**
-	* The Cordis module seam. `parentURL` positions relative specifiers;
-	* import attributes are ignored, as the client implementation does.
+	* Resolution and loading over this mount, in Node's v1 argument order. The cascaded ESM loader
+	* ({@link cascadedLoader}) and the packer call it; `parentURL` positions relative specifiers and import attributes
+	* are ignored.
 	*/
 	internal;
 	constructor(options) {
@@ -309,9 +508,22 @@ var WorkerModuleLoader = class {
 			resolveSync: resolveInternal
 		};
 	}
-	fail(detail) {
+	/**
+	* The `internal/modules/esm/loader` cascaded loader over this mount, created on first use.
+	* @returns This loader's one cascaded loader.
+	*/
+	cascadedLoader() {
+		return this.cascaded ??= createCascadedLoader(this.internal);
+	}
+	/**
+	* Throw this loader's diagnostic.
+	* @param detail - What failed.
+	* @param code - Node error code for a resolution failure Node also reports by code.
+	*/
+	fail(detail, code) {
 		const chain = this.stack.length === 0 ? "" : ` (importer chain: ${this.stack.join(" -> ")})`;
-		throw new Error(`webworker modules: ${detail}${chain}`);
+		const error = /* @__PURE__ */ new Error(`webworker modules: ${detail}${chain}`);
+		throw code === void 0 ? error : Object.assign(error, { code });
 	}
 	/** @returns Directory a base path or URL resolves specifiers from. */
 	baseDirectoryOf(base) {
@@ -392,7 +604,7 @@ var WorkerModuleLoader = class {
 			}
 			return this.probe(join$1(path, "index"), specifier);
 		}
-		return this.fail(`cannot resolve "${specifier}": no file at ${candidates.join(", ")}`);
+		return this.fail(`cannot resolve "${specifier}": no file at ${candidates.join(", ")}`, "MODULE_NOT_FOUND");
 	}
 	/** @returns The Worker-provided implementation of a static specifier. */
 	staticModule(specifier) {
@@ -431,12 +643,12 @@ var WorkerModuleLoader = class {
 		const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? specifier;
 		const rest = specifier.slice(packageName.length).replace(/^\//, "");
 		const packageDirectory = join$1(this.root, "node_modules", packageName);
-		if (!this.vfs.existsSync(join$1(packageDirectory, "package.json"))) return this.fail(`cannot resolve "${specifier}": ${packageDirectory}/package.json is not in the image`);
+		if (!this.vfs.existsSync(join$1(packageDirectory, "package.json"))) return this.fail(`cannot resolve "${specifier}": ${packageDirectory}/package.json is not in the image`, "MODULE_NOT_FOUND");
 		const manifest = this.manifestOf(packageDirectory);
 		const subpath = rest === "" ? "." : `./${rest}`;
 		if (manifest.exports !== void 0) {
 			const target = this.selectExport(manifest.exports, subpath, packageName);
-			if (target === void 0) return this.fail(`"${packageName}" does not export "${subpath}" under conditions [${[...this.conditions].join(", ")}]`);
+			if (target === void 0) return this.fail(`"${packageName}" does not export "${subpath}" under conditions [${[...this.conditions].join(", ")}]`, "ERR_PACKAGE_PATH_NOT_EXPORTED");
 			return {
 				kind: "file",
 				path: this.probe(join$1(packageDirectory, target), specifier)
@@ -614,19 +826,21 @@ function signalProcess(pid, signal) {
 /**
 * The `process` global the worker needs before any VFS module runs. Cordis
 * reads `process.env` and `process.versions.node` while the Loader is
-* constructed, and `cordis.yml` keeps its `!!js process.*` expressions, so the
-* configuration bytes stay identical to the Node deployment. Third-party Node
+* constructed, and bundle patch rows keep their `!!js process.*` expressions, so
+* the configuration bytes stay identical to the Node deployment. Third-party Node
 * packages use the presence of `process.title` to avoid browser-only globals.
 * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/globals/process
 */
 /** Virtual executable identity; the worker has no Node binary behind it. */
 const EXEC_PATH = "/dsh/bin/node";
+/** Node release whose internal-module members `node-addon-require-builtin` follows in the Worker. */
+const NODE_VERSION = "24.18.0";
 /**
 * Publish `globalThis.process`.
 *
-* `versions.node` is `0.0.0` on purpose: it makes Cordis's
-* `ModuleLoader.fromInternal()` return undefined instead of reaching for Node
-* internals, which is what lets the worker install its own module seam.
+* `versions.node` names the Node release the Worker's `node-addon-require-builtin` internals follow, so Cordis's
+* `ModuleLoader.fromInternal()` reaches them the way it reaches Node's; `execArgv` stays empty, without
+* `--expose-internals`.
 * @param options - Root, environment, and argument vector.
 * @returns The published object, for the module proxy table.
 */
@@ -645,8 +859,8 @@ function installProcessGlobal(options) {
 		platform: "linux",
 		arch: "x64",
 		pid: 1,
-		version: "v0.0.0",
-		versions: { node: "0.0.0" },
+		version: `v${NODE_VERSION}`,
+		versions: { node: NODE_VERSION },
 		cwd: () => options.cwd,
 		getBuiltinModule: (id) => {
 			let resolution;
@@ -1650,6 +1864,8 @@ function resize(bytes, length) {
 */
 var MemoryVfs = class {
 	files = /* @__PURE__ */ new Map();
+	/** Files a lazy archive supplies on their first asynchronous read. */
+	deferred = /* @__PURE__ */ new Map();
 	directories = new Set(["/"]);
 	/** Directory permission bits; absence means {@link DEFAULT_DIRECTORY_MODE}. */
 	directoryModes = /* @__PURE__ */ new Map();
@@ -1698,7 +1914,10 @@ var MemoryVfs = class {
 	}
 	/** Promise face mirroring `node:fs/promises` for the methods the roster uses. */
 	promises = {
-		readFile: async (path, options) => this.readFileSync(path, options),
+		readFile: async (path, options) => {
+			await this.whenReadable(path);
+			return this.readFileSync(path, options);
+		},
 		writeFile: async (path, data, options) => {
 			this.writeFileSync(path, data, options);
 		},
@@ -1730,11 +1949,13 @@ var MemoryVfs = class {
 			this.chmodSync(path, mode);
 		},
 		opendir: async (path) => this.opendir(path),
-		open: async (path, flags, mode) => this.open(path, flags, mode),
+		open: async (path, flags, mode) => {
+			await this.whenReadable(path);
+			return this.open(path, flags, mode);
+		},
 		/** Resolves for any existing path: the VFS grants read and write to everything it holds. */
 		access: async (path) => {
-			const target = normalize$1(resolve$2(path));
-			if (!this.files.has(target) && !this.directories.has(target)) fail("ENOENT", "access", target);
+			if (!this.existsSync(path)) fail("ENOENT", "access", normalize$1(resolve$2(path)));
 		}
 	};
 	/** @returns Absolute path with no trailing separator. */
@@ -1743,6 +1964,101 @@ var MemoryVfs = class {
 		return absolute.length > 1 && absolute.endsWith("/") ? absolute.slice(0, -1) : absolute;
 	}
 	/**
+	* Register files whose bytes arrive with one archive on the first
+	* asynchronous read of any of them. Their parent directories are created now.
+	* @param archive - Archive name, mount root, registered files, and fetch.
+	* @throws When a registered path already holds a file, directory, or another registration.
+	*/
+	deferArchive(archive) {
+		const root = this.key(archive.root);
+		const files = /* @__PURE__ */ new Map();
+		for (const file of archive.files) {
+			const target = this.key(join$1(root, file.path));
+			if (this.files.has(target) || this.directories.has(target) || this.deferred.has(target) || files.has(target)) throw new Error(`webworker vfs: ${target} is already registered, so lazy archive ${archive.name} cannot supply it`);
+			files.set(target, file.size);
+		}
+		const state = {
+			name: archive.name,
+			root,
+			load: () => archive.load(),
+			files,
+			fetching: void 0
+		};
+		const mtimeMs = Date.now();
+		for (const [target, size] of files) {
+			this.seedDirectory(dirname$1(target));
+			this.deferred.set(target, {
+				size,
+				mode: DEFAULT_FILE_MODE,
+				mtimeMs,
+				archive: state
+			});
+			this.touchDirectory(dirname$1(target));
+		}
+	}
+	/**
+	* Fetch the lazy archive that supplies a registered path. Concurrent readers
+	* of one archive share one fetch; a failed fetch leaves its files registered,
+	* so the next read fetches again.
+	* @param path - Path about to be read asynchronously.
+	* @returns A promise that settles once the archive arrived, or undefined when the path needs no fetch.
+	*/
+	whenReadable(path) {
+		const file = this.deferred.get(this.key(path));
+		if (file === void 0) return void 0;
+		file.archive.fetching ??= this.fetchArchive(file.archive);
+		return file.archive.fetching;
+	}
+	/** Fetch, validate against the registration, and mount one archive's files. */
+	async fetchArchive(state) {
+		try {
+			let archive;
+			try {
+				archive = await state.load();
+			} catch (error) {
+				throw new Error(`webworker vfs: lazy archive ${state.name} could not be fetched`, { cause: error });
+			}
+			const entries = /* @__PURE__ */ new Map();
+			for (const entry of parseTar(archive)) {
+				if (entry.directory) continue;
+				const relativeName = entry.name.startsWith("./") ? entry.name.slice(2) : entry.name;
+				const target = this.key(join$1(state.root, relativeName));
+				const size = state.files.get(target);
+				if (size === void 0) throw new Error(`webworker vfs: lazy archive ${state.name} carries unregistered entry "${relativeName}"`);
+				if (entry.bytes.length !== size) throw new Error(`webworker vfs: lazy archive ${state.name} holds ${String(entry.bytes.length)} bytes for ${target}, registered as ${String(size)}`);
+				entries.set(target, entry.bytes);
+			}
+			for (const target of state.files.keys()) if (!entries.has(target)) throw new Error(`webworker vfs: lazy archive ${state.name} lacks registered file ${target}`);
+			for (const [target, bytes] of entries) {
+				const file = this.deferred.get(target);
+				if (file?.archive !== state) continue;
+				this.deferred.delete(target);
+				const identity = this.identities.get(target);
+				this.identities.delete(target);
+				this.setFile(target, {
+					bytes,
+					mtimeMs: file.mtimeMs,
+					mode: file.mode,
+					paths: void 0,
+					...identity === void 0 ? {} : { identity }
+				});
+			}
+		} catch (error) {
+			state.fetching = void 0;
+			throw error;
+		}
+	}
+	/** Refuse a synchronous operation on a registered file whose bytes have not arrived. */
+	requireArrived(syscall, target) {
+		const file = this.deferred.get(target);
+		if (file === void 0) return;
+		const error = /* @__PURE__ */ new Error(`ERR_DSH_VFS_DEFERRED: ${syscall} cannot wait for '${target}', which lazy archive ${file.archive.name} supplies on its first asynchronous read`);
+		error.code = "ERR_DSH_VFS_DEFERRED";
+		error.path = target;
+		error.syscall = syscall;
+		throw error;
+	}
+	/**
 	* Read a file.
 	* @param path - File path.
 	* @param options - `'utf8'` or `{encoding}` for text; omitted for bytes.
@@ -1750,6 +2066,7 @@ var MemoryVfs = class {
 	*/
 	readFileSync(path, options) {
 		const target = this.key(path);
+		this.requireArrived("open", target);
 		const node = this.files.get(target);
 		if (node === void 0) {
 			if (this.directories.has(target)) fail("EISDIR", "read", target);
@@ -1764,7 +2081,7 @@ var MemoryVfs = class {
 	*/
 	existsSync(path) {
 		const target = this.key(path);
-		return this.files.has(target) || this.directories.has(target);
+		return this.files.has(target) || this.directories.has(target) || this.deferred.has(target);
 	}
 	/**
 	* Stat a path.
@@ -1775,11 +2092,17 @@ var MemoryVfs = class {
 	statSync(path, options) {
 		const target = this.key(path);
 		const node = this.files.get(target);
+		const deferred = this.deferred.get(target);
 		const [size, mtimeMs, directory, mode] = node !== void 0 ? [
 			node.bytes.length,
 			node.mtimeMs,
 			false,
 			node.mode
+		] : deferred !== void 0 ? [
+			deferred.size,
+			deferred.mtimeMs,
+			false,
+			deferred.mode
 		] : this.directories.has(target) ? [
 			0,
 			this.directoryMtimes.get(target) ?? 0,
@@ -1949,12 +2272,16 @@ var MemoryVfs = class {
 	readdirSync(path, options) {
 		const target = this.key(path);
 		if (!this.directories.has(target)) {
-			if (this.files.has(target)) fail("ENOTDIR", "scandir", target);
+			if (this.files.has(target) || this.deferred.has(target)) fail("ENOTDIR", "scandir", target);
 			fail("ENOENT", "scandir", target);
 		}
 		const prefix = target === "/" ? "/" : `${target}/`;
 		const names = /* @__PURE__ */ new Set();
-		for (const candidate of [...this.files.keys(), ...this.directories]) {
+		for (const candidate of [
+			...this.files.keys(),
+			...this.deferred.keys(),
+			...this.directories
+		]) {
 			if (!candidate.startsWith(prefix) || candidate === target) continue;
 			const rest = candidate.slice(prefix.length);
 			if (rest === "") continue;
@@ -1994,7 +2321,7 @@ var MemoryVfs = class {
 	*/
 	mkdirSync(path, options) {
 		const target = this.key(path);
-		if (this.files.has(target)) fail("EEXIST", "mkdir", target);
+		if (this.files.has(target) || this.deferred.has(target)) fail("EEXIST", "mkdir", target);
 		if (this.directories.has(target)) {
 			if (options?.recursive === true) return void 0;
 			fail("EEXIST", "mkdir", target);
@@ -2024,6 +2351,7 @@ var MemoryVfs = class {
 	*/
 	writeFileSync(path, data, options) {
 		const target = this.key(path);
+		this.requireArrived("open", target);
 		if (this.directories.has(target)) fail("EISDIR", "open", target);
 		if (!this.directories.has(dirname$1(target))) fail("ENOENT", "open", target);
 		const flag = options?.flag ?? "w";
@@ -2154,6 +2482,7 @@ var MemoryVfs = class {
 	*/
 	openFileSync(path, flags = "r", mode) {
 		const target = this.key(path);
+		this.requireArrived("open", target);
 		const access = openMode(flags);
 		const existing = this.files.get(target);
 		if (this.directories.has(target)) fail("EISDIR", "open", target);
@@ -2215,6 +2544,7 @@ var MemoryVfs = class {
 	*/
 	appendFileSync(path, data) {
 		const target = this.key(path);
+		this.requireArrived("open", target);
 		const existing = this.files.get(target);
 		const addition = typeof data === "string" ? encoder$1.encode(data) : data;
 		if (existing === void 0) {
@@ -2231,6 +2561,8 @@ var MemoryVfs = class {
 	renameSync(from, to) {
 		const source = this.key(from);
 		const destination = this.key(to);
+		this.requireArrived("rename", source);
+		this.requireArrived("rename", destination);
 		if (source === destination) return;
 		const node = this.files.get(source);
 		if (node !== void 0) {
@@ -2259,13 +2591,14 @@ var MemoryVfs = class {
 		if (!this.directories.has(source)) fail("ENOENT", "rename", source);
 		if (this.files.has(destination)) fail("ENOTDIR", "rename", destination);
 		if (!this.directories.has(dirname$1(destination))) fail("ENOENT", "rename", destination);
+		const prefix = `${source}/`;
+		for (const registered of this.deferred.keys()) if (registered.startsWith(prefix)) this.requireArrived("rename", registered);
 		if (this.directories.has(destination)) {
 			if (this.readdirSync(destination).length > 0) fail("ENOTEMPTY", "rename", destination);
 			this.directories.delete(destination);
 			this.directoryModes.delete(destination);
 			this.directoryMtimes.delete(destination);
 		}
-		const prefix = `${source}/`;
 		const movedFiles = [];
 		for (const [candidate, value] of [...this.files]) {
 			if (!candidate.startsWith(prefix)) continue;
@@ -2327,9 +2660,10 @@ var MemoryVfs = class {
 	linkSync(existing, next) {
 		const source = this.key(existing);
 		const target = this.key(next);
+		this.requireArrived("link", source);
 		const node = this.files.get(source);
 		if (node === void 0) fail("ENOENT", "link", source);
-		if (this.files.has(target) || this.directories.has(target)) fail("EEXIST", "link", target);
+		if (this.existsSync(target)) fail("EEXIST", "link", target);
 		if (!this.directories.has(dirname$1(target))) fail("ENOENT", "link", target);
 		this.setFile(target, node);
 		this.touchDirectory(dirname$1(target));
@@ -2348,6 +2682,7 @@ var MemoryVfs = class {
 	*/
 	truncateSync(path, length = 0) {
 		const target = this.key(path);
+		this.requireArrived("truncate", target);
 		const node = this.files.get(target);
 		if (node === void 0) fail("ENOENT", "truncate", target);
 		this.truncateFile(node, length);
@@ -2359,6 +2694,7 @@ var MemoryVfs = class {
 	*/
 	chmodSync(path, mode) {
 		const target = this.key(path);
+		this.requireArrived("chmod", target);
 		const node = this.files.get(target);
 		if (node !== void 0) {
 			this.chmodFile(node, mode);
@@ -2382,7 +2718,7 @@ var MemoryVfs = class {
 	*/
 	unlinkSync(path) {
 		const target = this.key(path);
-		if (this.deleteFile(target) === void 0) fail("ENOENT", "unlink", target);
+		if (this.deleteFile(target) === void 0 && !this.deferred.delete(target)) fail("ENOENT", "unlink", target);
 		this.forgetIdentity(target);
 		this.touchDirectory(dirname$1(target));
 		this.publish({
@@ -2397,7 +2733,7 @@ var MemoryVfs = class {
 	*/
 	rmSync(path, options) {
 		const target = this.key(path);
-		if (this.deleteFile(target) !== void 0) {
+		if (this.deleteFile(target) !== void 0 || this.deferred.delete(target)) {
 			this.forgetIdentity(target);
 			this.touchDirectory(dirname$1(target));
 			this.publish({
@@ -2410,6 +2746,7 @@ var MemoryVfs = class {
 			if (options?.recursive !== true) fail("ERR_FS_EISDIR", "rm", target);
 			const prefix = `${target}/`;
 			for (const candidate of [...this.files.keys()]) if (candidate.startsWith(prefix)) this.deleteFile(candidate);
+			for (const candidate of [...this.deferred.keys()]) if (candidate.startsWith(prefix)) this.deferred.delete(candidate);
 			for (const candidate of [...this.directories]) {
 				if (!candidate.startsWith(prefix)) continue;
 				this.directories.delete(candidate);
@@ -2449,6 +2786,7 @@ var MemoryVfs = class {
 	seed(path, data, options = {}) {
 		const target = this.key(path);
 		this.seedDirectory(dirname$1(target));
+		this.deferred.delete(target);
 		this.setFile(target, {
 			bytes: typeof data === "string" ? encoder$1.encode(data) : data,
 			mtimeMs: options.mtimeMs ?? this.touch(target),
@@ -2467,7 +2805,7 @@ var MemoryVfs = class {
 		if (!this.directories.has(target)) {
 			const parent = dirname$1(target);
 			if (parent !== target) this.seedDirectory(parent);
-			if (this.files.has(target)) fail("EEXIST", "mkdir", target);
+			if (this.files.has(target) || this.deferred.has(target)) fail("EEXIST", "mkdir", target);
 			this.directories.add(target);
 			this.directoryMtimes.set(target, options.mtimeMs ?? Date.now());
 			this.touchDirectory(parent);
@@ -2492,7 +2830,7 @@ var MemoryVfs = class {
 /**
 * Mount a tar image produced by the build-time collector.
 *
-* Entry names are relative to `root` (`node_modules/...`, `config/cordis.yml`);
+* Entry names are relative to `root` (`node_modules/...`, `config/vfs-manifest.json`);
 * an absolute entry name is a collector defect and fails loud. File contents
 * stay views into `image` — nothing is copied at mount time.
 * @param image - The ustar archive, as `inflateImage` produces it from the fetched image.
@@ -2604,6 +2942,72 @@ const XDG_OPEN_EXECUTABLE = {
 		return { kind: "asynchronous" };
 	}
 };
+//#endregion
+//#region src/image-manifest.ts
+/**
+* The base image's manifest: what the packer records about one image and what
+* the worker host requires before it wraps a module or boots the tree. Both
+* sides use these types; the worker validates the fetched file with
+* {@link parseImageManifest}.
+*/
+function recordOf(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/** A relative path made of non-empty segments without traversal. */
+function isRelativePath(value) {
+	return typeof value === "string" && value !== "" && !value.startsWith("/") && value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+function isCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+/**
+* Validate a fetched base-image manifest.
+* @param value - Parsed manifest JSON.
+* @param path - Manifest path inside the image, named in refusals.
+* @returns The detached manifest.
+* @throws When the manifest is malformed, or its bodies were lowered against another wrapper contract.
+*/
+function parseImageManifest(value, path) {
+	const record = recordOf(value);
+	if (record === void 0) throw new Error(`webworker host: ${path} does not hold an object`);
+	if (record.lowered !== "dsh-worker-transform/1") throw new Error(`webworker host: image was lowered by ${String(record.lowered)}, this build runs ${LOWERING_VERSION}; rebuild the image`);
+	const { root, profile, installation, javascriptEntries, visitedEntries, rewrittenEntries, lazy } = record;
+	if (typeof root !== "string" || typeof profile !== "string" || profile === "" || installation !== void 0 && (typeof installation !== "string" || installation === "") || !isCount(javascriptEntries) || !isCount(visitedEntries) || !isCount(rewrittenEntries) || !Array.isArray(lazy)) throw new Error(`webworker host: ${path} lacks a valid root, profile, installation, entry count, or lazy archive list`);
+	const archives = [];
+	const archiveNames = /* @__PURE__ */ new Set();
+	const filePaths = /* @__PURE__ */ new Set();
+	for (const entry of lazy) {
+		const archive = recordOf(entry);
+		const name = archive?.archive;
+		const files = archive?.files;
+		if (!isRelativePath(name) || archiveNames.has(name) || !Array.isArray(files) || files.length === 0) throw new Error(`webworker host: ${path} lists an invalid or repeated lazy archive`);
+		archiveNames.add(name);
+		const parsed = [];
+		for (const candidate of files) {
+			const file = recordOf(candidate);
+			if (file === void 0 || !isRelativePath(file.path) || !isCount(file.size) || filePaths.has(file.path)) throw new Error(`webworker host: ${path} lists an invalid or repeated file in lazy archive ${name}`);
+			filePaths.add(file.path);
+			parsed.push({
+				path: file.path,
+				size: file.size
+			});
+		}
+		archives.push({
+			archive: name,
+			files: parsed
+		});
+	}
+	return {
+		root,
+		profile,
+		...installation === void 0 ? {} : { installation },
+		lowered: LOWERING_VERSION,
+		javascriptEntries,
+		visitedEntries,
+		rewrittenEntries,
+		lazy: archives
+	};
+}
 function requireGlobalPort(channel) {
 	if (channel !== void 0) return channel;
 	const post = globalThis.postMessage;
@@ -2626,7 +3030,6 @@ async function readImage(image) {
 */
 function createWorkerHost(options) {
 	const root = options.root ?? "/dsh";
-	const configPath = options.configPath ?? join$1(root, "config/cordis.yml");
 	const port = options.port ?? 3080;
 	const tunnel = new TunnelServer({
 		port: requireGlobalPort(options.channel),
@@ -2643,7 +3046,7 @@ function createWorkerHost(options) {
 	const start = async () => {
 		try {
 			const home = join$1(root, IMAGE_HOME_DIRECTORY);
-			installProcessGlobal({
+			const processShim = installProcessGlobal({
 				cwd: root,
 				env: {
 					DSH_HOME: home,
@@ -2657,7 +3060,8 @@ function createWorkerHost(options) {
 			for (const directory of IMAGE_EMPTY_DIRECTORIES) mounted.seedDirectory(join$1(root, directory.replace(/\/$/, "")));
 			setActiveVfs(mounted);
 			vfs = mounted;
-			requireLoweredImage(mounted, options.manifestPath ?? join$1(root, "config/vfs-manifest.json"));
+			const manifest = readImageManifest(mounted, options.manifestPath ?? join$1(root, "config/vfs-manifest.json"));
+			deferLazyArchives(mounted, manifest, root, options.image);
 			const staticModules = { ...options.staticModules };
 			for (const key of ["node:process", "process"]) staticModules[key] ??= () => globalThis.process;
 			const loader = new WorkerModuleLoader({
@@ -2669,16 +3073,18 @@ function createWorkerHost(options) {
 			});
 			setActiveModuleLoader(loader);
 			modules = loader;
-			const require = loader.requireFrom(dirname$1(configPath));
+			const require = loader.requireFrom(root);
 			const appBoot = require("@deepseek-ai/dsh-app-boot");
+			const { DSH_LAUNCH_ENVIRONMENT_KEY } = require("@deepseek-ai/dsh-launch-environment");
 			const cmdline = require("@deepseek-ai/dsh-cmdline");
 			const started = Promise.withResolvers();
-			const { patches, profile } = bootPatches(loader, mounted, configPath, root);
+			const { patches, profile, environment } = prepareProfile(appBoot, mounted, manifest, root, processShim.env);
 			const profileConfig = join$1(profile.dir, "cordis.yml");
-			const ctx = await appBoot.boot("dsh-webworker", profileConfig, patches, (hostCtx) => {
+			const ctx = await appBoot.boot(BIN_NAME, profileConfig, patches, async (hostCtx) => {
 				hostCtx.provide("profileContext", profile);
-				hostCtx.loader.internal = loader.internal;
+				hostCtx.provide(DSH_LAUNCH_ENVIRONMENT_KEY, environment);
 				installLogSink(hostCtx, require);
+				await hostCtx.plugin(appBoot.PluginPackages, {});
 				cmdline.provideCmdline(hostCtx, {
 					args: [...options.cmdlineArgs ?? [
 						"--host",
@@ -2708,7 +3114,7 @@ function createWorkerHost(options) {
 			if (typertGateway === void 0) throw new Error("webworker host: the tree activated without a typertGateway service");
 			const handler = connection.createSharedFetchHandler("/api");
 			const usage = loader.usage();
-			console.info(`webworker host: tree active (modules=${String(usage.modules)}, data overlays=${String(overlays.length)}, direct lane=connection.createSharedFetchHandler, als causality=${options.alsCausality === void 0 ? "inert" : "snapshot/restore"}, image lowering=${LOWERING_VERSION})`);
+			console.info(`webworker host: tree active (modules=${String(usage.modules)}, data overlays=${String(overlays.length)}, lazy archives=${String(manifest.lazy.length)}, direct lane=connection.createSharedFetchHandler, als causality=${options.alsCausality === void 0 ? "inert" : "snapshot/restore"}, image lowering=${LOWERING_VERSION})`);
 			const peer = connection.browserPeer;
 			tunnel.serve({
 				directFetch: (request) => handler.fetch(request, peer),
@@ -2768,76 +3174,84 @@ function installLogSink(ctx, require) {
 	};
 	ctx.logger.exporter(exporter);
 }
+/** Diagnostic prefix the launcher passes to app-boot; the Worker boots the same profile code. */
+const BIN_NAME = "dsh";
 /**
-* Require the mounted image to carry bodies this build can wrap.
+* Read and validate the mounted image's manifest.
 *
 * The manifest the packer writes is the single source of truth: the worker holds
 * no transform, so an image that was never lowered — or was lowered against
 * different wrapper semantics — cannot be recovered at load and must be rebuilt.
 * @param vfs - Mounted filesystem.
 * @param path - Manifest path inside the image.
-* @throws When the manifest is missing, unreadable, or names another contract.
+* @returns The validated manifest.
+* @throws When the manifest is missing, malformed, or names another contract.
 */
-function requireLoweredImage(vfs, path) {
+function readImageManifest(vfs, path) {
 	if (!vfs.existsSync(path)) throw new Error(`webworker host: ${path} is missing, so the image records no lowering; rebuild the image`);
-	const parsed = JSON.parse(vfs.readFileSync(path, "utf8"));
-	if (typeof parsed !== "object" || parsed === null) throw new Error(`webworker host: ${path} does not hold an object`);
-	const lowered = parsed.lowered;
-	if (lowered !== "dsh-worker-transform/1") throw new Error(`webworker host: image was lowered by ${String(lowered)}, this build runs ${LOWERING_VERSION}; rebuild the image`);
+	return parseImageManifest(JSON.parse(vfs.readFileSync(path, "utf8")), path);
 }
 /**
-* Prepare an editable VFS profile from the packed rows and deployment overlays.
-* ConfigEditor writes overrides beside the insertion rows; reconciliation starts
-* at the empty profile root and retains the Worker deployment overlays.
-* @param loader - Module loader, for the image's YAML reader.
-* @param vfs - Filesystem holding the composed configuration.
-* @param configPath - Composed configuration path.
-* @param root - Virtual root.
-* @returns Profile locations and effective boot patches.
-*/
-function bootPatches(loader, vfs, configPath, root) {
-	const text = vfs.readFileSync(configPath, "utf8");
-	const include = loader.load(loader.resolve("@deepseek-ai/cordis-plugin-include", root));
-	const yaml = loader.load(loader.resolve("js-yaml", root));
-	let rows;
-	if (configPath.endsWith(".json")) rows = JSON.parse(text);
-	else rows = yaml.load(text, { schema: include.entryListSchema });
-	const find = (entries, id) => {
-		if (!Array.isArray(entries)) return void 0;
-		for (const entry of entries) {
-			if (entry.id === id) return entry;
-			const nested = find(entry.config, id);
-			if (nested !== void 0) return nested;
-		}
-	};
-	const configOf = (row) => typeof row.config === "object" && row.config !== null && !Array.isArray(row.config) ? row.config : {};
-	const patches = [];
-	const jsonl = find(rows, "session-persistence-jsonl");
-	if (jsonl !== void 0) patches.push({
-		id: "session-persistence-jsonl",
-		config: {
-			...configOf(jsonl),
-			compression: "none"
-		}
-	});
-	const dir = join$1(root, IMAGE_HOME_DIRECTORY, "profiles/preview");
+* Register the manifest's lazy archives; each is fetched beside the image on
+* the first asynchronous read of a file it carries.
+* @param vfs - Mounted filesystem.
+* @param manifest - Validated image manifest.
+* @param root - Virtual root the archives' entries mount under.
+* @param image - The image bytes or URL; archive names resolve against a URL.
+* @throws When the image registers lazy archives but arrived as bytes, leaving them unlocatable.
+*/
+function deferLazyArchives(vfs, manifest, root, image) {
+	if (manifest.lazy.length === 0) return;
+	if (typeof image !== "string") throw new Error("webworker host: the image registers lazy archives, which only an image fetched from a URL can locate");
+	const base = new URL(image, globalThis.location?.href);
+	for (const archive of manifest.lazy) {
+		const url = new URL(archive.archive, base).href;
+		vfs.deferArchive({
+			name: archive.archive,
+			root,
+			files: archive.files,
+			load: () => readImage(url)
+		});
+	}
+}
+/**
+* Prepare the profile the served launcher would boot: the image's app-boot
+* initializes the manifest's shipped profile template under the Worker home
+* and composes its bundle layers, user layer, and home layer. The profile
+* context carries the launcher's facts with no command-line overlay; the
+* image's home patch, written by the packer, carries the Worker's required
+* row config (`PLATFORM_ENTRY_CONFIG` in `image-layout.ts`).
+* @param appBoot - The image's app-boot.
+* @param vfs - Filesystem holding the profile.
+* @param manifest - Validated image manifest naming the profile and installation.
+* @param root - Virtual root, the process working directory.
+* @param env - The process shim's environment, after the launch layers applied.
+* @returns Effective boot patches, the profile context, and the launch environment snapshot.
+* @throws When the image names no installation manifest to anchor bundle resolution.
+*/
+function prepareProfile(appBoot, vfs, manifest, root, env) {
+	if (manifest.installation === void 0) throw new Error("webworker host: the image names no installation manifest, so no profile bundle can resolve; rebuild the image");
+	const home = join$1(root, IMAGE_HOME_DIRECTORY);
+	const installAnchor = join$1(root, "node_modules", manifest.installation, "package.json");
+	const environment = appBoot.loadLayeredEnv(BIN_NAME, root);
+	const loaded = appBoot.loadProfile(BIN_NAME, manifest.profile, installAnchor, home);
+	appBoot.reportSkippedBundles(BIN_NAME, loaded);
+	vfs.writeFileSync(join$1(loaded.dir, "cordis.yml"), "[]\n");
 	const profile = {
-		name: "preview",
-		dir,
-		patchPath: join$1(dir, "cordis.patch.yml"),
-		installAnchor: join$1(dir, "package.json"),
+		name: loaded.name,
+		dir: loaded.dir,
+		patchPath: loaded.patchPath,
+		installAnchor,
 		cwd: root,
-		home: join$1(root, IMAGE_HOME_DIRECTORY),
-		startedBundles: [],
-		overlays: patches,
-		telemetryDisabledEnv: void 0
-	};
-	vfs.seed(join$1(dir, "package.json"), "{\"private\":true,\"dsh\":{\"profile\":{\"bundles\":[]}}}\n");
-	vfs.seed(join$1(dir, "cordis.yml"), "[]\n");
-	if (!vfs.existsSync(profile.patchPath)) vfs.seed(profile.patchPath, yaml.dump([{ insert: rows }], { schema: include.entryListSchema }));
+		home,
+		startedBundles: loaded.layers.map((layer) => layer.packageName),
+		overlays: [],
+		telemetryDisabledEnv: env.DSH_TELEMETRY_DISABLED
+	};
 	return {
-		patches: loader.load(loader.resolve("@deepseek-ai/dsh-app-boot", root)).readProfilePatches("dsh-webworker", profile),
-		profile
+		patches: appBoot.readProfilePatches(BIN_NAME, profile, loaded),
+		profile,
+		environment
 	};
 }
 /**
@@ -4331,49 +4745,6 @@ var buffer_default = {
 	kMaxLength: import_buffer.kMaxLength
 };
 //#endregion
-//#region src/node/notImplementedFail.ts
-/**
-* Structural not-implemented stubs: a replaced module must expose every symbol
-* its importers name (a missing CommonJS symbol degrades to `undefined` at call
-* time instead of failing at link time), and every one of those symbols must
-* report exactly what is unavailable when it is finally called.
-*/
-/**
-* Build a function that throws naming its module and symbol. The refusal is
-* also written to the console before it propagates: callers routinely swallow
-* these errors far from their cause, and the console line is what places the
-* failure while debugging a worker session.
-*
-* `Face` is the Node declaration this stub stands in for, so the replaced module
-* publishes the type its importers compile against. The value is one throwing
-* function whatever that declaration says: a caller reaches the throw before any
-* declared parameter, return value, or `new` result exists, so the assertion
-* below cannot be observed as a lie. It is a function expression rather than an
-* arrow because a stub standing in for a class must refuse under `new` too, and
-* an arrow has no construct behavior to reach.
-* @param module - module specifier being stubbed.
-* @param symbol - exported symbol name.
-* @returns the throwing stand-in, typed as the member it replaces.
-*/
-function notImplementedFail(module, symbol) {
-	return (function refuse() {
-		throw notAvailableError(module, symbol);
-	});
-}
-/**
-* Build the refusal error and write it to the console first, for stubs that
-* cannot be a plain throwing function (constructors, methods on structural
-* fakes).
-* @param module - module specifier being stubbed.
-* @param symbol - unavailable member, named as the importer sees it.
-* @returns the error to throw.
-*/
-function notAvailableError(module, symbol) {
-	const message = `web-preview: ${module}.${symbol} is not available in the worker host`;
-	console.error(message);
-	return new Error(message);
-}
-//#endregion
 //#region src/node/builtin_modules/implemented/async_hooks.ts
 /**
 * `node:async_hooks` for the worker: `AsyncLocalStorage` over an EXPLICIT-SWITCH
@@ -11281,8 +11652,10 @@ const DSH_TMP = `${DSH_ROOT}/tmp`;
 * Node). `../../../../tests/node/path-diff.spec.ts` pins the port below to
 * Node's answers.
 * A `node:` proxy has to answer what Node answers, since VFS paths were built with
-* Node semantics. `win32` members throw: the worker host reports
-* `process.platform === 'linux'`, so a Windows branch means a bug.
+* Node semantics. `win32` members throw, except `isAbsolute`, which
+* cross-platform callers use to reject Windows absolute paths on any platform:
+* the worker host reports `process.platform === 'linux'`, so any other Windows
+* branch means a bug.
 */
 var path_exports = /* @__PURE__ */ __exportAll({
 	__esModule: () => true,
@@ -11614,11 +11987,31 @@ const posix = {
 const win32Member = (name) => () => {
 	throw new Error(`web-preview: node:path.win32.${name} is unreachable — the worker host reports platform "linux"`);
 };
-/** Windows member set: reaching it means a platform branch went the wrong way. */
+const CHAR_BACKWARD_SLASH = 92;
+const CHAR_COLON = 58;
+/** Node's win32 separator test: `/` or `\`. */
+function isWin32Separator(code) {
+	return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+/** Node's drive-letter test: `A`–`Z` or `a`–`z`. */
+function isWindowsDeviceRoot(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+/**
+* Node's `path.win32.isAbsolute`, a string check cross-platform callers make on every platform.
+* @param path - Path to classify.
+* @returns Whether a Windows host would treat the path as absolute.
+*/
+function win32IsAbsolute(path) {
+	if (path.length === 0) return false;
+	const code = path.charCodeAt(0);
+	return isWin32Separator(code) || path.length > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWin32Separator(path.charCodeAt(2));
+}
+/** Windows member set: reaching a member other than `isAbsolute` means a platform branch went the wrong way. */
 const win32 = {
 	resolve: win32Member("resolve"),
 	normalize: win32Member("normalize"),
-	isAbsolute: win32Member("isAbsolute"),
+	isAbsolute: win32IsAbsolute,
 	join: win32Member("join"),
 	relative: win32Member("relative"),
 	dirname: win32Member("dirname"),
@@ -11692,6 +12085,18 @@ const statOrMissing = (path, bigint) => {
 const statsChanged = (left, right) => left.size !== right.size || left.mtimeMs !== right.mtimeMs || left.mode !== right.mode || left.ino !== right.ino || left.isFile() !== right.isFile() || left.isDirectory() !== right.isDirectory();
 const contains$1 = (parent, child) => parent === "/" || child === parent || child.startsWith(`${parent}/`);
 const overlaps = (left, right) => contains$1(left, right) || contains$1(right, left);
+/**
+* Run a watcher callback in the async context where its watcher was created, as Node delivers watch events from the
+* watch handle: stores captured at creation apply, and every other store reads `undefined` instead of the store of the
+* code whose write produced the event.
+* @param context - Context captured when the watcher was created.
+* @param callback - Event dispatch.
+*/
+const dispatchInWatcherContext = (context, callback) => {
+	runAtAsyncContextRoot(() => {
+		runWithAsyncContext(context, callback);
+	});
+};
 /** `fs.FSWatcher` over VFS mutations. */
 var FSWatcher = class extends EventEmitter {
 	target;
@@ -11716,7 +12121,7 @@ var FSWatcher = class extends EventEmitter {
 			const filename = this.filename(mutation.path);
 			queueMicrotask(() => {
 				if (this.closed) return;
-				runWithAsyncContext(context, () => {
+				dispatchInWatcherContext(context, () => {
 					this.emit("change", eventType, filename);
 				});
 			});
@@ -11823,7 +12228,7 @@ var StatWatcher = class extends EventEmitter {
 			const current = statOrMissing(this.path, this.bigint);
 			const previous = this.previous;
 			this.previous = current;
-			if (initialMissing || statsChanged(current, previous)) runWithAsyncContext(this.context, () => {
+			if (initialMissing || statsChanged(current, previous)) dispatchInWatcherContext(this.context, () => {
 				this.emit("change", current, previous);
 			});
 		}, this.interval);
@@ -12468,6 +12873,21 @@ function closeFileStream(stream, callback) {
 	});
 	stream.destroy();
 }
+/** Open a read stream's descriptor and announce it, completing `_construct`. */
+function openReadDescriptor(stream, path, flags, callback) {
+	let fd;
+	try {
+		fd = openSync(path, flags);
+	} catch (error) {
+		callback(error);
+		return;
+	}
+	stream.fd = fd;
+	stream.pending = false;
+	callback();
+	stream.emit("open", fd);
+	stream.emit("ready");
+}
 /** Read stream over one VFS file. */
 var ReadStream = class extends Readable {
 	/** Resolved path opened by this stream. */
@@ -12511,18 +12931,16 @@ var ReadStream = class extends Readable {
 			callback(abortError$1(this.signal.reason));
 			return;
 		}
-		let fd;
-		try {
-			fd = openSync(this.path, this.flags);
-		} catch (error) {
-			callback(error);
+		const arrival = vfs().whenReadable(this.path);
+		if (arrival === void 0) {
+			openReadDescriptor(this, this.path, this.flags, callback);
 			return;
 		}
-		this.fd = fd;
-		this.pending = false;
-		callback();
-		this.emit("open", fd);
-		this.emit("ready");
+		arrival.then(() => {
+			openReadDescriptor(this, this.path, this.flags, callback);
+		}, (error) => {
+			callback(error);
+		});
 	}
 	_read(size) {
 		if (this.fd === null) return;
@@ -12686,7 +13104,10 @@ function opendirSync(path) {
 * check here is that every name is a real `node:fs/promises` export.
 */
 const promises = {
-	readFile: async (path, options) => readFileSync(path, options),
+	readFile: async (path, options) => {
+		await vfs().whenReadable(asPath(path));
+		return readFileSync(path, options);
+	},
 	writeFile: async (path, data, options) => {
 		const flag = typeof options === "object" && options !== null ? options.flag : void 0;
 		const mode = typeof options === "object" && options !== null ? options.mode : void 0;
@@ -12734,12 +13155,16 @@ const promises = {
 			return;
 		}
 		mkdirSync(dirname(target), { recursive: true });
+		await vfs().whenReadable(source);
 		writeFileSync(target, bytesOf(source));
 	},
 	link: async (from, to) => {
 		linkSync(from, to);
 	},
-	open: async (path, flags, mode) => openHandleSync(path, flags, mode),
+	open: async (path, flags, mode) => {
+		await vfs().whenReadable(asPath(path));
+		return openHandleSync(path, flags, mode);
+	},
 	opendir: async (path) => opendirSync(path),
 	truncate: async (path, length = 0) => {
 		vfs().truncateSync(asPath(path), length);
@@ -13397,6 +13822,7 @@ var util_exports = /* @__PURE__ */ __exportAll({
 	default: () => util_default,
 	deprecate: () => deprecate,
 	format: () => format,
+	inherits: () => inherits,
 	inspect: () => inspect,
 	isDeepStrictEqual: () => isDeepStrictEqual,
 	parseArgs: () => parseArgs,
@@ -13509,6 +13935,33 @@ function parseArgs() {
 function deprecate(fn) {
 	return fn;
 }
+/**
+* Node's `ERR_INVALID_ARG_TYPE` refusal for {@link inherits}.
+* @param name - Argument name.
+* @param expected - Expected type.
+* @param actual - Received value.
+* @returns The error to throw.
+*/
+function invalidArgType(name, expected, actual) {
+	return Object.assign(/* @__PURE__ */ new TypeError(`The "${name}" argument must be of type ${expected}. Received ${String(actual)}`), { code: "ERR_INVALID_ARG_TYPE" });
+}
+/**
+* Node's `util.inherits`: link `ctor.prototype` to `superCtor.prototype` and record `ctor.super_`.
+* @param ctor - Constructor that inherits.
+* @param superCtor - Constructor inherited from.
+*/
+function inherits(ctor, superCtor) {
+	if (ctor === void 0 || ctor === null) throw invalidArgType("ctor", "Function", ctor);
+	if (superCtor === void 0 || superCtor === null) throw invalidArgType("superCtor", "Function", superCtor);
+	const parent = superCtor.prototype;
+	if (parent === void 0) throw invalidArgType("superCtor.prototype", "Object", parent);
+	Object.defineProperty(ctor, "super_", {
+		value: superCtor,
+		writable: true,
+		configurable: true
+	});
+	Object.setPrototypeOf(ctor.prototype, parent);
+}
 /** Text decoder class, as `node:util` re-exports it. */
 const TextDecoderClass = globalThis.TextDecoder;
 /** Text encoder class, as `node:util` re-exports it. */
@@ -13523,6 +13976,7 @@ var util_default = {
 	types: types$1,
 	parseArgs,
 	deprecate,
+	inherits,
 	TextDecoder: TextDecoderClass,
 	TextEncoder: TextEncoderClass
 };
@@ -21708,6 +22162,76 @@ var got_exports = /* @__PURE__ */ __exportAll({
 /** Reject product telemetry HTTP requests without opening a connection. */
 const got = { post: notImplementedFail("got", "post") };
 //#endregion
+//#region src/node/internal_modules/package-surfaces.ts
+/**
+* Node internal members HMR reads and replaces while expiring package configuration:
+* `internal/modules/cjs/loader`'s `Module` caches and loaders, `internal/modules/package_json_reader`, and the
+* `modules` binding from `internal/bootstrap/realm`. The Worker's own `require` does not route through them, so
+* they keep Node's member names for replacement and refuse when called.
+* @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/internal_modules/package-surfaces
+*/
+const CJS_LOADER = "internal/modules/cjs/loader";
+/** `Module` with the static members HMR reads and replaces. */
+const Module = Object.assign(function Module() {
+	throw notAvailableError(CJS_LOADER, "Module");
+}, {
+	/** Empty: the Worker loader keeps its own resolution cache. */
+	_pathCache: Object.create(null),
+	_resolveFilename: notImplementedFail(CJS_LOADER, "Module._resolveFilename"),
+	_load: notImplementedFail(CJS_LOADER, "Module._load")
+});
+/** `internal/modules/package_json_reader` with the member HMR replaces. */
+const packageJsonReader = { getNearestParentPackageJSON: notImplementedFail("internal/modules/package_json_reader", "getNearestParentPackageJSON") };
+/** `internalBinding('modules')` with the members HMR replaces. */
+const modulesBinding = {
+	readPackageJSON: notImplementedFail("internalBinding(\"modules\")", "readPackageJSON"),
+	getPackageScopeConfig: notImplementedFail("internalBinding(\"modules\")", "getPackageScopeConfig"),
+	getPackageType: notImplementedFail("internalBinding(\"modules\")", "getPackageType")
+};
+/** `internal/bootstrap/realm`: only the `modules` binding is provided. */
+const realm = { 
+/**
+* Answer one internal binding.
+* @param name - Binding name.
+* @returns The `modules` binding.
+* @throws Error with `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` for any other binding.
+*/
+internalBinding(name) {
+	if (name === "modules") return modulesBinding;
+	throw notAvailableError("internal/bootstrap/realm", `internalBinding(${JSON.stringify(name)})`);
+} };
+//#endregion
+//#region src/node/external_packages/node-addon-require-builtin.ts
+/**
+* `node-addon-require-builtin` for the Worker. Without `--expose-internals`, the vendored Loader, app-boot, and HMR
+* read Node internal modules through this package's `requireBuiltin(id)`; the Worker answers the ids those callers
+* read with members that follow Node v24.18.0 and refuses every other id with Node's platform code.
+* @module @deepseek-ai/dsh-experimental-webworker-runtime/src/node/external_packages/node-addon-require-builtin
+*/
+var node_addon_require_builtin_exports = /* @__PURE__ */ __exportAll({ requireBuiltin: () => requireBuiltin });
+/** Mutable module objects: HMR replaces members on them and restores the originals. */
+const INTERNAL_MODULES = new Map([
+	["internal/modules/esm/loader", { getOrInitializeCascadedLoader: () => requireActiveModuleLoader().cascadedLoader() }],
+	["internal/modules/esm/module_map", {
+		LoadCache,
+		ResolveCache
+	}],
+	["internal/modules/cjs/loader", { Module }],
+	["internal/modules/package_json_reader", packageJsonReader],
+	["internal/bootstrap/realm", realm]
+]);
+/**
+* Answer one Node internal module.
+* @param moduleId - Node internal module id.
+* @returns The Worker's module object for that id.
+* @throws Error with `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` for an id the Worker does not provide.
+*/
+function requireBuiltin(moduleId) {
+	const module = INTERNAL_MODULES.get(moduleId);
+	if (module === void 0) throw notAvailableError("node-addon-require-builtin", `requireBuiltin(${JSON.stringify(moduleId)})`);
+	return module;
+}
+//#endregion
 //#region src/node/external_packages/pi-ai.ts
 /**
 * `@earendil-works/pi-ai` stub, including its `/providers/all` and `/api/*.lazy`
@@ -21945,6 +22469,7 @@ const REPLACED_EXTERNAL_PACKAGES = [
 	"node-pty",
 	"execa",
 	"got",
+	"node-addon-require-builtin",
 	"sharp",
 	"ws"
 ];
@@ -22013,6 +22538,7 @@ const EXTERNALS = {
 	"node-pty": () => node_pty_exports,
 	"execa": () => execa_exports,
 	"got": () => got_exports,
+	"node-addon-require-builtin": () => node_addon_require_builtin_exports,
 	"ws": () => ws_exports,
 	"@vscode/ripgrep": () => ripgrep_exports,
 	"@earendil-works/pi-ai": () => pi_ai_exports