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

package/lib/index.js

@@ -142,6 +142,122 @@ function parseInboundFrame(data) {
 	};
 }
 //#endregion
+//#region src/node/notImplementedFail.ts
+/** 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" });
+}
+/** 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");
+		}
+	};
+}
+//#endregion
 //#region src/module-system/posix-path.ts
 var posix_path_exports = /* @__PURE__ */ __exportAll({
 	SEP: () => "/",
@@ -306,8 +422,8 @@ function fileUrlToPath(url) {
 //#region src/image-layout.ts
 /**
 * Image layout contract shared by the packer and the worker host: the virtual
-* root, where the composed config and the manifest sit inside the image, and
-* the working directories every image carries empty. One definition, two
+* root, where the manifest sits inside the image, where lazy archives sit beside
+* it, and the working directories every image carries empty. One definition, two
 * consumers — the packer writes this layout, the worker host mounts it.
 */
 /** Default virtual root; the runtime mounts the image here unless told otherwise. */
@@ -318,12 +434,21 @@ const DEFAULT_ROOT = "/dsh";
 * there, so the extension is part of what a deployment serves.
 */
 const IMAGE_FILE_NAME = "vfs-image.tar.gz";
-/** Image path the composed profile is written to; the runtime's Loader reads it. */
-const IMAGE_CONFIG_PATH = "config/cordis.yml";
 /** Image path of the manifest the runtime reads before it wraps a single module. */
 const IMAGE_MANIFEST_PATH = "config/vfs-manifest.json";
+/**
+* Directory, relative to the base image URL, holding the lazy chunk archives:
+* `lazy/<sha256 of the archive>.tar.gz`, one page chunk each.
+*/
+const IMAGE_LAZY_DIRECTORY = "lazy";
 /** Home directory under the root; the process shim's `DSH_HOME`/`HOME` default. */
 const IMAGE_HOME_DIRECTORY = "home";
+/**
+* Config fields the Worker requires on Loader rows, by row id. The packer writes them into the image's home patch
+* (`home/cordis.patch.yml`) over each row's composed config: the Worker carries no Zstandard codec, so JSONL Session
+* logs stay plaintext.
+*/
+const PLATFORM_ENTRY_CONFIG = { "session-persistence-jsonl": { compression: "none" } };
 /** Working directories the host tree expects to exist, empty. */
 const IMAGE_EMPTY_DIRECTORIES = [
 	"home/",
@@ -361,10 +486,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
@@ -400,9 +526,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) {
@@ -434,9 +562,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) {
@@ -517,7 +658,7 @@ var WorkerModuleLoader = class {
 			}
 			return this.probe(join(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) {
@@ -556,12 +697,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(this.root, "node_modules", packageName);
-		if (!this.vfs.existsSync(join(packageDirectory, "package.json"))) return this.fail(`cannot resolve "${specifier}": ${packageDirectory}/package.json is not in the image`);
+		if (!this.vfs.existsSync(join(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(packageDirectory, target), specifier)
@@ -751,6 +892,7 @@ const MODULE_PROXIES = {
 	"got": "./node/external_packages/got.ts",
 	"@vscode/ripgrep": "./node/external_packages/ripgrep.ts",
 	"@earendil-works/pi-ai": "./node/external_packages/pi-ai.ts",
+	"node-addon-require-builtin": "./node/external_packages/node-addon-require-builtin.ts",
 	"ws": "./node/external_packages/ws.ts"
 };
 /** pi-ai subpaths (`/providers/all`, `/api/*.lazy`) share the one structural stub. */
@@ -773,6 +915,7 @@ const REPLACED_EXTERNAL_PACKAGES = [
 	"node-pty",
 	"execa",
 	"got",
+	"node-addon-require-builtin",
 	"sharp",
 	"ws"
 ];
@@ -1991,19 +2134,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.
 */
@@ -2022,8 +2167,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;
@@ -2417,6 +2562,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();
@@ -2465,7 +2612,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);
 		},
@@ -2497,11 +2647,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(resolve(path));
-			if (!this.files.has(target) && !this.directories.has(target)) fail("ENOENT", "access", target);
+			if (!this.existsSync(path)) fail("ENOENT", "access", normalize(resolve(path)));
 		}
 	};
 	/** @returns Absolute path with no trailing separator. */
@@ -2510,6 +2662,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(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(target));
+			this.deferred.set(target, {
+				size,
+				mode: DEFAULT_FILE_MODE,
+				mtimeMs,
+				archive: state
+			});
+			this.touchDirectory(dirname(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(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.
@@ -2517,6 +2764,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);
@@ -2531,7 +2779,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.
@@ -2542,11 +2790,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,
@@ -2716,12 +2970,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;
@@ -2761,7 +3019,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);
@@ -2791,6 +3049,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(target))) fail("ENOENT", "open", target);
 		const flag = options?.flag ?? "w";
@@ -2921,6 +3180,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);
@@ -2982,6 +3242,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.encode(data) : data;
 		if (existing === void 0) {
@@ -2998,6 +3259,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) {
@@ -3026,13 +3289,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(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;
@@ -3094,9 +3358,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(target))) fail("ENOENT", "link", target);
 		this.setFile(target, node);
 		this.touchDirectory(dirname(target));
@@ -3115,6 +3380,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);
@@ -3126,6 +3392,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);
@@ -3149,7 +3416,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(target));
 		this.publish({
@@ -3164,7 +3431,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(target));
 			this.publish({
@@ -3177,6 +3444,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);
@@ -3216,6 +3484,7 @@ var MemoryVfs = class {
 	seed(path, data, options = {}) {
 		const target = this.key(path);
 		this.seedDirectory(dirname(target));
+		this.deferred.delete(target);
 		this.setFile(target, {
 			bytes: typeof data === "string" ? encoder.encode(data) : data,
 			mtimeMs: options.mtimeMs ?? this.touch(target),
@@ -3234,7 +3503,7 @@ var MemoryVfs = class {
 		if (!this.directories.has(target)) {
 			const parent = dirname(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);
@@ -3259,7 +3528,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.
@@ -3327,6 +3596,72 @@ function requireActiveVfs() {
 	if (active === void 0) throw new Error("webworker vfs: no filesystem is mounted; the worker entry must call setActiveVfs before any node:fs access");
 	return active;
 }
+//#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$1(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$1(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$1(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$1(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;
@@ -3349,7 +3684,6 @@ async function readImage(image) {
 */
 function createWorkerHost(options) {
 	const root = options.root ?? "/dsh";
-	const configPath = options.configPath ?? join(root, "config/cordis.yml");
 	const port = options.port ?? 3080;
 	const tunnel = new TunnelServer({
 		port: requireGlobalPort(options.channel),
@@ -3363,7 +3697,7 @@ function createWorkerHost(options) {
 	const start = async () => {
 		try {
 			const home = join(root, IMAGE_HOME_DIRECTORY);
-			installProcessGlobal({
+			const processShim = installProcessGlobal({
 				cwd: root,
 				env: {
 					DSH_HOME: home,
@@ -3377,7 +3711,8 @@ function createWorkerHost(options) {
 			for (const directory of IMAGE_EMPTY_DIRECTORIES) mounted.seedDirectory(join(root, directory.replace(/\/$/, "")));
 			setActiveVfs(mounted);
 			vfs = mounted;
-			requireLoweredImage(mounted, options.manifestPath ?? join(root, "config/vfs-manifest.json"));
+			const manifest = readImageManifest(mounted, options.manifestPath ?? join(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({
@@ -3389,16 +3724,18 @@ function createWorkerHost(options) {
 			});
 			setActiveModuleLoader(loader);
 			modules = loader;
-			const require = loader.requireFrom(dirname(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(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",
@@ -3428,7 +3765,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),
@@ -3488,76 +3825,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`);
-}
-/**
-* 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(root, IMAGE_HOME_DIRECTORY, "profiles/preview");
+	return parseImageManifest(JSON.parse(vfs.readFileSync(path, "utf8")), path);
+}
+/**
+* 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(root, IMAGE_HOME_DIRECTORY);
+	const installAnchor = join(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(loaded.dir, "cordis.yml"), "[]\n");
 	const profile = {
-		name: "preview",
-		dir,
-		patchPath: join(dir, "cordis.patch.yml"),
-		installAnchor: join(dir, "package.json"),
+		name: loaded.name,
+		dir: loaded.dir,
+		patchPath: loaded.patchPath,
+		installAnchor,
 		cwd: root,
-		home: join(root, IMAGE_HOME_DIRECTORY),
-		startedBundles: [],
-		overlays: patches,
-		telemetryDisabledEnv: void 0
+		home,
+		startedBundles: loaded.layers.map((layer) => layer.packageName),
+		overlays: [],
+		telemetryDisabledEnv: env.DSH_TELEMETRY_DISABLED
 	};
-	vfs.seed(join(dir, "package.json"), "{\"private\":true,\"dsh\":{\"profile\":{\"bundles\":[]}}}\n");
-	vfs.seed(join(dir, "cordis.yml"), "[]\n");
-	if (!vfs.existsSync(profile.patchPath)) vfs.seed(profile.patchPath, yaml.dump([{ insert: rows }], { schema: include.entryListSchema }));
 	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
 	};
 }
 /**
@@ -3619,4 +3964,4 @@ function parsePreviewFixtureManifest(value) {
 	};
 }
 //#endregion
-export { API_PREFIX, DEFAULT_CONDITIONS, DEFAULT_ROOT, IMAGE_CONFIG_PATH, IMAGE_EMPTY_DIRECTORIES, IMAGE_FILE_NAME, IMAGE_HOME_DIRECTORY, IMAGE_MANIFEST_PATH, IMAGE_OVERLAY_DIRECTORIES, LOWERING_VERSION, MODULE_PROXIES, MODULE_PROXY_PREFIXES, MemoryVfs, PREVIEW_FIXTURE_MANIFEST_FILE, PREVIEW_FIXTURE_MANIFEST_VERSION, REPLACED_EXTERNAL_PACKAGES, SYNTHETIC_HOST, TunnelServer, WRAPPER_PARAMS, WorkerModuleLoader, createAlsRuntime, createSyntheticExchange, createWorkerHost, inflateImage, inflateImageStream, installProcessGlobal, loadVfsImage, loadVfsOverlay, lowerModuleSource, packTar, parseInboundFrame, parsePreviewFixtureManifest, parseTar, posix_path_exports as posixPath, requireActiveModuleLoader, requireActiveVfs, setActiveModuleLoader, setActiveVfs };
+export { API_PREFIX, DEFAULT_CONDITIONS, DEFAULT_ROOT, IMAGE_EMPTY_DIRECTORIES, IMAGE_FILE_NAME, IMAGE_HOME_DIRECTORY, IMAGE_LAZY_DIRECTORY, IMAGE_MANIFEST_PATH, IMAGE_OVERLAY_DIRECTORIES, LOWERING_VERSION, MODULE_PROXIES, MODULE_PROXY_PREFIXES, MemoryVfs, PLATFORM_ENTRY_CONFIG, PREVIEW_FIXTURE_MANIFEST_FILE, PREVIEW_FIXTURE_MANIFEST_VERSION, REPLACED_EXTERNAL_PACKAGES, SYNTHETIC_HOST, TunnelServer, WRAPPER_PARAMS, WorkerModuleLoader, createAlsRuntime, createSyntheticExchange, createWorkerHost, inflateImage, inflateImageStream, installProcessGlobal, loadVfsImage, loadVfsOverlay, lowerModuleSource, packTar, parseImageManifest, parseInboundFrame, parsePreviewFixtureManifest, parseTar, posix_path_exports as posixPath, requireActiveModuleLoader, requireActiveVfs, setActiveModuleLoader, setActiveVfs };