@deepseek-ai/dsh-app-boot 0.1.6-alpha.1 → 0.1.7-alpha.1

package/lib/index.js

@@ -1,20 +1,18 @@
 import { createRequire, isBuiltin } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { parseEnv } from "node:util";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import * as yaml from "js-yaml";
 import { Context, Service } from "@deepseek-ai/cordis";
-import Loader, { EntryGroup, EntryTree, isJsExpr } from "@deepseek-ai/cordis-plugin-loader";
-import { access, constants, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
+import Loader, { EntryGroup, EntryTree, ModuleLoader, isJsExpr } from "@deepseek-ai/cordis-plugin-loader";
+import { access, constants, readFile, realpath, rename, writeFile } from "node:fs/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import Group from "@deepseek-ai/cordis-plugin-group";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { createLaunchEnvironmentSnapshot } from "@deepseek-ai/dsh-launch-environment";
-import { watch } from "chokidar";
-import { withFileLock } from "@deepseek-ai/dsh-atomic-write";
-import { imports, resolve as resolve$1 } from "resolve.exports";
 import { getEnvironmentData, setEnvironmentData } from "node:worker_threads";
+import { imports } from "resolve.exports";
 //#region ../../../vendor/include/src/index.ts
 const JsExpr = new yaml.Type("tag:yaml.org,2002:js", {
 	kind: "scalar",
@@ -247,104 +245,8 @@ var Include = class extends EntryTree {
 	}
 };
 //#endregion
-//#region lib/types/watch-config.js
-/** Exact-path watching for live profile patch files outside Cordis module roots. */
-const registrations = /* @__PURE__ */ new WeakMap();
-async function findWatchRoot(filename) {
-	let root = dirname(filename);
-	let depth = 0;
-	while (true) try {
-		if (!(await stat(root)).isDirectory()) throw new Error(`config watch parent is not a directory: ${root}`);
-		const canonicalRoot = await realpath(root);
-		return {
-			filename: resolve(canonicalRoot, relative(root, filename)),
-			root: canonicalRoot,
-			depth
-		};
-	} catch (error) {
-		if (error.code !== "ENOENT") throw error;
-		const parent = dirname(root);
-		if (parent === root) throw error;
-		root = parent;
-		depth += 1;
-	}
-}
-/**
-* Watch one patch path, including missing parents, and serialize refresh callbacks.
-* @param ctx Context that owns watcher disposal and receives refresh failures.
-* @param filename Absolute patch-file path.
-* @param options Deployment watcher options inherited from the HMR configuration.
-* @param refresh Callback for additions, changes, and removals.
-* @returns A disposer that closes the watcher and drains its current refresh.
-* @throws When path resolution, watcher startup, or effect registration fails.
-*/
-async function watchConfig(ctx, filename, options, refresh) {
-	const target = await findWatchRoot(filename);
-	const paths = registrations.get(ctx) ?? /* @__PURE__ */ new Set();
-	registrations.set(ctx, paths);
-	if (paths.has(target.filename)) throw new Error(`config path already registered: ${filename}`);
-	const { cwd: _cwd, ignored: _ignored, ...watchOptions } = options;
-	const watcher = watch(target.root, {
-		...watchOptions,
-		depth: target.depth,
-		ignoreInitial: false
-	});
-	paths.add(target.filename);
-	const state = { dirty: false };
-	let running;
-	const onChange = (path) => {
-		const observed = resolve(path);
-		if (observed !== filename && observed !== target.filename) return;
-		state.dirty = true;
-		if (running) return;
-		running = (async () => {
-			while (state.dirty) {
-				state.dirty = false;
-				try {
-					await refresh();
-				} catch (reason) {
-					const error = reason instanceof Error ? reason : new Error(String(reason), { cause: reason });
-					ctx.logger.warn("config reload at %C failed", filename);
-					ctx.logger.warn(error);
-				}
-			}
-		})().finally(() => {
-			running = void 0;
-		});
-	};
-	watcher.on("add", onChange);
-	watcher.on("change", onChange);
-	watcher.on("unlink", onChange);
-	const ready = Promise.withResolvers();
-	let pending = true;
-	watcher.once("ready", () => {
-		pending = false;
-		ready.resolve();
-	});
-	watcher.on("error", (error) => {
-		if (pending) {
-			pending = false;
-			ready.reject(error);
-		} else ctx.logger.warn(error);
-	});
-	const dispose = async () => {
-		await watcher.close();
-		paths.delete(target.filename);
-		await running;
-	};
-	try {
-		await ready.promise;
-		return ctx.effect(() => dispose, "app-boot.watchConfig()");
-	} catch (error) {
-		await dispose();
-		throw error;
-	}
-}
-//#endregion
 //#region lib/types/profile-resolution/legacy-links.js
-/** Legacy profile-link inspection shared by the disk materializer and runtime resolver. */
-/** Profile-private package links projected into its pnpm-managed node_modules. */
-const PROFILE_MODULE_FALLBACK_DIR = ".dsh-module-fallback";
+/** Package directory canonicalization through the active runtime carrier's filesystem. */
 /**
 * Return whether the process reads application modules from pkg's virtual filesystem.
 * @returns whether pkg owns the module filesystem.
@@ -360,50 +262,6 @@ function isPackagedExecutable() {
 function realModuleDirectory(path) {
 	return isPackagedExecutable() ? realpathSync(path) : realpathSync.native(path);
 }
-/**
-* Resolve a link target without following the final path component.
-* @param path - candidate path whose parent is canonicalized.
-* @returns the canonical candidate, or undefined when its parent is absent.
-*/
-function canonicalLinkPath(path) {
-	try {
-		return join(realModuleDirectory(dirname(path)), basename(path));
-	} catch (error) {
-		/* v8 ignore next 2 -- a non-ENOENT realpath failure requires a host filesystem fault */
-		if (error.code === "ENOENT") return void 0;
-		/* v8 ignore next -- see the host-filesystem exception above */
-		throw error;
-	}
-}
-/**
-* Return whether a symlink or junction points at the same path as `target`.
-* @param link - symlink or junction to inspect.
-* @param target - expected target path.
-* @returns whether both paths identify the same entry.
-*/
-function symlinkPointsTo(link, target) {
-	const canonicalActual = canonicalLinkPath(resolve(dirname(link), readlinkSync(link)));
-	const canonicalTarget = canonicalLinkPath(resolve(target));
-	return canonicalActual !== void 0 && canonicalActual === canonicalTarget;
-}
-/**
-* Return whether an observed profile package must not claim local precedence.
-* @param profileDir - profile directory containing the package projection.
-* @param packageName - bare package name to inspect.
-* @returns whether the entry is a managed fallback link or disappeared during inspection.
-*/
-function isProfileModuleFallbackLink(profileDir, packageName) {
-	const link = join(profileDir, "node_modules", packageName);
-	const target = join(profileDir, PROFILE_MODULE_FALLBACK_DIR, "node_modules", packageName);
-	try {
-		return lstatSync(link).isSymbolicLink() && symlinkPointsTo(link, target);
-	} catch (error) {
-		/* v8 ignore next 2 -- a vanished candidate cannot claim local precedence */
-		if (error.code === "ENOENT") return true;
-		/* v8 ignore next -- non-ENOENT lstat/readlink failures require a host filesystem fault */
-		throw error;
-	}
-}
 //#endregion
 //#region lib/types/profile.js
 /**
@@ -415,19 +273,17 @@ function isProfileModuleFallbackLink(profileDir, packageName) {
 * `dsh.profile` with its ordered `bundles` list) and a `cordis.patch.yml`
 * (the user's own patch layer, applied after every bundle layer). Bundles are
 * npm packages whose manifest declares
-* `"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }`; the tree is
-* composed by applying each bundle's patch list in `dsh.profile.bundles` order over
-* an empty entry list, then the profile's own patches, then any launcher
-* layers (`--patch` files and flag-derived patches).
+* `"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }` (one file, or an
+* ordered list of files); the tree is composed by applying each bundle's patch
+* lists in `dsh.profile.bundles` order over an empty entry list, then the
+* profile's own patches, then any launcher layers (`--patch` files and
+* flag-derived patches).
 *
 * Module resolution is two-anchor by construction: a bundle name resolves
 * first from the dsh installation (the launcher's own package), then from the
 * profile directory. Pnpm-managed entries in the profile's `node_modules`
-* resolve first. Dsh-owned links add packages carried only by selected
-* bundles, while `$DSH_HOME/profiles/node_modules` supplies the installation
-* dependency closure through Node's ordinary parent-walk. Plain Node uses
-* symlinks for that shared fallback; packaged executables use ESM proxies so
-* external plugins retain the installation's module instances.
+* resolve first. The runtime resolution supplies packages carried by the
+* installation and selected bundles to Node's ESM and CommonJS resolvers.
 * @module @deepseek-ai/dsh-app-boot/profile
 */
 /** Directory under the Harness home holding every profile. */
@@ -435,6 +291,28 @@ const PROFILES_DIR = "profiles";
 /** The user patch layer inside a profile directory (hot-reloaded on long-lived surfaces). */
 const PROFILE_PATCH_FILENAME = "cordis.patch.yml";
 /**
+* The patch files a bundle declares, as written: one file for a string
+* `patch`, the listed files in order for an array.
+* @param bundle - the bundle's `dsh.bundle` declaration, as read from package.json.
+* @returns the package-relative patch file paths in application order.
+* @throws {Error} when `patch` is neither a string nor a list of strings.
+*/
+function bundlePatchFiles(bundle) {
+	const declared = typeof bundle.patch === "string" ? [bundle.patch] : bundle.patch;
+	if (!Array.isArray(declared) || !declared.every((file) => typeof file === "string")) throw new Error("dsh.bundle.patch must be a file path or a list of file paths");
+	return declared;
+}
+/**
+* Resolve a bundle declaration to its ordered absolute patch files.
+* @param packageDir - absolute directory of the bundle package.
+* @param bundle - the bundle's `dsh.bundle` declaration, as read from package.json.
+* @returns the absolute patch file paths in application order.
+* @throws {Error} when `patch` is neither a string nor a list of strings.
+*/
+function bundlePatchPaths(packageDir, bundle) {
+	return bundlePatchFiles(bundle).map((file) => join(packageDir, file));
+}
+/**
 * Resolve a profile's directory under the Harness home.
 * @param name - the profile name (`dsh --profile <name>`).
 * @param home - the Harness home; defaults to {@link resolveDshHome}.
@@ -446,26 +324,11 @@ function resolveProfileDir(name, home = resolveDshHome()) {
 }
 /** The shipped profile templates auto-initialized on first use, by name. */
 const PROFILE_TEMPLATES = {
-	acp: {
-		bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-acp-app"],
-		patchReload: "startup"
-	},
-	web: {
-		bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app"],
-		patchReload: "live"
-	},
-	headless: {
-		bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-headless"],
-		patchReload: "startup"
-	},
-	sdk: {
-		bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-sdk-app"],
-		patchReload: "startup"
-	},
-	"sdk-minimal": {
-		bundles: ["@deepseek-ai/dsh-sdk-minimal"],
-		patchReload: "startup"
-	}
+	acp: { bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-acp-app"] },
+	web: { bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app"] },
+	headless: { bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-headless"] },
+	sdk: { bundles: ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-sdk-app"] },
+	"sdk-minimal": { bundles: ["@deepseek-ai/dsh-sdk-minimal"] }
 };
 /** Installation-owned bundle tuples normalized to the shipped template. */
 const INSTALLATION_OWNED_PROFILE_TUPLES = { headless: [
@@ -475,8 +338,13 @@ const INSTALLATION_OWNED_PROFILE_TUPLES = { headless: [
 ] };
 /** The bundle list a `dsh plugin` init uses for a name with no shipped template. */
 const DEFAULT_PROFILE_BUNDLES = ["@deepseek-ai/dsh-base"];
-/** Custom profiles retain the historical live patch-file behavior. */
-const DEFAULT_PROFILE_PATCH_RELOAD = "live";
+/**
+* The bundles the dsh installation ships for a person to switch on: each a
+* runtime dependency of the installation that declares `dsh.bundle.patch`,
+* selected by no shipped template, and offered switched off by the plugin
+* manager ([rationale](../../../../.agents/notes/implemented/process/2026-09-15-shipped-optional-bundles.md)).
+*/
+const OPTIONAL_BUNDLES = ["@deepseek-ai/dsh-experimental-voice-input-bundle", "@deepseek-ai/dsh-experimental-agent-team-profile"];
 const PROFILE_PATCH_TEMPLATE = `# Your patch layer for this dsh profile, applied after every bundle layer:
 # a top-level YAML array of loader patch entries (id-targeted config
 # overrides, disables, and insert lists; \`!!js\` expressions allowed).
@@ -494,9 +362,8 @@ autoInstallPeers: false
 * so re-running is a no-op on an initialized profile.
 * @param dir - the profile directory from {@link resolveProfileDir}.
 * @param bundles - the initial `dsh.profile.bundles` layer list.
-* @param patchReload - user patch-file lifecycle; custom profiles default to live reload.
 */
-function initProfile(dir, bundles, patchReload = DEFAULT_PROFILE_PATCH_RELOAD) {
+function initProfile(dir, bundles) {
 	mkdirSync(dir, { recursive: true });
 	const manifestPath = join(dir, "package.json");
 	if (!existsSync(manifestPath)) {
@@ -504,10 +371,7 @@ function initProfile(dir, bundles, patchReload = DEFAULT_PROFILE_PATCH_RELOAD) {
 			name: `dsh-profile-${basename(dir)}`,
 			private: true,
 			dependencies: {},
-			dsh: { profile: {
-				bundles: [...bundles],
-				patchReload
-			} }
+			dsh: { profile: { bundles: [...bundles] } }
 		};
 		writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2) + "\n");
 	}
@@ -516,188 +380,108 @@ function initProfile(dir, bundles, patchReload = DEFAULT_PROFILE_PATCH_RELOAD) {
 	const workspacePath = join(dir, "pnpm-workspace.yaml");
 	if (!existsSync(workspacePath)) writeFileSync(workspacePath, PROFILE_PNPM_WORKSPACE);
 }
-function readModuleProxyRecord(link) {
-	try {
-		return JSON.parse(readFileSync(join(link, "package.json"), "utf8"));
-	} catch {
-		return;
-	}
+/** Directory where the link backend of the dsh 0.1.5 releases projected bundle-carried packages into a profile. */
+const LINK_PROJECTION_DIR = ".dsh-module-fallback";
+/**
+* Remove the package projections a link-backend launch left in a profile.
+* Only symlinks under the profile's `node_modules` whose target lies inside
+* `<profile>/.dsh-module-fallback/node_modules` are unlinked, then that directory is removed;
+* pnpm-installed packages and every other symlink stay. A profile without the directory is untouched.
+* @param dir - the profile directory.
+*/
+function removeLinkProjections(dir) {
+	const owned = join(dir, LINK_PROJECTION_DIR);
+	if (!existsSync(owned)) return;
+	const ownedModules = join(owned, "node_modules");
+	for (const link of symlinksUnder(join(dir, "node_modules"))) if (pointsInto(link, ownedModules)) unlinkSync(link);
+	rmSync(owned, {
+		recursive: true,
+		force: true
+	});
 }
-/** Ensure `link` is a symlink to `target`, replacing a wrong link or a dsh-managed packaged proxy. */
-function ensureSymlink(link, target) {
-	let stat;
-	try {
-		stat = lstatSync(link);
-	} catch {
-		stat = void 0;
-	}
-	if (stat !== void 0) {
-		if (!stat.isSymbolicLink()) {
-			if ((stat.isDirectory() ? readModuleProxyRecord(link) : void 0)?.dsh?.moduleFallback?.targets === void 0) throw new Error(`dsh: ${link} exists and is not a symlink or dsh-managed module proxy; remove it so dsh can manage the installation fallback`);
-			rmSync(link, { recursive: true });
-			stat = void 0;
-		}
-		if (stat !== void 0) {
-			if (symlinkPointsTo(link, target)) return;
-			unlinkSync(link);
+/** Top-level and scoped entries under a node_modules directory that are symlinks or junctions. */
+function symlinksUnder(modules) {
+	const links = [];
+	if (!existsSync(modules)) return links;
+	for (const entry of readdirSync(modules, { withFileTypes: true })) {
+		const path = join(modules, entry.name);
+		if (entry.isSymbolicLink()) links.push(path);
+		else if (entry.name.startsWith("@") && entry.isDirectory()) {
+			for (const child of readdirSync(path, { withFileTypes: true })) if (child.isSymbolicLink()) links.push(join(path, child.name));
 		}
 	}
-	try {
-		symlinkSync(target, link, "junction");
-	} catch (error) {
-		/* v8 ignore next 4 */
-		if (error.code !== "EEXIST" || !lstatSync(link).isSymbolicLink() || !symlinkPointsTo(link, target)) throw error;
-	}
-}
-/** Add one profile-owned fallback link without replacing a pnpm-managed entry. */
-function ensureProfileSymlink(link, target) {
-	try {
-		lstatSync(link);
-		return;
-	} catch (error) {
-		/* v8 ignore next -- a non-ENOENT lstat failure requires a host filesystem fault */
-		if (error.code !== "ENOENT") throw error;
-	}
-	ensureSymlink(link, target);
-}
-/** Package names represented by owned symlinks below one fallback node_modules. */
-function ownedPackageNames(modulesDir) {
-	return readdirSync(modulesDir, { withFileTypes: true }).flatMap((entry) => {
-		if (entry.name.startsWith("@") && entry.isDirectory()) return readdirSync(join(modulesDir, entry.name), { withFileTypes: true }).filter((child) => child.isSymbolicLink()).map((child) => `${entry.name}/${child.name}`);
-		return entry.isSymbolicLink() ? [entry.name] : [];
-	});
+	return links;
 }
-/** Remove an obsolete owned target and its profile projection when still connected. */
-function removeProfileSymlink(profileModulesDir, ownedModulesDir, packageName) {
-	const ownedLink = join(ownedModulesDir, packageName);
-	const profileLink = join(profileModulesDir, packageName);
-	try {
-		if (lstatSync(profileLink).isSymbolicLink() && symlinkPointsTo(profileLink, ownedLink)) unlinkSync(profileLink);
-	} catch (error) {
-		/* v8 ignore next -- a non-ENOENT lstat failure requires a host filesystem fault */
-		if (error.code !== "ENOENT") throw error;
-	}
+/**
+* Active profile `node_modules` entries linked outside the shared profiles tree and the active profile.
+* Missing targets and files are not linked roots; invalid link chains retain Node's diagnostic.
+*/
+function linkedProfileRoots(profile, profilesDir) {
+	const modules = join(profile.dir, "node_modules");
+	const links = symlinksUnder(modules);
+	if (links.length === 0) return [];
+	let tree;
 	try {
-		unlinkSync(ownedLink);
+		tree = realModuleDirectory(profilesDir) + sep;
 	} catch (error) {
-		/* v8 ignore next -- concurrent identical cleanup may remove the link first */
 		if (error.code !== "ENOENT") throw error;
+		tree = resolve(profilesDir) + sep;
 	}
-}
-/** Resolve one available explicit package export under Node ESM import conditions. */
-function packageEntryFromPackage(packageName, packageDir, declared, subpath) {
-	let candidates;
-	try {
-		candidates = resolve$1({
-			name: packageName,
-			exports: declared
-		}, subpath);
-	} catch (error) {
-		if (error.message.startsWith("No known conditions for ")) return void 0;
-		const specifier = subpath === "." ? packageName : packageName + subpath.slice(1);
-		throw new Error(`dsh: cannot resolve ESM export ${specifier} from installed package ${packageName}`, { cause: error });
-	}
-	for (const candidate of candidates ?? []) {
-		const target = candidate;
-		const entry = resolve(packageDir, target);
-		const relativeEntry = relative(packageDir, entry);
-		if (!target.startsWith("./") || /^\.\.(?:[\\/]|$)/u.test(relativeEntry)) throw new Error(`dsh: installed package ${packageName} export ${subpath} resolves outside its package: ${target}`);
-		if (existsSync(entry) && statSync(entry).isFile()) return pathToFileURL(entry).href;
-	}
-}
-/** Resolve every explicit ESM runtime export that an out-of-tree plugin can import. */
-function packageProxySource(packageName, packageDir) {
-	const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
-	if (typeof manifest.version !== "string" || manifest.version.length === 0) throw new Error(`dsh: installed package ${packageName} must declare a non-empty version`);
-	const declared = manifest.exports;
-	if (declared === void 0) {
-		const main = typeof manifest.main === "string" && manifest.main.length > 0 ? manifest.main : void 0;
-		const entry = join(packageDir, main ?? "index");
+	const excludedTrees = [tree, realModuleDirectory(profile.dir) + sep];
+	const roots = [];
+	for (const linkPath of links) {
+		let realPath;
 		try {
-			const resolved = createRequire(join(packageDir, "package.json")).resolve(entry);
-			return {
-				version: manifest.version,
-				targets: { ".": pathToFileURL(resolved).href }
-			};
+			realPath = realModuleDirectory(linkPath);
 		} catch (error) {
-			if (main === void 0 && (manifest.bin !== void 0 || manifest.types !== void 0 || manifest.typings !== void 0)) return {
-				version: manifest.version,
-				targets: {}
-			};
-			throw new Error(`dsh: installed package ${packageName} main entry is missing at ${entry}`, { cause: error });
+			if (error.code !== "ENOENT") throw error;
+			continue;
 		}
+		if (excludedTrees.some((prefix) => realPath + sep === prefix || realPath.startsWith(prefix)) || !statSync(realPath).isDirectory()) continue;
+		roots.push({
+			name: relative(modules, linkPath).split(sep).join("/"),
+			realPath
+		});
 	}
-	const subpaths = declared !== null && typeof declared === "object" && !Array.isArray(declared) && Object.keys(declared).some((key) => key.startsWith(".")) ? Object.keys(declared).filter((key) => key === "." || key.startsWith("./") && !key.includes("*") && !key.endsWith("/") && key !== "./package.json") : ["."];
-	const targets = {};
-	for (const subpath of subpaths) {
-		const target = packageEntryFromPackage(packageName, packageDir, declared, subpath);
-		if (target !== void 0) targets[subpath] = target;
-	}
-	return {
-		version: manifest.version,
-		targets
-	};
+	return roots.sort((left, right) => left.name.localeCompare(right.name));
 }
-/**
-* Materialize a real package proxy whose exports retain pkg's virtual module
-* URL. Files outside the executable cannot traverse a symlink into
-* `/snapshot`, while an ESM re-export can import that URL and preserves the
-* executable's single module instance for out-of-tree plugin peers.
-*/
-function ensureModuleProxy(link, packageName, version, targets) {
-	const manifest = {
-		name: packageName,
-		version,
-		private: true,
-		type: "module",
-		exports: Object.fromEntries(Object.keys(targets).map((subpath, index) => [subpath, `./entry-${index}.js`])),
-		dsh: { moduleFallback: { targets } }
-	};
-	let stat;
+/** Whether a symlink's target directory is `root` or lies below it. */
+function pointsInto(link, root) {
 	try {
-		stat = lstatSync(link);
-	} catch {
-		stat = void 0;
-	}
-	if (stat?.isSymbolicLink()) {
-		unlinkSync(link);
-		stat = void 0;
-	}
-	if (stat !== void 0) {
-		const existing = readModuleProxyRecord(link);
-		if (existing?.dsh?.moduleFallback?.targets === void 0) throw new Error(`dsh: ${link} exists and is not a dsh-managed module proxy; remove it so dsh can manage the installation fallback`);
-		if (existing.version === version && JSON.stringify(existing.dsh.moduleFallback.targets) === JSON.stringify(targets) && Object.keys(targets).every((_, index) => existsSync(join(link, `entry-${index}.js`)))) return;
-		rmSync(link, { recursive: true });
-	}
-	mkdirSync(link, { recursive: true });
-	writeFileSync(join(link, "package.json"), JSON.stringify(manifest, void 0, 2) + "\n");
-	for (const [index, target] of Object.values(targets).entries()) {
-		const specifier = JSON.stringify(target);
-		writeFileSync(join(link, `entry-${index}.js`), `export * from ${specifier}\nimport * as target from ${specifier}\nexport default target.default\n`);
+		const target = resolve(dirname(link), readlinkSync(link));
+		const parent = realpathSync.native(dirname(target));
+		const rootPath = realpathSync.native(root);
+		return parent === rootPath || parent.startsWith(rootPath + sep);
+	} catch (error) {
+		/* v8 ignore next 2 -- a non-ENOENT realpath failure requires a host filesystem fault */
+		if (error.code === "ENOENT") return false;
+		/* v8 ignore next -- see the host-filesystem exception above */
+		throw error;
 	}
 }
-/** Read one package manifest used while traversing a module-fallback dependency graph. */
-function readModuleFallbackManifest(anchor) {
+/** Read one package manifest while traversing a dependency graph. */
+function readPackageManifest(anchor) {
 	return JSON.parse(readFileSync(anchor, "utf8"));
 }
 /** Return dependency names that may be imported by a loader-visible plugin. */
 function profileDependencyNames(manifest) {
 	return [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.peerDependencies ?? {})];
 }
-/** Resolve the installation generation that every profile must find through the fallback directory. */
-function resolveModuleFallbackEntries(installAnchor, materialize = true) {
-	const appManifest = readModuleFallbackManifest(installAnchor);
+/** Resolve the installation packages that the runtime resolver supplies to every profile. */
+function collectInstallationScopePackages(installAnchor, skippedBundles) {
+	const canonicalAnchor = join(realModuleDirectory(dirname(installAnchor)), basename(installAnchor));
+	const appManifest = readPackageManifest(canonicalAnchor);
 	const links = /* @__PURE__ */ new Map();
 	const declarers = /* @__PURE__ */ new Map();
 	const versions = /* @__PURE__ */ new Map();
 	/* v8 ignore next -- a real app manifest always declares its name */
 	if (appManifest.name !== void 0) {
 		links.set(appManifest.name, dirname(installAnchor));
-		declarers.set(appManifest.name, installAnchor);
+		declarers.set(appManifest.name, canonicalAnchor);
 		versions.set(appManifest.name, appManifest.version);
 	}
 	const queue = [{
-		anchor: installAnchor,
+		anchor: canonicalAnchor,
 		manifest: appManifest
 	}];
 	for (let next = queue.shift(); next !== void 0; next = queue.shift())
@@ -706,10 +490,16 @@ function resolveModuleFallbackEntries(installAnchor, materialize = true) {
 		if (links.has(dep)) continue;
 		const dir = packageDirFromAnchor(next.anchor, dep);
 		if (dir === void 0) continue;
+		const manifestPath = join(realModuleDirectory(dir), "package.json");
+		let manifest;
+		try {
+			manifest = skippedBundles.has(dep) ? readProfileManifest("dsh", dir) : readPackageManifest(manifestPath);
+		} catch (error) {
+			if (!skippedBundles.has(dep)) throw error;
+			continue;
+		}
 		links.set(dep, dir);
 		declarers.set(dep, next.anchor);
-		const manifestPath = join(dir, "package.json");
-		const manifest = readModuleFallbackManifest(manifestPath);
 		versions.set(dep, manifest.version);
 		queue.push({
 			anchor: manifestPath,
@@ -717,72 +507,32 @@ function resolveModuleFallbackEntries(installAnchor, materialize = true) {
 		});
 	}
 	return {
-		entries: !materialize ? [] : !isPackagedExecutable() ? [...links].map(([packageName, packageDir]) => ({
-			kind: "symlink",
-			packageName,
-			packageDir
-		})) : [...links].flatMap(([packageName, packageDir]) => {
-			const source = packageProxySource(packageName, packageDir);
-			return Object.keys(source.targets).length === 0 ? [] : [{
-				kind: "proxy",
-				packageName,
-				version: source.version,
-				targets: source.targets
-			}];
-		}),
 		packageNames: new Set(links.keys()),
 		packageDirs: links,
 		declarers,
 		versions
 	};
 }
-/** Return whether one existing fallback entry already matches its resolved installation generation. */
-function moduleFallbackEntryCurrent(modulesDir, entry) {
-	const link = join(modulesDir, entry.packageName);
-	try {
-		const stat = lstatSync(link);
-		if (entry.kind === "symlink") return stat.isSymbolicLink() && readlinkSync(link) === entry.packageDir;
-		if (!stat.isDirectory()) return false;
-		const existing = readModuleProxyRecord(link);
-		return existing?.version === entry.version && JSON.stringify(existing.dsh?.moduleFallback?.targets) === JSON.stringify(entry.targets) && Object.keys(entry.targets).every((_, index) => existsSync(join(link, `entry-${index}.js`)));
-	} catch {
-		return false;
-	}
-}
-/** Return whether every required fallback entry is already ready for this installation. */
-function moduleFallbackCurrent(modulesDir, entries) {
-	return entries.every((entry) => moduleFallbackEntryCurrent(modulesDir, entry));
-}
 /**
-* Maintain module fallbacks for one profile launch. The shared
-* `$DSH_HOME/profiles/node_modules` mirrors the dsh installation dependency
-* closure. Plain Node writes symlinks; a packaged executable writes ESM
-* proxies under a cross-process lock because operating-system links cannot
-* enter pkg's virtual filesystem. Missing packages carried only by selected
-* bundles are linked through a profile-owned directory into that profile's
-* `node_modules`; pnpm-managed entries remain authoritative, and another
-* profile's links cannot change its resolution.
+* Compute the runtime resolution without writing module-resolution files.
 * @param options - installation anchor, optional loaded profile, and Harness home.
-* @returns the computed fallback generation after optional materialization.
+* @returns the complete immutable runtime resolution.
 */
-async function healProfilesModuleFallback(options) {
-	const { installAnchor, profile, home = resolveDshHome(), materialize = true } = options;
+async function createRuntimeResolution(options) {
+	const { installAnchor, profile, home = resolveDshHome() } = options;
 	const profilesDir = join(home, PROFILES_DIR);
-	const modulesDir = join(profilesDir, "node_modules");
-	if (materialize) mkdirSync(modulesDir, { recursive: true });
-	const { entries, packageNames, packageDirs, declarers, versions } = resolveModuleFallbackEntries(installAnchor, materialize);
-	if (materialize && !moduleFallbackCurrent(modulesDir, entries)) await withFileLock(modulesDir, () => {
-		if (!moduleFallbackCurrent(modulesDir, entries)) healProfilesModuleFallbackLocked(entries, modulesDir);
-		return Promise.resolve();
-	});
+	const manifest = readOptionalProfileManifest(profile);
+	const { packageNames, packageDirs, declarers, versions } = collectInstallationScopePackages(installAnchor, skippedProfileBundles(profile, manifest));
 	const profileDeclarers = /* @__PURE__ */ new Map();
 	const profileVersions = /* @__PURE__ */ new Map();
-	const localPackageNames = profile === void 0 ? [] : installedProfilePackageNames(profile);
-	const profilePackages = profile === void 0 ? /* @__PURE__ */ new Map() : healProfileModuleFallback(profile, packageNames, materialize, profileDeclarers, profileVersions);
-	return Object.freeze({
+	const localPackageNames = profile === void 0 ? [] : installedProfilePackageNames(profile, manifest);
+	const profilePackages = profile === void 0 ? /* @__PURE__ */ new Map() : collectProfileScopePackages(profile, packageNames, profileDeclarers, profileVersions);
+	const linkedRoots = profile === void 0 ? [] : linkedProfileRoots(profile, profilesDir);
+	return await Promise.resolve(Object.freeze({
 		profilesDir,
 		profileDir: profile?.dir,
 		localPackageNames: Object.freeze(localPackageNames),
+		linkedRoots: Object.freeze(linkedRoots.map((root) => Object.freeze(root))),
 		entries: Object.freeze([...[...packageDirs].map(([name, packageDir]) => Object.freeze({
 			name,
 			packageDir,
@@ -796,49 +546,41 @@ async function healProfilesModuleFallback(options) {
 			declarer: profileDeclarers.get(name),
 			scope: "profile"
 		}))])
-	});
+	}));
 }
-/** Return installed direct dependencies that Node resolves before profile fallback. */
-function installedProfilePackageNames(profile) {
-	let manifest;
+/** Synthetic profiles used by direct callers may have no on-disk manifest. */
+function readOptionalProfileManifest(profile) {
+	if (profile === void 0) return void 0;
 	try {
-		manifest = readModuleFallbackManifest(join(profile.dir, "package.json"));
+		return readPackageManifest(join(profile.dir, "package.json"));
 	} catch (error) {
-		if (error.code === "ENOENT") return [];
+		if (error.code === "ENOENT") return void 0;
 		throw error;
 	}
-	return profileDependencyNames(manifest).filter((name) => {
-		if (!existsSync(join(join(profile.dir, "node_modules", name), "package.json"))) return false;
-		return !isProfileModuleFallbackLink(profile.dir, name);
-	});
 }
 /**
-* Compute a profile resolution generation without materializing links or proxies.
-* @param options - installation anchor, profile, and optional Harness home.
-* @returns the complete immutable generation.
+* Identify selected bundles that did not produce a loaded layer.
+* @param profile - loaded profile, when present.
+* @param manifest - its parsed manifest, when present.
+* @returns selected bundle names missing from the loaded layers, for resolution and diagnostics.
 */
-function createProfileResolutionGeneration(options) {
-	return healProfilesModuleFallback({
-		...options,
-		materialize: false
-	});
+function skippedProfileBundles(profile, manifest) {
+	const selected = manifest?.dsh?.profile?.bundles ?? [];
+	const loaded = new Set(profile?.layers.map((layer) => layer.packageName));
+	return new Set(selected.filter((name) => !loaded.has(name)));
 }
-/** Heal one module-fallback generation while the cross-process writer lock is held. */
-function healProfilesModuleFallbackLocked(entries, modulesDir) {
-	for (const entry of entries) {
-		const link = join(modulesDir, entry.packageName);
-		mkdirSync(dirname(link), { recursive: true });
-		if (entry.kind === "proxy") ensureModuleProxy(link, entry.packageName, entry.version, entry.targets);
-		else ensureSymlink(link, entry.packageDir);
-	}
+/** Return installed direct dependencies that Node resolves before profile fallback. */
+function installedProfilePackageNames(profile, manifest) {
+	if (manifest === void 0) return [];
+	return profileDependencyNames(manifest).filter((name) => existsSync(join(profile.dir, "node_modules", name, "package.json")));
 }
 /** Collect the first resolvable package directory for each dependency name. */
-function dependencyClosure(anchors, reserved, exclude, declarers, versions) {
+function dependencyClosure(anchors, reserved, declarers, versions) {
 	const links = /* @__PURE__ */ new Map();
 	const visited = new Set(reserved);
 	for (const anchor of anchors) {
 		const canonicalAnchor = join(realModuleDirectory(dirname(anchor)), basename(anchor));
-		const manifest = readModuleFallbackManifest(canonicalAnchor);
+		const manifest = readPackageManifest(canonicalAnchor);
 		/* v8 ignore next -- an installable package manifest always declares its name */
 		if (manifest.name === void 0) continue;
 		if (!visited.has(manifest.name)) {
@@ -855,13 +597,13 @@ function dependencyClosure(anchors, reserved, exclude, declarers, versions) {
  /* v8 ignore next -- an installable package manifest always declares dependencies or peers */
 		for (const dep of profileDependencyNames(next.manifest)) {
 			if (visited.has(dep)) continue;
-			const dir = packageDirFromAnchor(next.anchor, dep, exclude);
+			const dir = packageDirFromAnchor(next.anchor, dep);
 			if (dir === void 0) continue;
 			visited.add(dep);
 			links.set(dep, dir);
 			declarers?.set(dep, next.anchor);
-			const manifestPath = join(dir, "package.json");
-			const dependencyManifest = readModuleFallbackManifest(manifestPath);
+			const manifestPath = join(realModuleDirectory(dir), "package.json");
+			const dependencyManifest = readPackageManifest(manifestPath);
 			versions?.set(dep, dependencyManifest.version);
 			queue.push({
 				anchor: manifestPath,
@@ -871,37 +613,10 @@ function dependencyClosure(anchors, reserved, exclude, declarers, versions) {
 	}
 	return links;
 }
-/** Reconcile packages carried only by selected bundles into one profile. */
-function healProfileModuleFallback(profile, installationPackageNames, materialize = true, declarers, versions) {
-	const profileModulesDir = join(profile.dir, "node_modules");
-	const ownedModulesDir = join(profile.dir, PROFILE_MODULE_FALLBACK_DIR, "node_modules");
-	if (materialize) {
-		mkdirSync(profileModulesDir, { recursive: true });
-		mkdirSync(ownedModulesDir, { recursive: true });
-	}
-	const bundleLinks = dependencyClosure(profile.layers.filter((layer) => !installationPackageNames.has(layer.packageName)).map((layer) => join(layer.packageDir, "package.json")), installationPackageNames, (candidate, packageName) => {
-		const profileLink = join(profileModulesDir, packageName);
-		if (canonicalLinkPath(candidate) !== canonicalLinkPath(profileLink)) return false;
-		try {
-			return lstatSync(profileLink).isSymbolicLink() && symlinkPointsTo(profileLink, join(ownedModulesDir, packageName));
-		} catch (error) {
-			/* v8 ignore next 2 -- a non-ENOENT lstat failure requires a host filesystem fault */
-			if (error.code === "ENOENT") return true;
-			/* v8 ignore next -- see the host-filesystem exception above */
-			throw error;
-		}
-	}, declarers, versions);
+/** Collect packages carried by the profile's selected bundles that the installation does not supply. */
+function collectProfileScopePackages(profile, installationPackageNames, declarers, versions) {
+	const bundleLinks = dependencyClosure(profile.layers.filter((layer) => !installationPackageNames.has(layer.packageName)).map((layer) => join(layer.packageDir, "package.json")), installationPackageNames, declarers, versions);
 	for (const layer of profile.layers) bundleLinks.delete(layer.packageName);
-	if (!materialize) return bundleLinks;
-	for (const packageName of ownedPackageNames(ownedModulesDir)) if (!bundleLinks.has(packageName)) removeProfileSymlink(profileModulesDir, ownedModulesDir, packageName);
-	for (const [packageName, target] of bundleLinks) {
-		const ownedLink = join(ownedModulesDir, packageName);
-		mkdirSync(dirname(ownedLink), { recursive: true });
-		ensureSymlink(ownedLink, target);
-		const profileLink = join(profileModulesDir, packageName);
-		mkdirSync(dirname(profileLink), { recursive: true });
-		ensureProfileSymlink(profileLink, ownedLink);
-	}
 	return bundleLinks;
 }
 /**
@@ -936,27 +651,21 @@ function sameBundles(left, right) {
 }
 /**
 * Normalize an exact installation-owned bundle tuple to its shipped template,
-* or add the shipped reload default to an exact current tuple. A changed value
-* is written back during profile loading while every other manifest field is
-* preserved; any other bundle list is user-owned and remains untouched.
+* preserving all other manifest fields. Other bundle lists remain untouched.
 */
 function normalizeShippedProfile(name, dir, manifest) {
 	const installationOwned = INSTALLATION_OWNED_PROFILE_TUPLES[name];
 	const template = PROFILE_TEMPLATES[name];
 	const bundles = manifest.dsh?.profile?.bundles;
 	if (template === void 0 || bundles === void 0) return manifest;
-	const isRetiredTuple = installationOwned !== void 0 && sameBundles(bundles, installationOwned);
-	const isCurrentTuple = sameBundles(bundles, template.bundles);
-	const needsReloadDefault = manifest.dsh?.profile?.patchReload === void 0 && isCurrentTuple;
-	if (!isRetiredTuple && !needsReloadDefault) return manifest;
+	if (!(installationOwned !== void 0 && sameBundles(bundles, installationOwned))) return manifest;
 	const normalized = {
 		...manifest,
 		dsh: {
 			...manifest.dsh,
 			profile: {
 				...manifest.dsh?.profile,
-				bundles: [...template.bundles],
-				patchReload: manifest.dsh?.profile?.patchReload ?? template.patchReload
+				bundles: [...template.bundles]
 			}
 		}
 	};
@@ -971,11 +680,11 @@ function normalizeShippedProfile(name, dir, manifest) {
 * matches what the Loader would import from the same anchor, and
 * `existsSync` follows the symlinks pnpm's isolated layout uses.
 */
-function packageDirFromAnchor(anchor, packageName, exclude = () => false) {
+function packageDirFromAnchor(anchor, packageName) {
 	/* v8 ignore next */
 	for (const searchPath of createRequire(anchor).resolve.paths(packageName) ?? []) {
 		const candidate = join(searchPath, packageName);
-		if (existsSync(join(candidate, "package.json")) && !exclude(candidate, packageName)) return candidate;
+		if (existsSync(join(candidate, "package.json"))) return candidate;
 	}
 }
 /**
@@ -1001,30 +710,31 @@ function resolveBundleDir(binName, packageName, installAnchor, profileDir) {
 * Load an already initialized profile directory without resolving it through
 * the shared Harness home. This is used by application-owned profiles whose
 * package project and lifecycle belong to that application.
+* Unreadable bundles are reported on stderr and skipped without changing the manifest.
 * @param binName - the diagnostic prefix on thrown errors.
 * @param dir - absolute profile package directory.
 * @param installAnchor - absolute path of the owning dsh app's package.json.
 * @param options - `userLayer: false` skips reading `cordis.patch.yml`.
-* @returns the resolved bundle layers and optional user patch layer.
+* @returns the successfully loaded bundle layers and optional user patch layer.
 */
 function loadProfileDirectory(binName, dir, installAnchor, options = {}) {
-	const manifest = readProfileManifest(binName, dir);
-	const bundles = manifest.dsh?.profile?.bundles ?? [];
-	const rawPatchReload = manifest.dsh?.profile?.patchReload;
-	if (rawPatchReload !== void 0 && rawPatchReload !== "live" && rawPatchReload !== "startup") throw new Error(`${binName}: profile manifest ${join(dir, "package.json")} dsh.profile.patchReload must be "live" or "startup"`);
-	const patchReload = rawPatchReload ?? "live";
-	const layers = bundles.map((packageName) => {
+	const bundles = readProfileManifest(binName, dir).dsh?.profile?.bundles ?? [];
+	const layers = [];
+	for (const packageName of bundles) try {
 		const packageDir = resolveBundleDir(binName, packageName, installAnchor, dir);
-		const declared = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")).dsh?.bundle?.patch;
-		if (declared === void 0) throw new Error(`${binName}: profile bundle ${JSON.stringify(packageName)} declares no dsh.bundle in its package.json`);
-		const patchPath = join(packageDir, declared);
-		return {
+		const bundle = readProfileManifest(binName, packageDir).dsh?.bundle;
+		if (bundle === void 0) throw new Error(`${binName}: profile bundle ${JSON.stringify(packageName)} declares no dsh.bundle in its package.json`);
+		const patchPaths = bundlePatchPaths(packageDir, bundle);
+		const patches = patchPaths.flatMap((patchPath) => loadOverlayPatches(binName, patchPath));
+		layers.push({
 			packageName,
 			packageDir,
-			patchPath,
-			patches: loadOverlayPatches(binName, patchPath)
-		};
-	});
+			patchPaths,
+			patches
+		});
+	} catch (error) {
+		process.stderr.write(`${binName}: skipping profile bundle ${JSON.stringify(packageName)}: ${String(error)}\n`);
+	}
 	const patchPath = join(dir, PROFILE_PATCH_FILENAME);
 	const patches = options.userLayer !== false && existsSync(patchPath) ? loadOverlayPatches(binName, patchPath) : [];
 	return {
@@ -1032,15 +742,13 @@ function loadProfileDirectory(binName, dir, installAnchor, options = {}) {
 		dir,
 		layers,
 		patchPath,
-		patches,
-		patchReload
+		patches
 	};
 }
 /**
 * Load a profile: resolve every `dsh.profile.bundles` entry to its patch
-* layer and parse the profile's own patch file. A listed bundle without a
-* `dsh.bundle` manifest fails loud — naming a bundle-less package as a layer
-* is a misconfiguration, not "no patches".
+* layer and parse the profile's own patch file. Unreadable bundles are reported
+* on stderr and skipped; profile manifest and user patch errors still throw.
 * @param binName - the diagnostic prefix on thrown errors.
 * @param name - the profile name.
 * @param installAnchor - absolute path of the dsh app's package.json (first resolution anchor).
@@ -1055,8 +763,9 @@ function loadProfile(binName, name, installAnchor, home = resolveDshHome(), opti
 	if (!existsSync(join(dir, "package.json"))) {
 		const template = PROFILE_TEMPLATES[name];
 		if (template === void 0) throw new Error(`${binName}: profile ${JSON.stringify(name)} does not exist; create it with 'dsh plugin --profile ${name} add <package>'`);
-		initProfile(dir, template.bundles, template.patchReload);
+		initProfile(dir, template.bundles);
 	}
+	removeLinkProjections(dir);
 	normalizeShippedProfile(name, dir, readProfileManifest(binName, dir));
 	return loadProfileDirectory(binName, dir, installAnchor, options);
 }
@@ -1075,6 +784,166 @@ function composeEntries(layers, warn = () => {}) {
 	});
 }
 //#endregion
+//#region lib/types/profile-context.js
+/** Launcher-owned profile locations and composition inputs. */
+const TELEMETRY_ROW_ID = "session-telemetry-otel";
+/**
+* Resolve the telemetry opt-out switch into its boot patch. ANY non-empty
+* value (including `'0'`/`'false'`) disables: a privacy switch prefers
+* off-by-mistake over on-by-mistake. A composition without the telemetry row
+* exports nothing, so the switch is then trivially satisfied and no patch is
+* generated — custom profiles need not mount telemetry to run with the
+* switch set.
+* @param disabledEnv - the raw `DSH_TELEMETRY_DISABLED` value (`undefined` when unset).
+* @param hasRow - whether the composition carries the telemetry row.
+* @returns the disable patch, or `undefined` when no hard-disable patch is required.
+*/
+function resolveTelemetryPatch(disabledEnv, hasRow) {
+	if ((disabledEnv ?? "") === "" || !hasRow) return void 0;
+	return {
+		id: TELEMETRY_ROW_ID,
+		disabled: true
+	};
+}
+/** Read current bundle and user layers with the launch-time overlays.
+* @param binName Diagnostic prefix for malformed or missing configuration.
+* @param context Data supplied by the profile launcher.
+* @param initialProfile Already loaded startup profile; omitted reads the current files.
+* @returns Detached ordered patches; this function does not update the Loader.
+*/
+function readProfilePatches(binName, context, initialProfile) {
+	const profile = initialProfile ?? loadProfileDirectory(binName, context.dir, context.installAnchor, { userLayer: false });
+	const patches = structuredClone([
+		...profile.layers.flatMap((layer) => layer.patches),
+		...initialProfile?.patches ?? loadOptionalPatches(binName, context.patchPath) ?? [],
+		...loadOptionalPatches(binName, join(context.home, "cordis.patch.yml")) ?? [],
+		...context.overlays
+	]);
+	const telemetryPatch = resolveTelemetryPatch(context.telemetryDisabledEnv, composeEntries([patches]).some((row) => row.id === TELEMETRY_ROW_ID));
+	if (telemetryPatch !== void 0) patches.push(telemetryPatch);
+	return patches;
+}
+//#endregion
+//#region lib/types/profile-plugins.js
+/** Installed profile dependencies and their bundle activation after package-manager operations. */
+/** Unavailable installed metadata must not prevent listing or removing dependencies. */
+function optionalManifest(binName, packageDir) {
+	try {
+		return readProfileManifest(binName, packageDir);
+	} catch {
+		return;
+	}
+}
+/** Resolve activation metadata with the same installation precedence as profile loading. */
+function bundleManifest(location, name) {
+	let packageDir;
+	try {
+		packageDir = resolveBundleDir(location.binName, name, location.installAnchor, location.profileDir);
+	} catch {
+		return;
+	}
+	return optionalManifest(location.binName, packageDir);
+}
+/**
+* Read installed versions and bundle declarations without requiring loadable plugin code.
+* Missing or unreadable installed metadata leaves the dependency visible for repair or removal.
+* @param location - profile and installation resolution inputs.
+* @returns dependency records in package.json order and the profile manifest.
+*/
+function readProfilePlugins(location) {
+	const manifest = readProfileManifest(location.binName, location.profileDir);
+	const bundles = manifest.dsh?.profile?.bundles ?? [];
+	return {
+		manifest,
+		dependencies: Object.entries(manifest.dependencies ?? {}).map(([name, spec]) => {
+			const installed = optionalManifest(location.binName, join(location.profileDir, "node_modules", name));
+			return {
+				name,
+				version: typeof installed?.version === "string" ? installed.version : spec,
+				bundle: bundleManifest(location, name)?.dsh?.bundle?.patch !== void 0,
+				enabled: bundles.includes(name)
+			};
+		})
+	};
+}
+/**
+* Write a bundle list while preserving the supplied profile's other metadata.
+* @param profileDir - directory whose package.json is updated.
+* @param manifest - current profile manifest, read after the package operation when applicable.
+* @param bundles - ordered active bundle names, including any template entries.
+* @returns the written manifest.
+*/
+function writeProfileBundles(profileDir, manifest, bundles) {
+	const updated = {
+		...manifest,
+		dsh: {
+			...manifest.dsh,
+			profile: {
+				...manifest.dsh?.profile,
+				bundles: [...bundles]
+			}
+		}
+	};
+	writeProfileManifest(profileDir, updated);
+	return updated;
+}
+/**
+* Reconcile installed bundle declarations after a successful package-manager operation.
+* Dependency-managed entries disappear when removed or when their package loses its declaration;
+* template entries retain their order and duplicates. New bundle dependencies activate automatically.
+* @param options - location, inventory captured before pnpm, and whether explicitly disabled bundles remain disabled.
+* @returns updated inventory and newly added ordinary dependencies for caller-owned warnings.
+*/
+function reconcileProfilePlugins(options) {
+	const after = readProfilePlugins(options);
+	const beforeNames = new Set(options.before.dependencies.map((dependency) => dependency.name));
+	const afterNames = new Set(after.dependencies.map((dependency) => dependency.name));
+	const bundleNames = new Set(after.dependencies.filter((dependency) => dependency.bundle).map((dependency) => dependency.name));
+	const disabled = new Set(options.preserveDisabled ? options.before.dependencies.filter((dependency) => dependency.bundle && !dependency.enabled).map((dependency) => dependency.name) : []);
+	const previous = after.manifest.dsh?.profile?.bundles ?? [];
+	const bundles = previous.filter((name) => !(beforeNames.has(name) || afterNames.has(name)) || bundleNames.has(name));
+	for (const dependency of after.dependencies) if (dependency.bundle && !disabled.has(dependency.name) && !bundles.includes(dependency.name)) bundles.push(dependency.name);
+	return {
+		plugins: {
+			manifest: bundles.length !== previous.length || bundles.some((name, index) => name !== previous[index]) ? writeProfileBundles(options.profileDir, after.manifest, bundles) : after.manifest,
+			dependencies: after.dependencies.map((dependency) => ({
+				...dependency,
+				enabled: bundles.includes(dependency.name)
+			}))
+		},
+		addedPlainDependencies: after.dependencies.filter((dependency) => !dependency.bundle && !beforeNames.has(dependency.name)).map((dependency) => dependency.name)
+	};
+}
+//#endregion
+//#region lib/types/profile-sanitize.js
+/** Filesystem recovery for callers that own profile shutdown and write exclusion. */
+/**
+* Back up the profile patch and retain only the caller's recovery bundles.
+* The caller must stop the profile and exclude concurrent profile writes.
+* Installed packages and other manifest fields are preserved; patches are never parsed.
+* Failures propagate and may leave completed changes in place for a retry.
+* @param binName - Diagnostic prefix for invalid profile manifests.
+* @param profileDir - Profile directory to recover without loading its plugins.
+* @param bundles - Ordered bundles to enable after recovery.
+* @returns Backup path with a Unix millisecond timestamp and optional collision ordinal, or undefined if absent.
+*/
+function sanitizeProfile(binName, profileDir, bundles) {
+	const manifest = existsSync(join(profileDir, "package.json")) ? readProfileManifest(binName, profileDir) : void 0;
+	const patchPath = join(profileDir, PROFILE_PATCH_FILENAME);
+	const backupBase = `${patchPath}.bak-${Date.now()}`;
+	let backupPath = backupBase;
+	let ordinal = 0;
+	while (existsSync(backupPath)) backupPath = `${backupBase}-${++ordinal}`;
+	try {
+		renameSync(patchPath, backupPath);
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+		backupPath = void 0;
+	}
+	if (manifest !== void 0) writeProfileBundles(profileDir, manifest, bundles);
+	return backupPath;
+}
+//#endregion
 //#region lib/types/profile-resolution/resolver.js
 /** In-memory profile package routing for Node's default ESM and CommonJS loaders. */
 const WORKER_RESOLUTION_KEY = "@deepseek-ai/dsh-app-boot/profile-resolution";
@@ -1104,27 +973,68 @@ function prefixes(path) {
 	const canonical = canonicalPath(path) + sep;
 	return canonical === configured ? [configured] : [configured, canonical];
 }
-function compileGeneration(generation) {
-	const profilePaths = prefixes(generation.profilesDir);
-	const profile = generation.profileDir === void 0 ? [] : prefixes(generation.profileDir);
+function compileResolution(resolution) {
 	return {
-		entries: new Map(generation.entries.map((entry) => [entry.name, entry])),
-		profilesDir: generation.profilesDir,
-		profileDir: generation.profileDir,
-		profilePaths,
-		profileUrls: profilePaths.map((path) => pathToFileURL(path).href),
-		profile,
-		activeProfileUrls: profile.map((path) => pathToFileURL(path).href),
-		localPackageNames: new Set(generation.localPackageNames),
-		shared: new Set(profilePaths.map((prefix) => join(prefix, "node_modules"))),
+		entries: new Map(resolution.entries.map((entry) => [entry.name, entry])),
+		profilesDir: resolution.profilesDir,
+		profileDir: resolution.profileDir,
+		profilePaths: prefixes(resolution.profilesDir),
+		profile: resolution.profileDir === void 0 ? [] : prefixes(resolution.profileDir),
+		installationPaths: [...new Set(resolution.entries.filter((entry) => entry.scope === "installation").flatMap((entry) => prefixes(entry.packageDir)))],
+		linkedPaths: resolution.linkedRoots.flatMap((root) => prefixes(root.realPath)),
+		localPackageNames: new Set(resolution.localPackageNames),
 		esmRoutes: /* @__PURE__ */ new Map(),
 		cjsRoutes: /* @__PURE__ */ new Map()
 	};
 }
+/**
+* The interception layer of a profile is `<profileParent>/node_modules`: an entry occupies its name there, so its
+* subpath misses continue above it, and a name without an entry continues at it.
+*/
+function computeProfileLayer(dir, active) {
+	const profileParent = dirname(dir);
+	return {
+		kind: "profile",
+		active,
+		localPrefix: dir + sep,
+		nativeAfter: join(profileParent, "package.json"),
+		after: join(dirname(profileParent), "package.json")
+	};
+}
+/** The interception layer of a module path: from its profile directory inside a profiles tree, or its linked root. */
+function findInterceptionLayer(path, resolution) {
+	const treeRoot = resolution.profilePaths.find((prefix) => path.startsWith(prefix));
+	const activeProfile = resolution.profile.find((prefix) => path.startsWith(prefix));
+	const dir = treeRoot !== void 0 ? profileChild(path, treeRoot) : activeProfile?.slice(0, -1);
+	if (dir !== void 0) return computeProfileLayer(dir, activeProfile !== void 0);
+	if (!startsWithin(path, resolution.linkedPaths)) return void 0;
+	if (startsWithin(path, resolution.installationPaths)) return void 0;
+	return { kind: "linked" };
+}
+/** Package names a directory's current manifest lists as peers; an unreadable manifest lists none. */
+function readPeerNames(directory) {
+	try {
+		const peers = JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).peerDependencies;
+		return new Set(peers !== null && typeof peers === "object" ? Object.keys(peers) : []);
+	} catch (_error) {
+		return /* @__PURE__ */ new Set();
+	}
+}
 function startsWithin(path, roots) {
 	for (const root of roots) if (path.startsWith(root)) return true;
 	return false;
 }
+/**
+* The profile directory owning a module inside the profiles tree: the first path segment below the tree root.
+* @param path - module path below `treePrefix`.
+* @param treePrefix - profiles directory with a trailing separator.
+* @returns the profile directory without a trailing separator.
+*/
+function profileChild(path, treePrefix) {
+	const rest = path.slice(treePrefix.length);
+	const end = rest.indexOf(sep);
+	return treePrefix + (end < 0 ? rest : rest.slice(0, end));
+}
 function nativePackageDir(parent, name) {
 	for (const searchPath of createRequire(parent).resolve.paths(name)) {
 		const candidate = join(searchPath, name);
@@ -1138,10 +1048,7 @@ function localPackageCandidate(searchPath, name, flavor) {
 		".js",
 		".json",
 		".node"
-	].some((extension) => existsSync(candidate + extension))) ? {
-		packageDir: candidate,
-		canBeManagedLink: stat !== void 0
-	} : void 0;
+	].some((extension) => existsSync(candidate + extension))) ? candidate : void 0;
 }
 function selfReferenceName(parent) {
 	let current = dirname(parent);
@@ -1198,7 +1105,7 @@ function packageImportsTarget(parent, request, conditions) {
 }
 function packageSearchPaths(entry, request, cjs) {
 	const name = barePackageName(request);
-	/* v8 ignore next -- fallback routes are created only for bare package requests */
+	/* v8 ignore next -- interception routes are created only for bare package requests */
 	if (name === void 0) return cjs._nodeModulePaths(dirname(entry.declarer));
 	const suffix = sep + name.split("/").join(sep);
 	return entry.packageDir.endsWith(suffix) ? [entry.packageDir.slice(0, -suffix.length)] : cjs._nodeModulePaths(dirname(entry.declarer));
@@ -1229,62 +1136,100 @@ function isUnselectedPackageMiss(error) {
 }
 function sameResolution(left, right) {
 	if (left === right) return true;
-	const leftPath = left.startsWith("file:") ? fileURLToPath(left) : left;
-	const rightPath = right.startsWith("file:") ? fileURLToPath(right) : right;
-	return canonicalPath(leftPath) === canonicalPath(rightPath);
+	return canonicalPath(left) === canonicalPath(right);
 }
-/** One mutable pointer to immutable generation data. */
+/** One mutable pointer to the immutable runtime resolution. */
 var ResolutionRouter = class {
+	nodeModulePaths;
 	current;
-	constructor(generation) {
-		this.current = compileGeneration(generation);
-	}
-	replace(generation) {
-		const entries = new Map(generation.entries.map((entry) => [entry.name, entry]));
-		if (generation.profilesDir !== this.current.profilesDir || generation.profileDir !== this.current.profileDir) throw new Error("profile resolution: a generation cannot change its profile scope");
+	linkedTargets;
+	constructor(resolution, nodeModulePaths) {
+		this.nodeModulePaths = nodeModulePaths;
+		this.current = compileResolution(resolution);
+		this.linkedTargets = new Map(resolution.linkedRoots.map((root) => [root.name, root.realPath]));
+	}
+	replace(successor) {
+		const entries = new Map(successor.entries.map((entry) => [entry.name, entry]));
+		if (successor.profilesDir !== this.current.profilesDir || successor.profileDir !== this.current.profileDir) throw new Error("profile resolution: a successor cannot change its profile scope");
 		for (const [name, current] of this.current.entries) {
 			const next = entries.get(name);
 			if (next === void 0 || !sameResolution(current.packageDir, next.packageDir) || !sameResolution(current.declarer, next.declarer) || current.version !== next.version || current.scope !== next.scope) throw new Error(`profile resolution: replacing ${JSON.stringify(name)} requires a process restart`);
 		}
-		const localPackageNames = new Set(generation.localPackageNames);
+		const localPackageNames = new Set(successor.localPackageNames);
 		for (const name of this.current.localPackageNames) if (!localPackageNames.has(name)) throw new Error(`profile resolution: removing local package ${JSON.stringify(name)} requires a process restart`);
 		for (const name of localPackageNames) if (!this.current.localPackageNames.has(name) && this.current.entries.has(name)) throw new Error(`profile resolution: overriding ${JSON.stringify(name)} locally requires a process restart`);
-		this.current = compileGeneration(generation);
+		for (const root of successor.linkedRoots) {
+			const previous = this.linkedTargets.get(root.name);
+			if (previous !== void 0 && !sameResolution(previous, root.realPath)) throw new Error(`profile resolution: relinking ${JSON.stringify(root.name)} requires a process restart`);
+		}
+		const next = compileResolution(successor);
+		for (const { name, realPath } of successor.linkedRoots) if (!this.linkedTargets.has(name)) this.linkedTargets.set(name, realPath);
+		this.current = next;
+	}
+	/** Whether a module path has an interception layer: it lies in the profiles tree, the active profile, or a linked root. */
+	hasInterceptionLayerForPath(path) {
+		return findInterceptionLayer(path, this.current) !== void 0;
+	}
+	/** Whether an importer URL is scoped; the answer is memoized with the importer's routes. */
+	hasInterceptionLayerForUrl(parentURL) {
+		return this.getOrCreateParentRoutesForUrl(parentURL) !== false;
+	}
+	createParentRoutes(parent, resolution) {
+		const layer = findInterceptionLayer(parent, resolution);
+		return layer === void 0 ? void 0 : {
+			parent,
+			layer,
+			requests: /* @__PURE__ */ new Map()
+		};
+	}
+	getOrCreateParentRoutesForUrl(parentURL) {
+		const resolution = this.current;
+		let parentRoutes = resolution.esmRoutes.get(parentURL);
+		if (parentRoutes !== void 0) return parentRoutes;
+		let parent;
+		try {
+			parent = fileURLToPath(parentURL);
+		} catch {
+			parent = void 0;
+		}
+		parentRoutes = parent === void 0 ? false : this.createParentRoutes(parent, resolution) ?? false;
+		resolution.esmRoutes.set(parentURL, parentRoutes);
+		return parentRoutes;
 	}
-	routeScoped(request, parentRoutes, generation, flavor, nativeResolve, cacheable = false) {
-		const { parent, profilesDir, requests } = parentRoutes;
+	routeScoped(request, parentRoutes, resolution, flavor, cjs) {
+		const { parent, layer, requests } = parentRoutes;
+		const memo = layer.kind === "profile" && (cjs === void 0 || cjs.cacheable);
 		const name = barePackageName(request);
 		if (name === void 0) return void 0;
-		if (parentRoutes.selfReferenceName === void 0) parentRoutes.selfReferenceName = selfReferenceName(parent);
+		if (parentRoutes.selfReferenceName === void 0 || !memo) parentRoutes.selfReferenceName = selfReferenceName(parent);
 		if (parentRoutes.selfReferenceName === name || parentRoutes.selfReferenceName === null) {
 			const state = { route: { kind: "native" } };
-			requests.set(request, state);
+			if (memo) requests.set(request, state);
 			return state;
 		}
-		const target = generation.entries.get(name);
+		if (layer.kind === "linked") return this.routeLinked(request, name, parent, resolution, flavor, cjs);
+		const target = resolution.entries.get(name);
 		const candidates = [];
 		const localSearchPaths = [];
 		for (const searchPath of createRequire(parent).resolve.paths(name)) {
-			if (generation.shared.has(resolve(searchPath))) break;
+			if (!searchPath.startsWith(layer.localPrefix)) break;
 			localSearchPaths.push(searchPath);
 			const candidate = localPackageCandidate(searchPath, name, flavor);
-			if (candidate !== void 0) {
-				if (!(candidate.canBeManagedLink && generation.profile.some((prefix) => candidate.packageDir === join(prefix, "node_modules", name) && isProfileModuleFallbackLink(prefix.slice(0, -1), name)))) candidates.push(candidate);
-			}
+			if (candidate !== void 0) candidates.push(candidate);
 		}
-		if (candidates.length > 0) if (flavor === "cjs" && nativeResolve !== void 0) try {
-			const resolved = nativeResolve(localSearchPaths);
-			const selected = candidates.find((candidate) => localCandidateOwnsResolution(candidate.packageDir, resolved, request, name));
+		if (candidates.length > 0) if (cjs !== void 0) try {
+			const resolved = cjs.resolveNative(localSearchPaths);
+			const selected = candidates.find((candidate) => localCandidateOwnsResolution(candidate, resolved, request, name));
 			if (selected !== void 0) {
 				const state = {
 					route: {
 						kind: "native",
-						packageDir: selected.packageDir
+						packageDir: selected
 					},
-					packageDir: selected.packageDir,
-					...cacheable ? { cjs: resolved } : {}
+					packageDir: selected,
+					cjs: resolved
 				};
-				requests.set(request, state);
+				if (memo) requests.set(request, state);
 				return state;
 			}
 		} catch (error) {
@@ -1295,122 +1240,120 @@ var ResolutionRouter = class {
 			const state = {
 				route: {
 					kind: "native",
-					packageDir: selected.packageDir
+					packageDir: selected
 				},
-				packageDir: selected.packageDir
+				packageDir: selected
 			};
 			requests.set(request, state);
 			return state;
 		}
-		const eligible = target?.scope === "installation" || target?.scope === "profile" && parentRoutes.activeProfile;
-		const after = join(dirname(profilesDir), "package.json");
-		const route = eligible ? {
-			kind: "fallback",
+		const route = target !== void 0 && (target.scope === "installation" || layer.active) ? {
+			kind: "interception",
 			entry: target,
-			after
+			after: layer.after
 		} : {
-			kind: "after-fallback",
-			parent: after
+			kind: "native-after-interception",
+			parent: layer.nativeAfter
 		};
 		const state = { route };
-		if (route.kind === "fallback") requests.set(request, state);
+		if (route.kind === "interception" && memo) requests.set(request, state);
 		return state;
 	}
-	routeLocalPackage(request, parentRoutes, generation) {
+	routeLinked(request, name, parent, resolution, flavor, cjs) {
+		const target = resolution.entries.get(name);
+		if (target === void 0) return { route: { kind: "native" } };
+		const ancestors = this.nodeModulePaths(dirname(parent));
+		const ancestorSet = new Set(ancestors);
+		const searchPaths = flavor === "esm" ? ancestors : createRequire(parent).resolve.paths(name);
+		for (const searchPath of searchPaths) {
+			const directory = dirname(searchPath);
+			if (ancestorSet.has(searchPath) && readPeerNames(directory).has(name)) {
+				const route = {
+					kind: "interception",
+					entry: target,
+					after: join(dirname(directory), "package.json")
+				};
+				if (cjs === void 0) return { route };
+				try {
+					const resolved = cjs.resolveEntry(target, route.after);
+					if (localCandidateOwnsResolution(target.packageDir, resolved, request, name)) return {
+						route,
+						packageDir: target.packageDir,
+						cjs: resolved
+					};
+				} catch (error) {
+					if (!isUnselectedPackageMiss(error)) throw error;
+				}
+				continue;
+			}
+			const candidate = localPackageCandidate(searchPath, name, flavor);
+			if (candidate === void 0) continue;
+			if (cjs === void 0) return {
+				route: {
+					kind: "native",
+					packageDir: candidate
+				},
+				packageDir: candidate
+			};
+			try {
+				const resolved = cjs.resolveNative([searchPath]);
+				if (localCandidateOwnsResolution(candidate, resolved, request, name)) return {
+					route: {
+						kind: "native",
+						packageDir: candidate
+					},
+					packageDir: candidate,
+					cjs: resolved
+				};
+			} catch (error) {
+				if (!isUnselectedPackageMiss(error)) throw error;
+			}
+		}
+		return cjs === void 0 ? { route: { kind: "native" } } : {
+			route: { kind: "native" },
+			cjs: cjs.resolveNative([])
+		};
+	}
+	routeLocalPackage(request, parentRoutes, resolution) {
 		const name = barePackageName(request);
-		if (name === void 0 || !parentRoutes.activeProfile || !generation.localPackageNames.has(name)) return void 0;
+		const { layer } = parentRoutes;
+		if (name === void 0 || layer.kind !== "profile" || !layer.active || !resolution.localPackageNames.has(name)) return void 0;
 		const state = { route: { kind: "native" } };
 		parentRoutes.requests.set(request, state);
 		return state;
 	}
 	routeUrl(request, parentURL) {
-		const generation = this.current;
-		let parentRoutes = generation.esmRoutes.get(parentURL);
+		const resolution = this.current;
+		const parentRoutes = this.getOrCreateParentRoutesForUrl(parentURL);
 		if (parentRoutes === false) return void 0;
-		const cached = parentRoutes?.requests.get(request);
+		const cached = parentRoutes.requests.get(request);
 		if (cached !== void 0) return cached;
-		if (parentRoutes === void 0) {
-			const profileIndex = generation.profileUrls.findIndex((prefix) => parentURL.startsWith(prefix));
-			const activeProfileIndex = generation.activeProfileUrls.findIndex((prefix) => parentURL.startsWith(prefix));
-			if (profileIndex < 0 && activeProfileIndex < 0) {
-				generation.esmRoutes.set(parentURL, false);
-				return;
-			}
-			let parent;
-			try {
-				parent = fileURLToPath(parentURL);
-			} catch {
-				generation.esmRoutes.set(parentURL, false);
-				return;
-			}
-			const profileRoot = profileIndex >= 0 ? generation.profilePaths[profileIndex] : generation.profile[activeProfileIndex];
-			/* v8 ignore next -- one matching index was established above */
-			if (profileRoot === void 0) return void 0;
-			parentRoutes = {
-				parent,
-				profilesDir: profileRoot.slice(0, -1),
-				activeProfile: activeProfileIndex >= 0,
-				requests: /* @__PURE__ */ new Map()
-			};
-			generation.esmRoutes.set(parentURL, parentRoutes);
-		}
-		const local = this.routeLocalPackage(request, parentRoutes, generation);
+		const local = this.routeLocalPackage(request, parentRoutes, resolution);
 		if (local !== void 0) return local;
-		return this.routeScoped(request, parentRoutes, generation, "esm");
+		return this.routeScoped(request, parentRoutes, resolution, "esm");
 	}
-	routePath(request, parent, nativeResolve, cacheable = false) {
-		const generation = this.current;
-		let parentRoutes = generation.cjsRoutes.get(parent);
+	routePath(request, parent, cjs) {
+		const resolution = this.current;
+		let parentRoutes = resolution.cjsRoutes.get(parent);
 		if (parentRoutes === false) return void 0;
-		const cached = parentRoutes?.requests.get(request);
+		const cached = cjs.cacheable ? parentRoutes?.requests.get(request) : void 0;
 		if (cached !== void 0) return cached;
 		if (parentRoutes === void 0) {
-			const profilesDir = generation.profilePaths.find((prefix) => parent.startsWith(prefix));
-			const activeProfile = generation.profile.find((prefix) => parent.startsWith(prefix));
-			if (profilesDir !== void 0 || activeProfile !== void 0) {
-				const profileRoot = profilesDir ?? activeProfile;
-				/* v8 ignore next -- one matching root was established above */
-				if (profileRoot === void 0) return void 0;
-				parentRoutes = {
-					parent,
-					profilesDir: profileRoot.slice(0, -1),
-					activeProfile: activeProfile !== void 0,
-					requests: /* @__PURE__ */ new Map()
-				};
-				generation.cjsRoutes.set(parent, parentRoutes);
-			}
-		}
-		if (parentRoutes === void 0) {
-			generation.cjsRoutes.set(parent, false);
-			return;
-		}
-		return this.routeScoped(request, parentRoutes, generation, "cjs", nativeResolve, cacheable);
-	}
-	explicitRoute(request, paths) {
-		if (barePackageName(request) === void 0) return void 0;
-		for (const [index, path] of paths.entries()) {
-			const parent = join(resolve(path), ".dsh-profile-resolution.cjs");
-			if (startsWithin(parent, this.current.profilePaths) || startsWithin(parent, this.current.profile)) return {
-				index,
-				parent
-			};
+			parentRoutes = this.createParentRoutes(parent, resolution) ?? false;
+			resolution.cjsRoutes.set(parent, parentRoutes);
+			if (parentRoutes === false) return void 0;
 		}
-	}
-	nativeSelfReference(request, parent) {
-		const name = barePackageName(request);
-		if (name === void 0) return false;
-		const self = selfReferenceName(parent);
-		return self === name || self === null;
+		return this.routeScoped(request, parentRoutes, resolution, "cjs", cjs);
 	}
 	packageDir(specifier, parentURL) {
 		const name = barePackageName(specifier);
 		if (name === void 0) return void 0;
-		const state = this.routeUrl(specifier, parentURL);
-		if (state?.route.kind === "fallback") return state.route.entry.packageDir;
+		const state = this.routeUrl(name, parentURL);
+		if (state?.route.kind === "interception") return state.route.entry.packageDir;
 		if (state?.packageDir !== void 0) return state.packageDir;
 		let parent;
 		try {
-			parent = state?.route.kind === "after-fallback" ? state.route.parent : fileURLToPath(parentURL);
+			parent = state?.route.kind === "native-after-interception" ? state.route.parent : fileURLToPath(parentURL);
 		} catch {
 			return;
 		}
@@ -1454,353 +1397,1427 @@ function throwWithImporter(error, routedParent, parent) {
 	}
 	throw error;
 }
-function throwWithoutCjsAnchor(error, anchor) {
-	const resolved = error;
-	const requireStack = resolved.requireStack;
-	if (error instanceof Error && resolved.code === "MODULE_NOT_FOUND" && requireStack?.[0] !== void 0 && sameResolution(requireStack[0], anchor)) {
-		const originalMessage = error.message;
-		const originalBlock = `\nRequire stack:\n${requireStack.map((path) => `- ${path}`).join("\n")}`;
-		const remaining = requireStack.slice(1);
-		/* v8 ignore next -- routed calls always retain the original importing module */
-		const replacement = remaining.length === 0 ? "" : `\nRequire stack:\n${remaining.map((path) => `- ${path}`).join("\n")}`;
-		error.message = originalMessage.replace(originalBlock, replacement);
-		resolved.requireStack = remaining;
-		const stack = error.stack;
-		/* v8 ignore next -- Node's resolver errors always carry a stack */
-		if (stack !== void 0) error.stack = stack.replace(originalMessage, error.message);
+function throwWithoutCjsAnchor(error, anchor) {
+	const resolved = error;
+	const requireStack = resolved.requireStack;
+	if (error instanceof Error && resolved.code === "MODULE_NOT_FOUND" && requireStack?.[0] !== void 0 && sameResolution(requireStack[0], anchor)) {
+		const originalMessage = error.message;
+		const originalBlock = `\nRequire stack:\n${requireStack.map((path) => `- ${path}`).join("\n")}`;
+		const remaining = requireStack.slice(1);
+		/* v8 ignore next -- routed calls always retain the original importing module */
+		const replacement = remaining.length === 0 ? "" : `\nRequire stack:\n${remaining.map((path) => `- ${path}`).join("\n")}`;
+		error.message = originalMessage.replace(originalBlock, replacement);
+		resolved.requireStack = remaining;
+		const stack = error.stack;
+		/* v8 ignore next -- Node's resolver errors always carry a stack */
+		if (stack !== void 0) error.stack = stack.replace(originalMessage, error.message);
+	}
+	throw error;
+}
+/**
+* Install one runtime resolution as the interception on Node's default ESM and CommonJS resolvers.
+* @param resolution - complete package table and profile scope.
+* @returns an interception that publishes a successor or restores the native methods.
+*/
+function installRuntimeInterception(resolution) {
+	const { esm, esmDefaultResolve, esmConditions, cjs, cjsConditions, modern } = internalModules();
+	const router = new ResolutionRouter(resolution, (directory) => cjs._nodeModulePaths(directory));
+	let delegatedEsm;
+	const adaptEsm = (native) => {
+		const adapted = (request, parent, attributes) => {
+			const delegated = delegatedEsm;
+			/* v8 ignore next -- reentry requires a separate synchronous Node hook; supported launches install none */
+			if (delegated !== void 0 && delegated.parent === parent && delegated.request === request) return native(request, parent, attributes);
+			if (parent === void 0 || !router.hasInterceptionLayerForUrl(parent)) return native(request, parent, attributes);
+			const state = router.routeUrl(request, parent);
+			if (state === void 0) {
+				const target = request[0] === "#" ? packageImportsTarget(fileURLToPath(parent), request, esmConditions) : void 0;
+				if (target === void 0) return native(request, parent, attributes);
+				const restoreImporter = (error) => throwWithImporter(error, target.parentURL, parent);
+				let expected;
+				try {
+					expected = adapted(target.specifier, target.parentURL, attributes);
+					/* v8 ignore next -- Node 24+ resolves synchronously; the Node 22 matrix covers its Promise result */
+					if (expected instanceof Promise) expected = expected.catch(restoreImporter);
+				} catch (error) {
+					return restoreImporter(error);
+				}
+				return expected;
+			}
+			const cacheable = attributes === EMPTY_ATTRIBUTES || Object.keys(attributes).length === 0;
+			if (cacheable && state.esm !== void 0) return state.esm;
+			const route = state.route;
+			if (route.kind === "native") {
+				const result = native(request, parent, attributes);
+				if (cacheable && !(result instanceof Promise)) state.esm = result;
+				return result;
+			}
+			const routedParent = pathToFileURL(route.kind === "interception" ? route.entry.declarer : route.parent).href;
+			const previous = delegatedEsm;
+			delegatedEsm = {
+				parent: routedParent,
+				request
+			};
+			const restoreImporter = (error) => throwWithImporter(error, routedParent, parent);
+			try {
+				let result;
+				try {
+					result = native(request, routedParent, attributes);
+				} catch (error) {
+					return restoreImporter(error);
+				}
+				/* v8 ignore next -- Node 24+ resolves synchronously; the Node 22 matrix covers its Promise result */
+				if (result instanceof Promise) return result.catch(restoreImporter);
+				if (cacheable) state.esm = result;
+				return result;
+			} finally {
+				delegatedEsm = previous;
+			}
+		};
+		return adapted;
+	};
+	let restoreEsm;
+	/* v8 ignore else -- CI coverage runs Node 24 v2; the Node 22 matrix exercises the v1 adapter */
+	if (modern) {
+		const loader = esm;
+		const original = Reflect.get(loader, "resolveSync");
+		const resolveRequest = adaptEsm((request, parent, attributes) => original.call(loader, parent, {
+			specifier: request,
+			attributes
+		}));
+		const wrapped = (parent, request, ...rest) => rest.length ? Reflect.apply(original, loader, [
+			parent,
+			request,
+			...rest
+		]) : resolveRequest(request.specifier, parent, request.attributes ?? EMPTY_ATTRIBUTES);
+		loader.resolveSync = wrapped;
+		restoreEsm = () => {
+			/* v8 ignore else -- interceptions are disposed in reverse installation order */
+			if (loader.resolveSync === wrapped) loader.resolveSync = original;
+		};
+	} else {
+		const loader = esm;
+		const original = Reflect.get(loader, "resolve");
+		const originalSync = Reflect.get(loader, "resolveSync");
+		const resolveRequest = adaptEsm((request, parent, attributes) => original.call(loader, request, parent, attributes));
+		const resolveRequestSync = adaptEsm((request, parent, attributes) => originalSync.call(loader, request, parent, attributes));
+		const wrapped = (request, parent, attributes = EMPTY_ATTRIBUTES) => resolveRequest(request, parent, attributes);
+		const wrappedSync = (request, parent, attributes = EMPTY_ATTRIBUTES) => resolveRequestSync(request, parent, attributes);
+		loader.resolve = wrapped;
+		loader.resolveSync = wrappedSync;
+		restoreEsm = () => {
+			if (loader.resolve === wrapped) loader.resolve = original;
+			if (loader.resolveSync === wrappedSync) loader.resolveSync = originalSync;
+		};
+	}
+	const originalFilename = Reflect.get(cjs, "_resolveFilename");
+	let delegatedCjs = 0;
+	const resolveRoutedCjs = (request, routed, parent, main, options) => {
+		const anchor = routed.kind === "interception" ? routed.entry.declarer : routed.parent;
+		const synthetic = new cjs(anchor);
+		synthetic.parent = parent;
+		synthetic.filename = anchor;
+		synthetic.paths = routed.kind === "interception" ? packageSearchPaths(routed.entry, request, cjs) : cjs._nodeModulePaths(dirname(anchor));
+		try {
+			return originalFilename.call(cjs, request, synthetic, main, options);
+		} catch (error) {
+			return throwWithoutCjsAnchor(error, anchor);
+		}
+	};
+	const resolveNativeCjs = (request, searchPaths, parent, parentFilename, main, conditions) => {
+		const synthetic = new cjs(parentFilename);
+		if (parent.parent !== void 0) synthetic.parent = parent.parent;
+		synthetic.filename = parentFilename;
+		synthetic.paths = [...searchPaths];
+		const options = conditions === void 0 ? void 0 : { conditions };
+		return originalFilename.call(cjs, request, synthetic, main, options);
+	};
+	const resolvePackageImportCjs = (target, conditions) => {
+		const state = router.routeUrl(target.specifier, target.parentURL);
+		const resolveFrom = (parentURL) => fileURLToPath(esmDefaultResolve(target.specifier, {
+			parentURL,
+			conditions: [...conditions]
+		}).url);
+		/* v8 ignore next -- the target manifest was found inside the established profile scope */
+		if (state === void 0) return resolveFrom(target.parentURL);
+		if (state.route.kind === "native") return resolveFrom(target.parentURL);
+		const route = state.route;
+		if (route.kind === "native-after-interception") return resolveFrom(pathToFileURL(route.parent).href);
+		return resolveFrom(pathToFileURL(route.entry.declarer).href);
+	};
+	const wrappedFilename = (request, parent, main, options) => {
+		if (delegatedCjs || !parent?.filename || options?.paths !== void 0) return originalFilename.call(cjs, request, parent, main, options);
+		const parentFilename = parent.filename;
+		const cacheable = options?.conditions === void 0;
+		const routedOptions = options?.conditions === void 0 ? void 0 : { conditions: options.conditions };
+		const state = router.routePath(request, parentFilename, {
+			cacheable,
+			resolveNative: (searchPaths) => resolveNativeCjs(request, searchPaths, parent, parentFilename, main, options?.conditions),
+			resolveEntry: (entry, after) => {
+				delegatedCjs++;
+				try {
+					return resolveRoutedCjs(request, {
+						kind: "interception",
+						entry,
+						after
+					}, parent, main, routedOptions);
+				} finally {
+					delegatedCjs--;
+				}
+			}
+		});
+		if (state === void 0) {
+			const scoped = router.hasInterceptionLayerForPath(parentFilename);
+			const conditions = options?.conditions ?? cjsConditions;
+			const target = request[0] === "#" && scoped ? packageImportsTarget(parentFilename, request, conditions) : void 0;
+			if (target === void 0) return originalFilename.call(cjs, request, parent, main, options);
+			return resolvePackageImportCjs(target, conditions);
+		}
+		if (state.cjs !== void 0) return state.cjs;
+		const route = state.route;
+		if (route.kind === "native") {
+			const result = originalFilename.call(cjs, request, parent, main, options);
+			if (cacheable) state.cjs = result;
+			return result;
+		}
+		delegatedCjs++;
+		try {
+			let expected;
+			try {
+				expected = resolveRoutedCjs(request, route, parent, main, routedOptions);
+			} catch (error) {
+				if (route.kind !== "interception" || !isUnselectedPackageMiss(error)) throw error;
+				expected = resolveRoutedCjs(request, {
+					kind: "native-after-interception",
+					parent: route.after
+				}, parent, main, routedOptions);
+			}
+			if (cacheable) state.cjs = expected;
+			return expected;
+		} finally {
+			delegatedCjs--;
+		}
+	};
+	cjs._resolveFilename = wrappedFilename;
+	return {
+		packageDir(specifier, parentURL) {
+			return router.packageDir(specifier, parentURL);
+		},
+		replace(next) {
+			router.replace(next);
+		},
+		dispose() {
+			/* v8 ignore else -- interceptions are disposed in reverse installation order */
+			if (cjs._resolveFilename === wrappedFilename) cjs._resolveFilename = originalFilename;
+			restoreEsm();
+		}
+	};
+}
+/**
+* Publish one runtime resolution for Harness-owned Workers.
+* @param resolution - complete package table and profile scope.
+* @returns a disposer restoring the previous thread environment data.
+*/
+function registerWorkerResolution(resolution) {
+	const previous = getEnvironmentData(WORKER_RESOLUTION_KEY);
+	setEnvironmentData(WORKER_RESOLUTION_KEY, { resolution });
+	return () => {
+		setEnvironmentData(WORKER_RESOLUTION_KEY, previous);
+	};
+}
+//#endregion
+//#region lib/types/package-meta.js
+/** Read plugin display text and icons through exported resources without evaluating plugin code. */
+const LANGUAGE_ID = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/u;
+/** Maximum raw icon bytes admitted to plugin metadata. */
+const MAX_ICON_BYTES = 256 * 1024;
+const ICON_MEDIA_TYPES = new Map([
+	[".svg", "image/svg+xml"],
+	[".png", "image/png"],
+	[".jpg", "image/jpeg"],
+	[".jpeg", "image/jpeg"],
+	[".webp", "image/webp"]
+]);
+function iconOf(value, manifestPath) {
+	const icon = textOf(value, `${manifestPath}: icon`);
+	if (icon === void 0) return void 0;
+	if (isAbsolute(icon) || win32.isAbsolute(icon) || /^[A-Za-z][A-Za-z\d+.-]*:/u.test(icon)) throw new Error(`${manifestPath}: icon must be a relative file path`);
+	const mediaType = ICON_MEDIA_TYPES.get(extname(icon).toLowerCase());
+	if (mediaType === void 0) throw new Error(`${manifestPath}: icon must be SVG, PNG, JPEG, or WebP`);
+	const directory = realpathSync(dirname(manifestPath));
+	const file = realpathSync(resolve(directory, icon));
+	const local = relative(directory, file);
+	if (local === ".." || local.startsWith(`..${sep}`) || isAbsolute(local)) throw new Error(`${manifestPath}: icon must remain inside its manifest directory`);
+	const stat = statSync(file);
+	if (!stat.isFile()) throw new Error(`${manifestPath}: icon must be a regular file`);
+	if (stat.size > MAX_ICON_BYTES) throw new Error(`${manifestPath}: icon exceeds 256 KiB`);
+	const bytes = readFileSync(file);
+	if (bytes.length > MAX_ICON_BYTES) throw new Error(`${manifestPath}: icon exceeds 256 KiB`);
+	return `data:${mediaType};base64,${bytes.toString("base64")}`;
+}
+/**
+* Resolve a plugin resource through the active Node ESM resolver without evaluating it.
+* @param specifier - complete resource module specifier, including its locale filename.
+* @param parentURL - owning module-resolution base.
+* @returns the local filesystem path selected by Node and the active profile.
+* @throws when the resolver is unavailable or the resource cannot resolve to a local file.
+*/
+function resolvePluginResource(specifier, parentURL) {
+	const loader = ModuleLoader.fromInternal();
+	if (loader === void 0) throw new Error("Plugin metadata requires the Node module resolver");
+	return fileURLToPath((loader.version === "v2" ? loader.resolveSync(parentURL, {
+		specifier,
+		attributes: {}
+	}) : loader.resolveSync(specifier, parentURL, {})).url);
+}
+function missingResource(error) {
+	const code = error?.code;
+	return code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || code === "ENOENT" || code === "ENOTDIR";
+}
+function optionalResourcePath(specifier, parentURL) {
+	try {
+		return resolvePluginResource(specifier, parentURL);
+	} catch (error) {
+		if (missingResource(error)) return void 0;
+		throw error;
+	}
+}
+function objectOf(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${path} must be an object`);
+	return value;
+}
+function textOf(value, path) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || value.trim() === "") throw new Error(`${path} must be a non-empty string`);
+	return value;
+}
+function readObject(file) {
+	let contents;
+	try {
+		contents = JSON.parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		throw new Error(`${file}: ${String(error)}`);
+	}
+	return objectOf(contents, file);
+}
+function fallbackText(value) {
+	return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function dictionariesOf(englishPath, specifier, parentURL) {
+	const dictionaries = /* @__PURE__ */ new Map();
+	for (const entry of readdirSync(dirname(englishPath), { withFileTypes: true })) {
+		if (!entry.name.endsWith(".json")) continue;
+		const resource = `${specifier}/locale/${entry.name}`;
+		const language = entry.name.slice(0, -5);
+		if (!LANGUAGE_ID.test(language)) throw new Error(`${resource} must use a language id as its filename`);
+		const id = language.toLowerCase();
+		if (dictionaries.has(id)) throw new Error(`${resource} duplicates locale ${id}`);
+		const file = resolvePluginResource(resource, parentURL);
+		if (dirname(file) !== dirname(englishPath)) throw new Error(`${resource}: ${file} must share the English locale directory ${dirname(englishPath)}`);
+		const parsed = readObject(file);
+		const meta = parsed.meta === void 0 ? void 0 : objectOf(parsed.meta, `${file}: meta`);
+		dictionaries.set(id, {
+			title: textOf(meta?.title, `${file}: meta.title`),
+			description: textOf(meta?.description, `${file}: meta.description`)
+		});
+	}
+	return dictionaries;
+}
+function localizedText(field, dictionaries, fallback, finalFallback) {
+	const entries = [...dictionaries].flatMap(([language, fields]) => {
+		const value = fields[field];
+		return value === void 0 ? [] : [[language, value]];
+	});
+	if (entries.length === 0) return fallback;
+	return {
+		en: fallback ?? finalFallback,
+		...Object.fromEntries(entries)
+	};
+}
+/**
+* Read localized display text and the icon declared in a plugin's exported package.json.
+* Icons are manifest-relative SVG, PNG, JPEG, or WebP files of at most 256 KiB,
+* contained in the manifest directory after realpath resolution. Icon failures retain display text.
+* Non-package specifiers are skipped without invoking the resource resolver.
+* Language files share the directory containing the resolved English resource;
+* each file is resolved through the complete plugin specifier before reading.
+* Missing fields use the same address's package.json name/description. Translation
+* maps retain an English fallback, ultimately the full module specifier for titles and empty for descriptions.
+* @param specifier - configured plugin module name, including any package subpath.
+* @param parentURL - owning Loader tree's module-resolution base.
+* @returns display fields and any icon diagnostic, or undefined for non-package specifiers or absent metadata.
+*/
+function readPluginMeta(specifier, parentURL) {
+	if (barePackageName(specifier) === void 0) return void 0;
+	try {
+		const englishPath = optionalResourcePath(`${specifier}/locale/en.json`, parentURL);
+		const dictionaries = englishPath === void 0 ? /* @__PURE__ */ new Map() : dictionariesOf(englishPath, specifier, parentURL);
+		const manifestPath = optionalResourcePath(`${specifier}/package.json`, parentURL);
+		const manifest = manifestPath === void 0 ? void 0 : readObject(manifestPath);
+		const title = localizedText("title", dictionaries, fallbackText(manifest?.name), specifier);
+		const description = localizedText("description", dictionaries, fallbackText(manifest?.description), "");
+		const text = {
+			...title === void 0 ? {} : { title },
+			...description === void 0 ? {} : { description }
+		};
+		let icon;
+		try {
+			icon = manifestPath === void 0 ? void 0 : iconOf(manifest?.icon, manifestPath);
+		} catch (error) {
+			return {
+				...text,
+				error: `Plugin metadata for ${specifier}: ${String(error)}`
+			};
+		}
+		if (title === void 0 && description === void 0 && icon === void 0) return void 0;
+		return {
+			...text,
+			...icon === void 0 ? {} : { icon }
+		};
+	} catch (error) {
+		return { error: `Plugin metadata for ${specifier}: ${String(error)}` };
+	}
+}
+//#endregion
+//#region lib/types/config-schema/native.js
+/** Identity checks at the plugin-export and lazy-builder boundaries. */
+/**
+* Recognize the native Schemastery graph protocol without invoking a validator or serialization hook.
+* @param value - plugin Config export or lazy-builder result.
+* @returns whether native schema fields can be inspected.
+*/
+function isNativeConfigSchema(value) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+	const meta = Reflect.get(value, "meta");
+	return Reflect.get(value, Symbol.for("schemastery")) === true && typeof Reflect.get(value, "type") === "string" && meta !== null && typeof meta === "object";
+}
+//#endregion
+//#region lib/types/config-schema/pattern.js
+/** Conservative compatibility checks between native RegExp validation and Unicode JSON Schema patterns. */
+function bmpOnly(node) {
+	switch (node.type) {
+		case "Character": return node.value <= 65535 && (node.value < 55296 || node.value > 57343);
+		case "CharacterClassRange": return bmpOnly(node.min) && bmpOnly(node.max) && (node.max.value < 55296 || node.min.value > 57343);
+		case "CharacterClass": return !node.negate && node.elements.every(bmpOnly);
+		case "CharacterSet": return (node.kind === "digit" || node.kind === "space" || node.kind === "word") && !node.negate;
+		case "Quantifier": return bmpOnly(node.element);
+		case "Assertion": return [
+			"start",
+			"end",
+			"word"
+		].includes(node.kind);
+		default: return false;
+	}
+}
+function broadSet(node) {
+	return node.type === "CharacterSet" && (node.kind === "any" || (node.kind === "digit" || node.kind === "space" || node.kind === "word") && node.negate);
+}
+function portableAlternative(alternative) {
+	if (alternative.elements.length === 1 && alternative.elements.some(broadSet)) return true;
+	let broadRepetitions = 0;
+	const wordAssertion = alternative.elements.some((element) => element.type === "Assertion" && element.kind === "word");
+	return alternative.elements.every((element) => {
+		if (element.type === "Quantifier" && element.max === Infinity && element.min <= 1 && broadSet(element.element)) return !wordAssertion && ++broadRepetitions === 1;
+		return bmpOnly(element);
+	});
+}
+function signature(pattern) {
+	const incidental = new Set([
+		"parent",
+		"start",
+		"end",
+		"raw",
+		"references",
+		"resolved"
+	]);
+	return JSON.stringify(pattern, (key, value) => incidental.has(key) ? void 0 : value);
+}
+/**
+* Create a checker for patterns that can retain native acceptance under Unicode regex semantics.
+* Unrecognized flagless syntax stays explicitly partial rather than becoming a misleading constraint.
+* @returns the compatibility predicate; parsing never executes the regular expression against config values.
+*/
+async function createPatternCheck() {
+	const { RegExpParser } = await import("@eslint-community/regexpp");
+	const parser = new RegExpParser();
+	return (source, flags = "") => {
+		if (flags !== "" && flags !== "u") return false;
+		try {
+			const unicode = parser.parsePattern(source, 0, source.length, { unicode: true });
+			if (flags === "u") return true;
+			const native = parser.parsePattern(source, 0, source.length, { unicode: false });
+			return signature(native) === signature(unicode) && native.alternatives.every(portableAlternative);
+		} catch (error) {
+			if (error instanceof SyntaxError) return false;
+			throw error;
+		}
+	};
+}
+//#endregion
+//#region lib/types/config-schema/projector.js
+/** Project native Config input constraints without executing their validators or transform callbacks. */
+/** Definition that projected value positions reference as `#/$defs/loaderExpression`; an enclosing document must define it. */
+const LOADER_EXPRESSION_SCHEMA = {
+	type: "object",
+	properties: { __jsExpr: { type: "string" } },
+	required: ["__jsExpr"],
+	description: "Inert representation of a YAML !!js scalar from the Cordis entry-list parser. Its result is evaluated and validated only at runtime. Extra marker-object fields are ignored by interpolation."
+};
+/** Copy JSON-compatible schema annotations without silently converting non-JSON defaults. */
+function jsonValue(value, nullifyUndefined = false) {
+	const visit = (item, active) => {
+		if (nullifyUndefined && item === void 0) return;
+		if (item === null || typeof item === "string" || typeof item === "boolean") return;
+		if (typeof item === "number" && Number.isFinite(item)) return;
+		if (typeof item !== "object") throw new Error("schema annotation is not JSON-compatible");
+		if (active.has(item)) throw new Error("schema annotation contains a cycle");
+		if (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null) throw new Error("schema annotation contains a non-JSON object");
+		active.add(item);
+		for (const child of Object.values(item)) visit(child, active);
+		active.delete(item);
+	};
+	visit(value, /* @__PURE__ */ new Set());
+	return JSON.parse(JSON.stringify(value, (_key, item) => nullifyUndefined && item === void 0 ? null : item));
+}
+/** Native constant equality treats omitted and null-valued object members alike. */
+function constant(value, objectComparison) {
+	if (Array.isArray(value)) return {
+		type: "array",
+		minItems: value.length,
+		maxItems: value.length,
+		items: false,
+		...value.length ? { prefixItems: Array.from(value, (item) => constant(item, objectComparison)) } : {}
+	};
+	if (value !== null && typeof value === "object") {
+		objectComparison();
+		const properties = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, constant(child, objectComparison)]));
+		const inherited = Object.getOwnPropertyNames(Object.prototype);
+		const required = Object.keys(properties).filter((key) => !inherited.includes(key) && Reflect.get(value, key) != null);
+		return {
+			type: "object",
+			properties,
+			additionalProperties: { type: "null" },
+			patternProperties: { [`^(?:${inherited.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`]: {} },
+			...required.length ? { required } : {}
+		};
+	}
+	return { const: value };
+}
+/** Add or remove null acceptance; a type list stays deduplicated because a wrapped projection may already accept null. */
+function nullable(core, accepts) {
+	if (typeof core === "boolean") return accepts ? core || { type: "null" } : core && { not: { type: "null" } };
+	const types = typeof core.type === "string" ? [core.type] : core.type;
+	if (types === void 0) return accepts ? { anyOf: [core, { type: "null" }] } : {
+		...core,
+		not: { type: "null" }
+	};
+	const [single, ...rest] = accepts ? [...new Set([...types, "null"])] : types.filter((type) => type !== "null");
+	if (single === void 0) return false;
+	return {
+		...core,
+		type: rest.length ? [single, ...rest] : single
+	};
+}
+/** Add expression alternatives only at config VALUE positions, not property names or applicator branches. */
+function expressions(schema, valuePosition = true, enabled = true) {
+	const result = { ...schema };
+	if (schema.properties) result.properties = Object.fromEntries(Object.entries(schema.properties).map(([key, child]) => [key, expressions(child, true, enabled)]));
+	for (const key of ["items", "additionalProperties"]) if (schema[key] !== void 0) result[key] = schema[key] === false ? false : expressions(schema[key], true, enabled);
+	if (schema.propertyNames) result.propertyNames = expressions(schema.propertyNames, false, false);
+	if (schema.prefixItems) result.prefixItems = schema.prefixItems.map((child) => expressions(child, true, enabled));
+	if (schema.anyOf) result.anyOf = schema.anyOf.map((child) => expressions(child, false, enabled));
+	if (schema.not !== void 0) result.not = expressions(schema.not, false, false);
+	if (!valuePosition || !enabled) return result;
+	const annotations = {};
+	for (const key of [
+		"title",
+		"description",
+		"default",
+		"$comment",
+		"x-cordis"
+	]) if (Object.hasOwn(result, key)) {
+		annotations[key] = result[key];
+		Reflect.deleteProperty(result, key);
+	}
+	return {
+		...annotations,
+		anyOf: [result, { $ref: "#/$defs/loaderExpression" }]
+	};
+}
+/** Check native volatile containment without evaluating values or invoking unresolved lazy builders. */
+function validateVolatilePlacement(node, path, blocked = false, seen = /* @__PURE__ */ new Map()) {
+	const states = seen.get(node) ?? /* @__PURE__ */ new Set();
+	if (states.has(blocked)) return;
+	states.add(blocked);
+	seen.set(node, states);
+	if (node.meta.volatile && blocked) throw new Error(`${path}: volatile fields require a fixed object path without an enclosing volatile field`);
+	const nested = blocked || !!node.meta.volatile;
+	for (const [key, child] of Object.entries(node.dict ?? {})) validateVolatilePlacement(child, `${path}/${key}`, nested, seen);
+	if (node.sKey) validateVolatilePlacement(node.sKey, `${path}/keys`, true, seen);
+	if (node.inner && (node.type !== "lazy" || isNativeConfigSchema(node.inner))) validateVolatilePlacement(node.inner, `${path}/inner`, true, seen);
+	for (const [index, child] of (node.list ?? []).entries()) validateVolatilePlacement(child, `${path}/${index}`, true, seen);
+}
+/**
+* Create an invocation-local projector. Ajv checks only literal defaults against generated schemas;
+* it does not fill defaults, coerce input, or call native plugin validators. Opaque input or metadata effects
+* widen validation with explicit limitations instead of simulating native mutation.
+* @returns a function projecting one trusted native Config graph into the enclosing document's definitions.
+*/
+async function createConfigProjector() {
+	const { Ajv2020 } = await import("ajv/dist/2020.js");
+	const validator = new Ajv2020({
+		strict: false,
+		logger: false,
+		validateFormats: false,
+		addUsedSchema: false
+	});
+	const portablePattern = await createPatternCheck();
+	const builderResults = /* @__PURE__ */ new Map();
+	return (root, prefix) => {
+		validateVolatilePlacement(root, "config");
+		const completed = /* @__PURE__ */ new Map();
+		const strictNodes = /* @__PURE__ */ new Map();
+		const active = /* @__PURE__ */ new Set();
+		const recursiveNames = /* @__PURE__ */ new Map();
+		const definitions = {};
+		const limitations = [];
+		const metadataEffects = [];
+		const limitation = (path, message) => {
+			const text = `${path}: ${message}`;
+			limitations.push(text);
+			return text;
+		};
+		const visit = (node, path, strict = false) => {
+			let key = node;
+			if (strict) {
+				key = strictNodes.get(node) ?? { ...node };
+				strictNodes.set(node, key);
+			}
+			const cached = completed.get(key);
+			if (cached) return cached;
+			if (active.has(key)) {
+				let name = recursiveNames.get(key);
+				if (name === void 0) {
+					name = `${prefix}Recursive${recursiveNames.size}`;
+					recursiveNames.set(key, name);
+				}
+				return {
+					schema: { $ref: `#/$defs/${name}` },
+					acceptsMissing: node.type !== "lazy" && node.meta.required ? false : "unknown",
+					exact: true,
+					recursive: true,
+					effectful: true,
+					mutating: true
+				};
+			}
+			active.add(key);
+			let projection;
+			if (node.type === "lazy") {
+				let inner = node;
+				let meta = node.meta.volatile ? {
+					...node.meta,
+					volatile: false
+				} : node.meta;
+				const chain = /* @__PURE__ */ new Set();
+				let looseProjection;
+				while (inner.type === "lazy") {
+					const cachedInner = isNativeConfigSchema(inner.inner);
+					if (meta.loose) {
+						const message = limitation(path, "lazy loose fallback can accept inputs rejected by its inner schema");
+						if (!cachedInner) metadataEffects.push(limitation(path, "unresolved loose lazy metadata propagation may affect shared schemas"));
+						looseProjection = {
+							schema: { "x-cordis": {
+								loose: true,
+								limitations: [message]
+							} },
+							acceptsMissing: true,
+							exact: false,
+							recursive: false,
+							effectful: true,
+							mutating: false
+						};
+						break;
+					}
+					if (chain.has(inner)) throw new Error(`${path}: lazy cycle has no concrete schema`);
+					chain.add(inner);
+					let next = cachedInner ? inner.inner : builderResults.get(inner);
+					if (next === void 0 && typeof inner.builder === "function") {
+						next = Reflect.apply(inner.builder, inner, []);
+						builderResults.set(inner, next);
+					}
+					if (!isNativeConfigSchema(next)) throw new Error(`${path}: lazy schema has no native builder result or resolved inner schema`);
+					if (!cachedInner && [
+						"required",
+						"default",
+						"min",
+						"max",
+						"step",
+						"pattern",
+						"loose",
+						"volatile"
+					].some((key) => Object.hasOwn(meta, key) && !Object.hasOwn(next.meta, key) && ([
+						"required",
+						"loose",
+						"volatile"
+					].includes(key) ? !!Reflect.get(meta, key) : Reflect.get(meta, key) != null))) metadataEffects.push(limitation(path, "lazy metadata propagation may affect shared schemas; validation requires native execution"));
+					meta = cachedInner ? next.meta : {
+						...meta,
+						...next.meta
+					};
+					validateVolatilePlacement({
+						...next,
+						meta
+					}, `${path}/lazy`, true);
+					inner = next;
+				}
+				projection = looseProjection ?? visit({
+					...inner,
+					meta
+				}, `${path}/lazy`, strict);
+				if (node.meta.volatile) projection = {
+					...projection,
+					schema: {
+						...projection.schema,
+						"x-cordis": {
+							...projection.schema["x-cordis"],
+							volatile: true
+						}
+					}
+				};
+			} else {
+				const ownLimitations = [];
+				const inputLimitations = [];
+				let unsupported = false;
+				const inputLimitation = (message) => {
+					inputLimitations.push(message);
+					ownLimitations.push(limitation(path, message));
+				};
+				const annotation = (value, name) => {
+					try {
+						return {
+							ok: true,
+							value: jsonValue(value)
+						};
+					} catch (error) {
+						ownLimitations.push(limitation(`${path}/${name}`, `annotation omitted: ${error instanceof Error ? error.message : String(error)}`));
+						return { ok: false };
+					}
+				};
+				const children = [];
+				const child = (value, suffix, childStrict = false) => {
+					if (value === void 0) throw new Error(`${path}: ${node.type} schema is missing ${suffix}`);
+					const result = visit(value, `${path}/${suffix}`, childStrict);
+					children.push(result);
+					return result;
+				};
+				const meta = { ...node.meta };
+				for (const key of [
+					"min",
+					"max",
+					"step"
+				]) {
+					if (meta[key] === void 0 || Number.isFinite(meta[key])) continue;
+					if (!(key === "max" ? meta.max === Infinity : key === "min" && meta.min === -Infinity && !meta.step)) inputLimitation(`non-finite ${key} constraint is omitted; native validation is required`);
+					Reflect.deleteProperty(meta, key);
+				}
+				let core;
+				let dictionaryValidation;
+				switch (node.type) {
+					case "any":
+						core = true;
+						break;
+					case "never":
+						core = false;
+						break;
+					case "const":
+						try {
+							core = node.value == null ? false : constant(jsonValue(node.value, true), () => {
+								inputLimitation("object constant inherited-member comparison requires native validation");
+							});
+						} catch (error) {
+							core = true;
+							inputLimitation(`constant constraint requires native validation: ${error instanceof Error ? error.message : String(error)}`);
+						}
+						break;
+					case "boolean":
+						core = { type: "boolean" };
+						break;
+					case "string":
+						core = { type: "string" };
+						if (meta.min !== void 0) if (meta.min <= 1) core.minLength = Math.max(0, Math.ceil(meta.min));
+						else inputLimitation("UTF-16 minimum length requires native validation");
+						if (meta.max !== void 0) if (meta.max < 0) core = false;
+						else {
+							const maximum = Math.floor(meta.max);
+							core.maxLength = maximum;
+							if (maximum > 0) inputLimitation("UTF-16 maximum length requires native validation");
+						}
+						if (meta.pattern && core !== false) if (portablePattern(meta.pattern.source, meta.pattern.flags)) core.pattern = meta.pattern.source;
+						else inputLimitation("regular-expression syntax or Unicode semantics require native validation");
+						break;
+					case "number":
+						core = { type: "number" };
+						if (meta.min !== void 0) core.minimum = meta.min;
+						if (meta.max !== void 0) core.maximum = meta.max;
+						if (meta.step) {
+							const step = Math.abs(meta.step);
+							const origin = meta.min ?? 0;
+							if (!Number.isInteger(step) || origin % step !== 0) inputLimitation("fractional or offset numeric step requires native validation");
+							else if (step === 1) core.type = "integer";
+							else core.multipleOf = step;
+						}
+						break;
+					case "object": {
+						const required = [];
+						core = {
+							type: "object",
+							properties: Object.fromEntries(Object.entries(node.dict ?? {}).map(([key, field]) => {
+								const value = child(field, key);
+								if (value.acceptsMissing === false) required.push(key);
+								return [key, value.schema];
+							}))
+						};
+						if (required.length) core.required = required;
+						break;
+					}
+					case "array":
+						core = {
+							type: "array",
+							items: child(node.inner, "items").schema
+						};
+						if (meta.min !== void 0 && node.inner?.meta.default == null) core.minItems = Math.max(0, Math.ceil(meta.min));
+						if (meta.max !== void 0) if (meta.max < 0) core = false;
+						else core.maxItems = Math.floor(meta.max);
+						break;
+					case "dict": {
+						const valueSchema = child(node.inner, "values").schema;
+						core = {
+							type: "object",
+							additionalProperties: valueSchema
+						};
+						if (node.sKey) {
+							const key = child(node.sKey, "keys");
+							if (!(node.sKey.type === "string" && node.sKey.meta.min === void 0 && node.sKey.meta.max === void 0 && node.sKey.meta.pattern === void 0) && (strict || key.effectful)) {
+								dictionaryValidation = {
+									keySchema: key.schema,
+									valueSchema
+								};
+								core = { type: "object" };
+								inputLimitation(key.effectful ? "dictionary key normalization can overwrite unvalidated values; native validation is required" : "strict dictionary filtering and value validation require native validation");
+							} else core.propertyNames = key.schema;
+						}
+						break;
+					}
+					case "tuple": {
+						if (node.list === void 0) throw new Error(`${path}: tuple schema is missing its list`);
+						const values = node.list.map((item, index) => child(item, String(index)));
+						core = {
+							type: "array",
+							...values.length ? { prefixItems: values.map((item) => item.schema) } : {}
+						};
+						const minimum = values.reduce((length, value, index) => value.acceptsMissing === false ? index + 1 : length, 0);
+						if (minimum) core.minItems = minimum;
+						break;
+					}
+					case "union": {
+						if (node.list === void 0) throw new Error(`${path}: union schema is missing its list`);
+						const variants = node.list.map((item, index) => child(item, String(index), strict));
+						if (variants.slice(0, -1).some((variant) => variant.mutating)) {
+							core = true;
+							inputLimitation("earlier union branches may alter later validation inputs; native validation is required");
+						} else core = variants.length ? { anyOf: variants.map((variant) => variant.schema) } : false;
+						break;
+					}
+					case "transform":
+						core = child(node.inner, "input", true).schema;
+						inputLimitation("transform callback validation and normalization are not executed or projected");
+						break;
+					default:
+						core = true;
+						unsupported = true;
+						inputLimitation(`native schema type ${node.type} is not statically projected`);
+				}
+				if (meta.loose) {
+					core = true;
+					inputLimitation("loose validation can replace invalid values with defaults");
+				}
+				const recursive = children.some((value) => value.recursive);
+				const container = [
+					"object",
+					"array",
+					"dict",
+					"tuple"
+				].includes(node.type);
+				const mutating = unsupported || children.some((value) => value.mutating || container && value.effectful);
+				const exact = inputLimitations.length === 0 && children.every((value) => value.exact);
+				const fallback = meta.default === void 0 ? void 0 : annotation(meta.default, "default");
+				let acceptsMissing;
+				if (meta.required) acceptsMissing = false;
+				else if (unsupported) acceptsMissing = "unknown";
+				else if (meta.default == null) acceptsMissing = true;
+				else if (!fallback?.ok) acceptsMissing = "unknown";
+				else if (recursive) {
+					acceptsMissing = "unknown";
+					inputLimitation("recursive default validation cannot be decided statically");
+				} else if (!exact) acceptsMissing = "unknown";
+				else acceptsMissing = validator.validate(core, fallback.value);
+				const annotations = {};
+				if (fallback?.ok) annotations.default = fallback.value;
+				const native = {};
+				if (typeof meta.description === "string") annotations.description = meta.description;
+				else if (meta.description) {
+					const descriptions = annotation(meta.description, "description");
+					if (descriptions.ok) {
+						native.descriptions = descriptions.value;
+						const description = meta.description.en ?? meta.description[""] ?? Object.values(meta.description)[0];
+						if (typeof description === "string") annotations.description = description;
+					}
+				}
+				if (dictionaryValidation) native.dictionaryValidation = dictionaryValidation;
+				const copy = (name, value) => {
+					if (value === void 0) return;
+					const result = annotation(value, name);
+					if (result.ok) native[name] = result.value;
+				};
+				for (const key of [
+					"role",
+					"extra",
+					"hidden",
+					"disabled",
+					"collapse",
+					"link",
+					"comment",
+					"badges",
+					"loose",
+					"volatile"
+				]) copy(key, meta[key]);
+				if (meta.pattern?.flags) copy("patternFlags", meta.pattern.flags);
+				if (node.type === "union") native.branchSelection = "first-success";
+				if (acceptsMissing === "unknown") native.omissionValidation = "runtime";
+				if (ownLimitations.length) {
+					native.type = node.type;
+					for (const key of [
+						"min",
+						"max",
+						"step",
+						"pattern"
+					]) copy(key, meta[key]);
+					native.limitations = ownLimitations;
+				}
+				if (Object.keys(native).length) annotations["x-cordis"] = native;
+				const input = nullable(core, acceptsMissing !== false);
+				projection = {
+					schema: {
+						...typeof input === "boolean" ? input ? {} : { not: {} } : input,
+						...annotations
+					},
+					acceptsMissing,
+					exact: exact && acceptsMissing !== "unknown",
+					recursive,
+					effectful: unsupported || node.type === "transform" || !!meta.loose || children.some((child) => child.effectful),
+					mutating
+				};
+			}
+			active.delete(key);
+			const name = recursiveNames.get(key);
+			if (name !== void 0) {
+				definitions[name] = projection.schema;
+				projection = {
+					...projection,
+					schema: { $ref: `#/$defs/${name}` }
+				};
+			}
+			completed.set(key, projection);
+			return projection;
+		};
+		const result = visit(root, "config");
+		const schema = expressions(result.schema);
+		return {
+			schema: metadataEffects.length ? { anyOf: [schema, {}] } : schema,
+			definitions: Object.fromEntries(Object.entries(definitions).map(([key, value]) => [key, expressions(value, false)])),
+			acceptsMissing: metadataEffects.length ? "unknown" : result.acceptsMissing,
+			limitations: [...new Set(limitations)]
+		};
+	};
+}
+//#endregion
+//#region lib/types/config-schema/document.js
+/** Compose Loader entry/patch structure and discovered plugin input schemas into one JSON Schema document. */
+const ref = (name) => ({ $ref: `#/$defs/${name}` });
+function metadata() {
+	return {
+		id: {
+			type: "string",
+			description: "Entry id. Loader generates an id when an entry omits it; patches use the configured id."
+		},
+		name: {
+			type: "string",
+			description: "Plugin module specifier. Inserted relative plugin paths are anchored beside their patch file."
+		},
+		config: {},
+		group: {
+			type: ["boolean", "null"],
+			description: "Allows patch indexing and insertion into an entry-list config; does not select the plugin implementation."
+		},
+		disabled: {
+			anyOf: [{ type: ["boolean", "null"] }, ref("loaderExpression")],
+			description: "Boolean or !!js expression. The Loader coerces other truthy values as disabled; this schema rejects them."
+		},
+		inject: { anyOf: [
+			{
+				type: "array",
+				items: { type: "string" }
+			},
+			{ type: "object" },
+			{ type: "null" }
+		] },
+		intercept: { type: ["object", "null"] },
+		isolate: {
+			type: ["object", "null"],
+			additionalProperties: { anyOf: [{ const: true }, { type: "string" }] }
+		}
+	};
+}
+function patchStructure() {
+	return {
+		type: "object",
+		allOf: [ref("entryMetadata")],
+		properties: { insert: ref("entryList") },
+		description: "An insert appends entries, optionally inside the group identified by id. Other patches replace supplied fields; config is replaced wholesale, not deep-merged. A truthy name asserts the existing plugin name rather than renaming it. Unknown targets and non-insert patches without a nonempty id are warned and skipped."
+	};
+}
+/**
+* Build a schema for the composed entry list and a separately addressable root-tree patch list.
+* Unknown plugin names remain open; only collected schemas supply plugin-specific constraints.
+* @param profile - selected profile name.
+* @param collected - declarations discovered without mounting plugins, including include descendants.
+* @param targets - last-id-wins patch targets from the root tree's patch index, excluding include descendants.
+* @param initialDiagnostics - composition and import diagnostics already collected.
+* @returns one JSON Schema document with explicit collection and projection annotations.
+*/
+async function buildConfigSchemaDocument(profile, collected, targets, initialDiagnostics) {
+	const project = await createConfigProjector();
+	const diagnostics = [...initialDiagnostics];
+	const definitions = {
+		loaderExpression: LOADER_EXPRESSION_SCHEMA,
+		entryMetadata: {
+			type: "object",
+			properties: metadata()
+		},
+		entryList: {
+			type: "array",
+			items: ref("entry")
+		},
+		patchList: {
+			type: "array",
+			items: ref("patch")
+		},
+		unknownConfig: { $comment: "No projected Config schema is available; this is unknown configuration, not a prohibition on fields." },
+		includeConfig: {
+			type: "object",
+			required: ["path"],
+			properties: {
+				path: {
+					type: "string",
+					description: "YAML/JSON filename resolved relative to the owning Loader tree. This field is literal, not a !!js expression."
+				},
+				initial: ref("entryList"),
+				patches: {
+					type: "array",
+					items: ref("includePatch")
+				},
+				enableLogs: { type: "boolean" }
+			},
+			description: "Native Include configuration stays literal. initial is used only when the file is absent. Included files have their own module-resolution base and patch target index."
+		},
+		includePatch: patchStructure()
+	};
+	const entries = [];
+	const outputByEntry = /* @__PURE__ */ new Map();
+	const projections = /* @__PURE__ */ new Map();
+	const trees = new Set(["#/$defs/entryList", "#/$defs/includeConfig"]);
+	const requiredConfigs = new Set(trees);
+	const names = new Map([["cordis:group", new Set(["#/$defs/entryList"])], ["cordis:include", new Set(["#/$defs/includeConfig"])]]);
+	for (const entry of collected) {
+		const { native, ...output } = entry;
+		if (entry.tree) output.configRef = entry.tree === "group" ? "#/$defs/entryList" : "#/$defs/includeConfig";
+		else if (native) {
+			let projection = projections.get(native);
+			if (projection === void 0) {
+				const name = `config${projections.size}`;
+				try {
+					const result = project(native, name);
+					definitions[name] = result.schema;
+					Object.assign(definitions, result.definitions);
+					projection = {
+						reference: `#/$defs/${name}`,
+						required: result.acceptsMissing === false,
+						limitations: result.limitations
+					};
+					projections.set(native, projection);
+				} catch (error) {
+					output.status = "error";
+					diagnostics.push({
+						level: "error",
+						path: entry.path,
+						message: error instanceof Error ? error.message : String(error)
+					});
+				}
+			}
+			if (projection) {
+				output.configRef = projection.reference;
+				output.status = projection.limitations.length ? "partial" : "schema";
+				if (projection.required) requiredConfigs.add(projection.reference);
+				for (const message of projection.limitations) diagnostics.push({
+					level: "warning",
+					path: entry.path,
+					message
+				});
+			}
+		}
+		output.configRef ??= "#/$defs/unknownConfig";
+		entries.push(output);
+		outputByEntry.set(entry, output);
+		if (entry.name !== void 0) {
+			const choices = names.get(entry.name) ?? /* @__PURE__ */ new Set();
+			choices.add(output.configRef);
+			names.set(entry.name, choices);
+		}
+	}
+	const dormant = {
+		properties: {
+			disabled: { anyOf: [{ const: true }, ref("loaderExpression")] },
+			group: { not: { const: true } }
+		},
+		required: ["disabled"]
+	};
+	const entryRules = [];
+	for (const [name, choices] of names) {
+		const validated = { properties: { config: { anyOf: [...choices].map((reference) => ({ $ref: reference })) } } };
+		let then = validated;
+		if ([...choices].every((reference) => requiredConfigs.has(reference))) {
+			then = {
+				if: dormant,
+				else: {
+					...validated,
+					required: ["config"]
+				}
+			};
+			if (![...choices].every((reference) => trees.has(reference))) then.then = validated;
+		}
+		entryRules.push({
+			if: {
+				properties: { name: { const: name } },
+				required: ["name"]
+			},
+			then
+		});
+		if (choices.size > 1) diagnostics.push({
+			level: "warning",
+			message: `Plugin ${JSON.stringify(name)} has multiple collected schemas; entry validation accepts their union because module resolution depends on the owning tree.`
+		});
+	}
+	definitions.entry = {
+		type: "object",
+		required: ["name"],
+		allOf: [ref("entryMetadata"), ...entryRules],
+		description: "Loader entry. Unknown metadata and plugin names are accepted; plugin-specific validation is available only for the names collected in this profile. Distinct resolutions of one name use a union of their schemas."
+	};
+	const patchRules = [];
+	for (const [id, target] of targets) {
+		if (target.name === void 0) continue;
+		const configRef = outputByEntry.get(target)?.configRef ?? "#/$defs/unknownConfig";
+		patchRules.push({
+			if: {
+				required: ["id"],
+				properties: { id: { const: id } },
+				allOf: [{ not: { required: ["insert"] } }, { anyOf: [{ not: { required: ["name"] } }, { properties: { name: { enum: ["", target.name] } } }] }]
+			},
+			then: { properties: { config: { $ref: configRef } } }
+		});
+	}
+	definitions.patch = {
+		...patchStructure(),
+		allOf: [ref("entryMetadata"), ...patchRules]
+	};
+	const positions = new Map(entries.map((entry, index) => [entry.path, index]));
+	diagnostics.sort((left, right) => (positions.get(left.path ?? "") ?? -1) - (positions.get(right.path ?? "") ?? -1));
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		title: `Cordis configuration for profile ${profile}`,
+		description: "Describes the parsed entry-list YAML printed by --dump-config. Use $defs.patchList for a profile/home/CLI overlay. Parse !!js with the Cordis entry-list YAML dialect. Expression results, service dependencies, plugin startup checks, and sequence-dependent patch targets still require runtime validation.",
+		$comment: "Bundle, profile, home, and CLI layers apply in that order. A patch config replaces the whole config. JSON Schema defaults are annotations; Schemastery validates a fallback on null/omission unless required rejects it first. Schemastery unions select the first successful branch. Root patch id constraints describe the current index, not ids introduced or changed by earlier patches. Include-local patches have a separate index. Relative plugin insertions require their source patch directory; this document does not infer future overlay locations.",
+		type: "array",
+		items: ref("entry"),
+		$defs: definitions,
+		"x-cordis": {
+			profile,
+			complete: !diagnostics.some((item) => item.level === "error") && !entries.some((entry) => [
+				"partial",
+				"unsupported",
+				"error"
+			].includes(entry.status)) && ![...names.values()].some((choices) => choices.size > 1),
+			entries,
+			diagnostics,
+			patchSchema: "#/$defs/patchList"
+		}
+	};
+}
+//#endregion
+//#region lib/types/config-schema/collect.js
+/** Boot-free inspection of declared plugin Config schemas using profile module resolution. */
+function objectLike(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function configOf(plugin) {
+	return objectLike(plugin) ? Reflect.get(plugin, "Config") : void 0;
+}
+function validateMetadata(row) {
+	for (const key of ["id", "name"]) {
+		const value = Reflect.get(row, key);
+		if (value !== void 0 && typeof value !== "string") throw new Error(`${key} must be a literal string`);
 	}
-	throw error;
+	const group = Reflect.get(row, "group");
+	if (group !== void 0 && group !== null && typeof group !== "boolean") throw new Error("group must be a literal boolean or null");
+}
+function validateEntry(value) {
+	if (!record(value) || typeof value.name !== "string") throw new Error("each entry must be a mapping with a literal plugin name");
+	validateMetadata(value);
 }
-function assertEquivalent(actual, expected, request, parent) {
-	if (sameResolution(actual, expected)) return;
-	throw new Error(`profile resolution mismatch for ${JSON.stringify(request)} from ${parent}: disk resolved ${actual}, generation resolved ${expected}`);
+function entryList(value) {
+	if (value === void 0) throw new Error("entry list config is missing");
+	if (!Array.isArray(value)) throw new Error("expected a literal entry list; config expressions are not evaluated");
+	return value;
 }
-function assertOptionalEquivalent(actual, expected, request, parent) {
-	if (actual === void 0 && expected === void 0) return;
-	if (actual !== void 0 && expected !== void 0 && sameResolution(actual, expected)) return;
-	throw new Error(`profile resolution mismatch for ${JSON.stringify(request)} from ${parent}: disk selected ${actual ?? "nothing"}, generation selected ${expected ?? "nothing"}`);
+function includePatches(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new Error("include patches must be a literal patch list; config expressions are not evaluated");
+	for (const patch of value) {
+		if (!record(patch) || isJsExpr(patch)) throw new Error("include patches must be literal mappings; config expressions are not evaluated");
+		validateMetadata(patch);
+		if (patch.insert !== void 0) entryList(patch.insert);
+	}
+	return value;
 }
 /**
-* Install one profile generation on Node's default ESM and CommonJS resolvers.
-* @param generation - complete package table and profile scope.
-* @param behavior - enforce the generation, or verify a materialized generation.
-* @returns a registration that replaces the generation or restores the native methods.
+* Generate JSON Schema from parsed entry rows and root-tree patches without applying plugins or evaluating expressions.
+* Imports, Config getters, and lazy schema builders execute trusted plugin code; transform callbacks do not. Calls must not overlap
+* another profile-resolution interception; module imports remain cached after the interception is released.
+* @param profile - prepared profile whose directory anchors root module and include resolution.
+* @param entries - unvalidated rows from profile composition; malformed rows become positioned diagnostics without losing siblings.
+* @param resolution - the same immutable package resolution used for profile boot.
+* @param diagnostics - existing composition diagnostics; copied into the returned catalog.
+* @returns a JSON Schema document with partial-result diagnostics and Config references under `x-cordis`.
+* @throws when Node's profile module resolution cannot be installed.
 */
-function installProfileResolution(generation, behavior = "enforce") {
-	const router = new ResolutionRouter(generation);
-	const { esm, esmDefaultResolve, esmConditions, cjs, cjsConditions, modern } = internalModules();
-	const esmScope = /* @__PURE__ */ new Map();
-	const profilePaths = [...prefixes(generation.profilesDir), ...generation.profileDir === void 0 ? [] : prefixes(generation.profileDir)];
-	const profileUrls = profilePaths.map((path) => pathToFileURL(path).href);
-	let recentEsmParent;
-	let recentEsmScoped = false;
-	let delegatedEsm;
-	const adaptEsm = (native) => {
-		const adapted = (request, parent, attributes) => {
-			const delegated = delegatedEsm;
-			/* v8 ignore next -- reentry requires a separate synchronous Node hook; supported launches install none */
-			if (delegated !== void 0 && delegated.parent === parent && delegated.request === request) return native(request, parent, attributes);
-			if (parent === void 0) return native(request, parent, attributes);
-			let scoped = recentEsmParent === parent ? recentEsmScoped : esmScope.get(parent);
-			if (scoped === void 0) {
-				scoped = startsWithin(parent, profileUrls);
-				esmScope.set(parent, scoped);
+async function collectConfigSchemas(profile, entries, resolution, diagnostics = []) {
+	const result = {
+		entries: [],
+		diagnostics: [...diagnostics]
+	};
+	const byOptions = /* @__PURE__ */ new Map();
+	const interception = installRuntimeInterception(resolution);
+	try {
+		const loader = ModuleLoader.fromInternal();
+		if (loader === void 0) throw new Error("config schema dump requires the Node module loader used by profile resolution");
+		const builtins = {
+			group: Group,
+			include: Include
+		};
+		const nativeCarriers = /* @__PURE__ */ new Map();
+		const carrier = async (plugin, baseUrl) => {
+			if (plugin === Group) return "group";
+			if (plugin === Include) return "include";
+			if (!objectLike(plugin) || !Reflect.get(plugin, EntryGroup.key)) return void 0;
+			let resolved = nativeCarriers.get(baseUrl);
+			if (resolved === void 0) {
+				resolved = Promise.allSettled([loader.import("@deepseek-ai/cordis-plugin-group", baseUrl, {}), loader.import("@deepseek-ai/cordis-plugin-include", baseUrl, {})]).then(([group, include]) => {
+					return {
+						group: group.status === "fulfilled" ? Loader.prototype.unwrapExports(group.value) : void 0,
+						include: include.status === "fulfilled" ? Loader.prototype.unwrapExports(include.value) : void 0
+					};
+				});
+				nativeCarriers.set(baseUrl, resolved);
+			}
+			const native = await resolved;
+			if (plugin === native.group) return "group";
+			if (plugin === native.include) return "include";
+			throw new Error("unrecognized Loader tree carrier; use cordis:group or cordis:include for native child collection");
+		};
+		const ancestors = /* @__PURE__ */ new Set();
+		const report = (path, error) => {
+			result.diagnostics.push({
+				level: "error",
+				path,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		};
+		const warn = (path) => (message, ...args) => {
+			let index = 0;
+			result.diagnostics.push({
+				level: "warning",
+				path,
+				message: message.replace(/%C/g, () => JSON.stringify(args[index++]))
+			});
+		};
+		const walkInclude = async (config, baseUrl, path) => {
+			if (config === void 0) throw new Error("include config is missing");
+			if (!record(config) || isJsExpr(config)) throw new Error("include config must be literal; config expressions are not evaluated");
+			if (typeof config.path !== "string") throw new Error("include path must be literal; config expressions are not evaluated");
+			const filename = fileURLToPath(new URL(config.path, baseUrl));
+			const extension = extname(filename);
+			if (![
+				".json",
+				".yaml",
+				".yml"
+			].includes(extension)) throw new Error(`include extension ${JSON.stringify(extension)} is not supported`);
+			let source;
+			let canonical;
+			try {
+				canonical = await realpath(filename);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				canonical = filename;
 			}
-			if (recentEsmParent !== parent) {
-				recentEsmParent = parent;
-				recentEsmScoped = scoped;
+			if (ancestors.has(canonical)) throw new Error(`include cycle at ${filename}`);
+			let content;
+			try {
+				content = await readFile(filename, "utf8");
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				source = config.initial;
+				if (source === void 0) throw new Error(`include file not found: ${filename}`);
 			}
-			if (!scoped) return native(request, parent, attributes);
-			const state = router.routeUrl(request, parent);
-			if (state === void 0) {
-				const target = request[0] === "#" ? packageImportsTarget(fileURLToPath(parent), request, esmConditions) : void 0;
-				if (target === void 0) return native(request, parent, attributes);
-				const restoreImporter = (error) => throwWithImporter(error, target.parentURL, parent);
-				let expected;
-				try {
-					expected = adapted(target.specifier, target.parentURL, attributes);
-					/* v8 ignore next -- Node 24+ resolves synchronously; the Node 22 matrix covers its Promise result */
-					if (expected instanceof Promise) expected = expected.catch(restoreImporter);
-				} catch (error) {
-					return restoreImporter(error);
-				}
-				if (behavior === "enforce") return expected;
-				const actual = native(request, parent, attributes);
-				/* v8 ignore start -- Node 22 is the asynchronous adapter and is covered by the external version matrix */
-				if (expected instanceof Promise || actual instanceof Promise) return Promise.all([actual, expected]).then(([resolved, wanted]) => {
-					assertEquivalent(resolved.url, wanted.url, request, parent);
-					return resolved;
-				});
-				/* v8 ignore stop */
-				assertEquivalent(actual.url, expected.url, request, parent);
-				return actual;
+			if (content !== void 0) try {
+				source = extension === ".json" ? JSON.parse(content) : yaml.load(content, { schema: entryListSchema });
+			} catch (error) {
+				const at = error instanceof yaml.YAMLException ? ` at line ${error.mark.line + 1}, column ${error.mark.column + 1}` : "";
+				throw new Error(`invalid ${extension === ".json" ? "JSON" : "YAML"} include ${filename}${at}`);
 			}
-			const cacheable = attributes === EMPTY_ATTRIBUTES || Object.keys(attributes).length === 0;
-			if (cacheable && state.esm !== void 0) return state.esm;
-			const route = state.route;
-			if (route.kind === "native") {
-				const result = native(request, parent, attributes);
-				if (cacheable && !(result instanceof Promise)) state.esm = result;
-				return result;
+			const patches = includePatches(config.patches);
+			const rows = entryList(source);
+			let children;
+			try {
+				children = applyEntryPatches(rows, patches, warn(path));
+			} catch (error) {
+				throw new Error(`include patches could not be composed for ${filename}; child declarations are unavailable`, { cause: error });
+			}
+			ancestors.add(canonical);
+			try {
+				await walk(children, new URL(".", pathToFileURL(filename)).href, `${path}/include`);
+			} finally {
+				ancestors.delete(canonical);
 			}
-			const routedParent = pathToFileURL(route.kind === "fallback" ? route.entry.declarer : route.parent).href;
-			if (behavior === "enforce") {
-				const previous = delegatedEsm;
-				delegatedEsm = {
-					parent: routedParent,
-					request
+		};
+		const walk = async (rows, baseUrl, prefix) => {
+			for (const [index, value] of rows.entries()) {
+				const path = `${prefix}/${index}`;
+				const identity = record(value) ? value : void 0;
+				const entry = {
+					path,
+					...typeof identity?.id === "string" ? { id: identity.id } : {},
+					...typeof identity?.name === "string" ? { name: identity.name } : {},
+					status: "error"
 				};
-				const restoreImporter = (error) => throwWithImporter(error, routedParent, parent);
+				result.entries.push(entry);
+				const row = value;
 				try {
-					let result;
-					try {
-						result = native(request, routedParent, attributes);
-					} catch (error) {
-						return restoreImporter(error);
+					validateEntry(row);
+				} catch (error) {
+					report(path, error);
+					continue;
+				}
+				entry.status = "absent";
+				byOptions.set(row, entry);
+				let plugin;
+				try {
+					let exports;
+					if (row.name.startsWith("cordis:")) {
+						const name = row.name.slice(7);
+						if (!Object.hasOwn(builtins, name)) throw new Error(`unknown Cordis builtin ${JSON.stringify(row.name)}`);
+						exports = builtins[name];
+					} else exports = await loader.import(row.name, baseUrl, {});
+					plugin = Loader.prototype.unwrapExports(exports);
+					const schema = configOf(plugin);
+					if (schema !== void 0 && schema !== null) if (!isNativeConfigSchema(schema)) {
+						entry.status = "unsupported";
+						report(path, "Config is not a native Schemastery schema");
+					} else {
+						entry.status = "schema";
+						entry.native = schema;
 					}
-					/* v8 ignore next -- Node 24+ resolves synchronously; the Node 22 matrix covers its Promise result */
-					if (result instanceof Promise) return result.catch(restoreImporter);
-					if (cacheable) state.esm = result;
-					return result;
-				} finally {
-					delegatedEsm = previous;
+				} catch (error) {
+					entry.status = "error";
+					report(path, error);
 				}
-			}
-			const actual = native(request, parent, attributes);
-			const previous = delegatedEsm;
-			delegatedEsm = {
-				parent: routedParent,
-				request
-			};
-			const restoreImporter = (error) => throwWithImporter(error, routedParent, parent);
-			try {
-				let expected;
 				try {
-					const result = native(request, routedParent, attributes);
-					expected = result;
-					/* v8 ignore next -- Node 24+ resolves synchronously; the Node 22 matrix covers its Promise result */
-					if (result instanceof Promise) expected = result.catch(restoreImporter);
+					const kind = await carrier(plugin, baseUrl);
+					if (kind === void 0) continue;
+					entry.tree = kind;
+					if (row.config === void 0 && row.group !== true && (row.disabled === true || isJsExpr(row.disabled))) continue;
+					if (kind === "group") await walk(entryList(row.config), baseUrl, `${path}/config`);
+					else await walkInclude(row.config, baseUrl, path);
 				} catch (error) {
-					return restoreImporter(error);
+					report(path, error);
 				}
-				/* v8 ignore start -- Node 22 is the asynchronous adapter and is covered by the external version matrix */
-				if (expected instanceof Promise || actual instanceof Promise) return Promise.all([actual, expected]).then(([resolved, wanted]) => {
-					assertEquivalent(resolved.url, wanted.url, request, parent);
-					if (cacheable) state.esm = resolved;
-					return resolved;
-				});
-				/* v8 ignore stop */
-				assertEquivalent(actual.url, expected.url, request, parent);
-				if (cacheable) state.esm = actual;
-				return actual;
-			} finally {
-				delegatedEsm = previous;
 			}
 		};
-		return adapted;
-	};
-	let restoreEsm;
-	/* v8 ignore else -- CI coverage runs Node 24 v2; the Node 22 matrix exercises the v1 adapter */
-	if (modern) {
-		const loader = esm;
-		const original = Reflect.get(loader, "resolveSync");
-		const resolveRequest = adaptEsm((request, parent, attributes) => original.call(loader, parent, {
-			specifier: request,
-			attributes
-		}));
-		const wrapped = (parent, request, ...rest) => rest.length ? Reflect.apply(original, loader, [
-			parent,
-			request,
-			...rest
-		]) : resolveRequest(request.specifier, parent, request.attributes ?? EMPTY_ATTRIBUTES);
-		loader.resolveSync = wrapped;
-		restoreEsm = () => {
-			/* v8 ignore else -- registrations are disposed in reverse installation order */
-			if (loader.resolveSync === wrapped) loader.resolveSync = original;
-		};
-	} else {
-		const loader = esm;
-		const original = Reflect.get(loader, "resolve");
-		const originalSync = Reflect.get(loader, "resolveSync");
-		const resolveRequest = adaptEsm((request, parent, attributes) => original.call(loader, request, parent, attributes));
-		const resolveRequestSync = adaptEsm((request, parent, attributes) => originalSync.call(loader, request, parent, attributes));
-		const wrapped = (request, parent, attributes = EMPTY_ATTRIBUTES) => resolveRequest(request, parent, attributes);
-		const wrappedSync = (request, parent, attributes = EMPTY_ATTRIBUTES) => resolveRequestSync(request, parent, attributes);
-		loader.resolve = wrapped;
-		loader.resolveSync = wrappedSync;
-		restoreEsm = () => {
-			if (loader.resolve === wrapped) loader.resolve = original;
-			if (loader.resolveSync === wrappedSync) loader.resolveSync = originalSync;
-		};
-	}
-	const originalFilename = Reflect.get(cjs, "_resolveFilename");
-	let delegatedCjs = 0;
-	const resolveRoutedCjs = (request, routed, parent, main, options) => {
-		const anchor = routed.kind === "fallback" ? routed.entry.declarer : routed.parent;
-		const synthetic = new cjs(anchor);
-		synthetic.parent = parent;
-		synthetic.filename = anchor;
-		synthetic.paths = routed.kind === "fallback" ? packageSearchPaths(routed.entry, request, cjs) : cjs._nodeModulePaths(dirname(anchor));
-		try {
-			return originalFilename.call(cjs, request, synthetic, main, options);
-		} catch (error) {
-			return throwWithoutCjsAnchor(error, anchor);
-		}
-	};
-	const resolveNativeCjs = (request, searchPaths, parent, parentFilename, main, conditions) => {
-		const synthetic = new cjs(parentFilename);
-		synthetic.parent = parent;
-		synthetic.filename = parentFilename;
-		synthetic.paths = [...searchPaths];
-		const options = conditions === void 0 ? void 0 : { conditions };
-		return originalFilename.call(cjs, request, synthetic, main, options);
-	};
-	const resolvePackageImportCjs = (target, conditions) => {
-		const state = router.routeUrl(target.specifier, target.parentURL);
-		const resolveFrom = (parentURL) => fileURLToPath(esmDefaultResolve(target.specifier, {
-			parentURL,
-			conditions: [...conditions]
-		}).url);
-		/* v8 ignore next -- the target manifest was found inside the established profile scope */
-		if (state === void 0) return resolveFrom(target.parentURL);
-		if (state.route.kind === "native") return resolveFrom(target.parentURL);
-		const route = state.route;
-		if (route.kind === "after-fallback") return resolveFrom(pathToFileURL(route.parent).href);
-		return resolveFrom(pathToFileURL(route.entry.declarer).href);
-	};
-	const wrappedFilename = (request, parent, main, options) => {
-		if (delegatedCjs || !parent?.filename) return originalFilename.call(cjs, request, parent, main, options);
-		const parentFilename = parent.filename;
-		const cacheable = options?.paths === void 0 && options?.conditions === void 0;
-		const explicitPaths = Array.isArray(options?.paths) ? options.paths : void 0;
-		if (explicitPaths !== void 0 && router.nativeSelfReference(request, parentFilename)) return originalFilename.call(cjs, request, parent, main, options);
-		const explicit = explicitPaths === void 0 ? void 0 : router.explicitRoute(request, explicitPaths);
-		if (options?.paths !== void 0 && explicit === void 0) return originalFilename.call(cjs, request, parent, main, options);
-		if (explicit !== void 0 && explicitPaths !== void 0 && explicit.index > 0) try {
-			return originalFilename.call(cjs, request, parent, main, {
-				...options,
-				paths: explicitPaths.slice(0, explicit.index)
-			});
-		} catch (error) {
-			if (!isUnselectedPackageMiss(error)) throw error;
-		}
-		const state = router.routePath(request, explicit?.parent ?? parentFilename, (searchPaths) => resolveNativeCjs(request, searchPaths, parent, parentFilename, main, options?.conditions), explicit === void 0 && cacheable);
-		if (state === void 0) {
-			const scoped = startsWithin(parentFilename, profilePaths);
-			const conditions = options?.conditions ?? cjsConditions;
-			const target = request[0] === "#" && scoped ? packageImportsTarget(parentFilename, request, conditions) : void 0;
-			if (target === void 0) return originalFilename.call(cjs, request, parent, main, options);
-			const expected = resolvePackageImportCjs(target, conditions);
-			if (behavior === "enforce") return expected;
-			const actual = originalFilename.call(cjs, request, parent, main, options);
-			assertEquivalent(actual, expected, request, parentFilename);
-			return actual;
-		}
-		if (cacheable && state.cjs !== void 0) return state.cjs;
-		const route = state.route;
-		if (route.kind === "native") {
-			const result = originalFilename.call(cjs, request, parent, main, options);
-			if (cacheable) state.cjs = result;
-			return result;
-		}
-		if (route.kind === "after-fallback" && explicit !== void 0 && explicitPaths !== void 0) try {
-			return originalFilename.call(cjs, request, parent, main, {
-				...options,
-				paths: [dirname(route.parent)]
-			});
-		} catch (error) {
-			if (!isUnselectedPackageMiss(error)) throw error;
-			const remaining = explicitPaths.slice(explicit.index + 1);
-			if (remaining.length === 0) throw error;
-			return wrappedFilename(request, parent, main, {
-				...options,
-				paths: remaining
-			});
-		}
-		delegatedCjs++;
-		try {
-			const routedOptions = options?.conditions === void 0 ? void 0 : { conditions: options.conditions };
-			let expected;
-			try {
-				expected = resolveRoutedCjs(request, route, parent, main, routedOptions);
-			} catch (error) {
-				if (route.kind !== "fallback" || !isUnselectedPackageMiss(error)) throw error;
-				try {
-					expected = resolveRoutedCjs(request, {
-						kind: "after-fallback",
-						parent: route.after
-					}, parent, main, routedOptions);
-				} catch (afterError) {
-					const remaining = explicit === void 0 || explicitPaths === void 0 ? [] : explicitPaths.slice(explicit.index + 1);
-					if (!isUnselectedPackageMiss(afterError) || remaining.length === 0) throw afterError;
-					delegatedCjs--;
-					try {
-						return wrappedFilename(request, parent, main, {
-							...options,
-							paths: remaining
-						});
-					} finally {
-						delegatedCjs++;
-					}
+		await walk(entries, pathToFileURL(join(profile.dir, "cordis.yml")).href, "");
+		const targets = /* @__PURE__ */ new Map();
+		const indexTargets = (rows) => {
+			for (const row of rows) {
+				if (!record(row)) continue;
+				if (typeof row.id === "string" && row.id) {
+					const entry = byOptions.get(row);
+					if (entry) targets.set(row.id, entry);
+					else targets.delete(row.id);
 				}
+				if (row.group && Array.isArray(row.config)) indexTargets(row.config);
 			}
-			if (behavior === "enforce") {
-				if (cacheable) state.cjs = expected;
-				return expected;
-			}
-			const actual = originalFilename.call(cjs, request, parent, main, options);
-			assertEquivalent(actual, expected, request, parentFilename);
-			if (cacheable) state.cjs = actual;
-			return actual;
-		} finally {
-			delegatedCjs--;
-		}
-	};
-	cjs._resolveFilename = wrappedFilename;
-	return {
-		packageDir(specifier, parentURL) {
-			const expected = router.packageDir(specifier, parentURL);
-			if (behavior !== "verify" || !startsWithin(parentURL, profileUrls)) return expected;
-			const name = barePackageName(specifier);
-			if (name === void 0) return expected;
-			let parent;
-			try {
-				parent = fileURLToPath(parentURL);
-			} catch {
-				return expected;
-			}
-			assertOptionalEquivalent(nativePackageDir(parent, name), expected, specifier, parentURL);
-			return expected;
-		},
-		replace(next) {
-			router.replace(next);
-		},
-		dispose() {
-			/* v8 ignore else -- registrations are disposed in reverse installation order */
-			if (cjs._resolveFilename === wrappedFilename) cjs._resolveFilename = originalFilename;
-			restoreEsm();
-		}
-	};
+		};
+		indexTargets(entries);
+		return await buildConfigSchemaDocument(profile.name, result.entries, targets, result.diagnostics);
+	} finally {
+		interception.dispose();
+	}
 }
+//#endregion
+//#region lib/types/config-schema/index.js
+/** Profile schema generation: composition diagnostics, runtime resolution, and boot-free discovery. */
 /**
-* Publish one generation for Harness-owned Workers.
-* @param generation - complete package table and profile scope.
-* @param behavior - enforce or verify the generation in newly created Workers.
-* @returns a disposer restoring the previous thread environment data.
+* Generate JSON Schema for a prepared profile's ordered patch layers without mounting plugins or evaluating expressions.
+* Reads the profile manifest; imports, Config getters, and lazy builders execute trusted code. Native validators and
+* transform callbacks are not executed. Calls must not overlap another profile-resolution interception; collection
+* releases its interception on success or rejection, while Node retains imported modules. Supplied layers are not mutated.
+* Profile preparation, layer selection, process streams, and exit policy belong to the caller.
+* @param binName - the diagnostic prefix on thrown manifest errors.
+* @param profile - prepared on-disk profile whose directory anchors root module and include resolution.
+* @param layers - already parsed patch lists in application order, including caller-selected home and argv overlays.
+* @param installAnchor - package manifest anchoring the installation's runtime dependencies.
+* @returns a JSON Schema document with declaration references, partial results, and diagnostics under `x-cordis`.
+* @throws when profile metadata, composition, or runtime resolution cannot be prepared.
 */
-function registerWorkerResolution(generation, behavior = "enforce") {
-	const previous = getEnvironmentData(WORKER_RESOLUTION_KEY);
-	setEnvironmentData(WORKER_RESOLUTION_KEY, {
-		generation,
-		behavior
+async function generateConfigSchema(binName, profile, layers, installAnchor) {
+	const diagnostics = [];
+	const manifest = readProfileManifest(binName, profile.dir);
+	for (const packageName of skippedProfileBundles(profile, manifest)) diagnostics.push({
+		level: "error",
+		message: `Selected profile bundle ${JSON.stringify(packageName)} could not be loaded; repair or remove its bundle selection.`
 	});
-	return () => {
-		setEnvironmentData(WORKER_RESOLUTION_KEY, previous);
-	};
+	return collectConfigSchemas(profile, composeEntries(layers, (message) => diagnostics.push({
+		level: "warning",
+		message
+	})), await createRuntimeResolution({
+		installAnchor,
+		profile
+	}), diagnostics);
 }
 //#endregion
 //#region lib/types/profile-resolution/service.js
-/** Package metadata resolved through one profile resolution registration. */
+/** Package metadata resolved through one runtime interception. */
 function readPackage(dir, fallbackName) {
 	const manifestPath = join(dir, "package.json");
 	if (!existsSync(manifestPath)) return void 0;
@@ -1818,31 +2835,30 @@ function readPackage(dir, fallbackName) {
 /** Package lookup shared by metadata consumers in one profile process. */
 var PluginPackages = class extends Service {
 	packages = /* @__PURE__ */ new Map();
-	resolver;
-	behavior;
+	interception;
 	disposeWorkerResolution;
 	constructor(ctx, config = {}) {
 		super(ctx, "pluginPackages");
-		this.behavior = config.behavior ?? "enforce";
-		if (config.generation === void 0) return;
-		const resolver = installProfileResolution(config.generation, this.behavior);
-		this.disposeWorkerResolution = registerWorkerResolution(config.generation, this.behavior);
-		this.resolver = resolver;
+		if (config.resolution === void 0) return;
+		const interception = installRuntimeInterception(config.resolution);
+		this.disposeWorkerResolution = registerWorkerResolution(config.resolution);
+		this.interception = interception;
 		ctx.effect(() => () => {
 			this.disposeWorkerResolution?.();
-			resolver.dispose();
+			interception.dispose();
 		}, "profile package resolution");
 	}
 	/**
-	* Publish an additive generation for this process and subsequently created Workers.
-	* @param generation - fully constructed successor generation.
+	* Publish a complete successor generation for this process and subsequently created Workers.
+	* Linked roots may be removed without unloading modules or clearing Node caches.
+	* @param successor - fully constructed generation accepted by {@link RuntimeInterception.replace}.
 	*/
-	replace(generation) {
-		if (this.resolver === void 0) throw new Error("plugin-packages: runtime resolution is not installed");
-		this.resolver.replace(generation);
+	replace(successor) {
+		if (this.interception === void 0) throw new Error("plugin-packages: runtime resolution is not installed");
+		this.interception.replace(successor);
 		this.packages = /* @__PURE__ */ new Map();
 		this.disposeWorkerResolution?.();
-		this.disposeWorkerResolution = registerWorkerResolution(generation, this.behavior);
+		this.disposeWorkerResolution = registerWorkerResolution(successor);
 	}
 	/**
 	* Locate the package named by a specifier without requiring a package export.
@@ -1853,7 +2869,7 @@ var PluginPackages = class extends Service {
 	packageOf(specifier, parentURL) {
 		const name = barePackageName(specifier);
 		if (name === void 0) return void 0;
-		const dir = this.resolver === void 0 ? packageDirFromParent(name, parentURL) : this.resolver.packageDir(name, parentURL);
+		const dir = this.interception === void 0 ? packageDirFromParent(name, parentURL) : this.interception.packageDir(name, parentURL);
 		if (dir === void 0) return void 0;
 		const key = JSON.stringify({
 			dir,
@@ -1862,6 +2878,15 @@ var PluginPackages = class extends Service {
 		if (!this.packages.has(key)) this.packages.set(key, readPackage(dir, name));
 		return this.packages.get(key);
 	}
+	/**
+	* Read display metadata without loading or activating the target plugin.
+	* @param specifier - configured package module, including package subpaths.
+	* @param parentURL - owning Loader tree's resolution base.
+	* @returns local display metadata or its diagnostic; undefined for non-package requests or absent metadata.
+	*/
+	metaOf(specifier, parentURL) {
+		return readPluginMeta(specifier, parentURL);
+	}
 };
 function packageDirFromParent(name, parentURL) {
 	for (const searchPath of createRequire(parentURL).resolve.paths(name)) {
@@ -2061,37 +3086,39 @@ function loadLayeredEnv(binName, cwd = process.cwd(), warn = (line) => void proc
 }
 const bootstrapIncludes = /* @__PURE__ */ new WeakMap();
 const userPatchesSchema = entryListSchema;
-/**
-* Watch the user patch layer and reapply it to the boot Include without rollback.
-* @param ctx - settled app context containing the root Include and an active HMR service.
-* @param options - diagnostic, file, and patch-composition inputs.
-* @returns an asynchronous disposer after the exact-path watcher is ready.
-* @throws when HMR or the root Include is absent, watcher setup fails, or initial path resolution fails.
+/** Apply one complete patch generation and wait for Loader activation diagnostics.
+* @param ctx Booted root context.
+* @param patches Complete ordered patch list.
+* @param binName Diagnostic prefix.
+* @param requiredIds Explicit enablement targets whose existing failures also reject reconciliation.
+* @returns Diagnostics for unchanged pre-existing inactive entries; new or changed failures reject.
 */
-async function watchUserPatches(ctx, options) {
-	const { binName, filename, compose = (patches) => patches } = options;
-	const hmr = ctx.get("hmr");
-	if (hmr === void 0) throw new Error(`${binName}: user patch-layer watching requires the Cordis HMR service`);
+async function reconcileProfilePatches(ctx, patches, binName, requiredIds = []) {
 	const entry = bootstrapIncludes.get(ctx);
-	if (entry === void 0) throw new Error(`${binName}: user patch-layer watching requires the root Include entry`);
-	const register = watchConfig(ctx, filename, hmr.config, async () => {
-		const { patches: _previousPatches, ...includeConfig } = entry.options.config;
-		const patches = compose(loadOptionalPatches(binName, filename) ?? []);
-		await entry.update({ config: {
-			...includeConfig,
-			patches
-		} });
-		await ctx.loader.await();
-		await Promise.allSettled([...ctx.loader.entries()].map((entry) => Promise.resolve(entry.fiber?.await())));
-		const failures = await inactiveEntries(ctx);
-		if (failures.length > 0) throw new Error(activationDiagnostic(binName, "warning", failures).trimEnd());
-	});
-	try {
-		return await register;
-	} catch (error) {
-		if (error?.code === "INACTIVE_EFFECT") return async () => {};
-		throw error;
-	}
+	if (entry === void 0) throw new Error(`${binName}: profile reload requires the root Include entry`);
+	const previousFailures = (await inactiveEntries(ctx)).map((failure) => ({
+		...failure,
+		diagnostic: inactiveDiagnostic(failure),
+		fiber: failure.entry.fiber,
+		options: JSON.stringify(failure.entry.options)
+	}));
+	const previousFibers = [...ctx.loader.entries()].flatMap((row) => row.fiber === void 0 ? [] : [{
+		fiber: row.fiber,
+		failed: row.fiber.state === FIBER_FAILED || row.fiber.state === FIBER_DISPOSED
+	}]);
+	const { patches: _previous, ...includeConfig } = entry.options.config;
+	await entry.update({ config: {
+		...includeConfig,
+		patches
+	} });
+	const results = await Promise.allSettled(previousFibers.map(({ fiber }) => fiber.await()));
+	await ctx.loader.await();
+	const failures = await inactiveEntries(ctx);
+	const introduced = failures.filter((failure) => requiredIds.includes(failure.entry.options.id) || !previousFailures.some((previous) => previous.entry === failure.entry && previous.fiber === failure.entry.fiber && previous.options === JSON.stringify(failure.entry.options) && previous.diagnostic === inactiveDiagnostic(failure)));
+	if (introduced.length > 0) throw new Error(activationDiagnostic(binName, introduced).trimEnd());
+	for (const [index, result] of results.entries()) if (result.status === "rejected" && !previousFibers[index]?.failed) throw result.reason;
+	ctx.emit("app-boot/config-reload");
+	return failures.map(inactiveDiagnostic);
 }
 /**
 * Load an optional patch-list file: a top-level YAML array of loader patch
@@ -2392,12 +3419,12 @@ function installFailLoud(binName, proc = process, release) {
 }
 /**
 * Value mirrors used because Cordis's const enum has no runtime object to import.
-* Keep aligned with `packages/extensions/tool-cordis/src/fiber-state.ts` and
-* `packages/client/web/src/loader-status.ts`.
+* Keep aligned with `packages/client/web/src/loader-status.ts`.
 */
 const FIBER_PENDING = 0;
 const FIBER_ACTIVE = 2;
 const FIBER_FAILED = 3;
+const FIBER_DISPOSED = 4;
 /**
 * Entry ids whose presence defines a usable DSH application.
 *
@@ -2432,6 +3459,25 @@ function formatActivationError(error) {
 	visit(error);
 	return details.join("\n");
 }
+/** Startup audit failure with non-enumerable metadata and original failures as its cause. */
+var StartupError = class extends Error {
+	entries;
+	/** Root configuration and startup logs, attached by boot after disposal. */
+	startup;
+	/**
+	* @param message - concise terminal diagnostic.
+	* @param entries - inactive plugin metadata and original failure values.
+	*/
+	constructor(message, entries) {
+		const failures = entries.flatMap(({ outcome }) => outcome.kind === "failed" ? [outcome.error] : []);
+		super(message, failures.length > 0 ? { cause: new AggregateError(failures, "Plugin activation failures") } : void 0);
+		this.entries = entries;
+		Object.defineProperties(this, {
+			entries: { enumerable: false },
+			startup: { enumerable: false }
+		});
+	}
+};
 /**
 * Collect Loader activation failures and disabled-expression errors. Failed
 * fibers are awaited to recover their recorded rejection reason and coalesce
@@ -2441,13 +3487,16 @@ async function inactiveEntries(ctx) {
 	const failures = [];
 	const rejectionReasons = [];
 	for (const entry of ctx.loader.entries()) {
-		const subject = `${entry.options.id} (${entry.options.name})`;
 		try {
 			if (entry.disabled) continue;
 		} catch (error) {
 			failures.push({
 				entry,
-				diagnostic: `${subject}: disabled expression failed: ${formatActivationError(error)}`
+				outcome: {
+					kind: "failed",
+					error,
+					phase: "disabled expression failed"
+				}
 			});
 			continue;
 		}
@@ -2455,7 +3504,10 @@ async function inactiveEntries(ctx) {
 		if (fiber === void 0) {
 			failures.push({
 				entry,
-				diagnostic: `${subject}: failed to import`
+				outcome: {
+					kind: "failed",
+					error: "failed to import"
+				}
 			});
 			continue;
 		}
@@ -2468,7 +3520,10 @@ async function inactiveEntries(ctx) {
 				rejectionReasons.push(error);
 				failures.push({
 					entry,
-					diagnostic: `${subject}: ${formatActivationError(error)}`
+					outcome: {
+						kind: "failed",
+						error
+					}
 				});
 			}
 			continue;
@@ -2477,42 +3532,90 @@ async function inactiveEntries(ctx) {
 			const missing = Object.keys(fiber.inject).filter((service) => fiber.ctx.get(service) === void 0);
 			failures.push({
 				entry,
-				diagnostic: `${subject}: pending (waiting for ${missing.length === 1 ? "service" : "services"}: ${missing.join(", ") || "unknown"})`
+				outcome: {
+					kind: "pending",
+					missing
+				}
 			});
 		} else failures.push({
 			entry,
-			diagnostic: `${subject}: fiber state ${String(state)}`
+			outcome: {
+				kind: "failed",
+				error: `fiber state ${String(state)}`
+			}
 		});
 	}
 	if (rejectionReasons.length > 0) await observeLoaderRejectionCheckpoint(rejectionReasons);
 	return failures;
 }
-/** Render an inactive-entry diagnostic with a count and severity label. */
-function activationDiagnostic(binName, severity, failures) {
+/** Render one failed plugin's original error and activation phase. */
+function failureDetail(outcome) {
+	return `${outcome.phase === void 0 ? "" : `${outcome.phase}: `}${formatActivationError(outcome.error)}`;
+}
+/** Render optional-only warnings without changing startup policy. */
+function activationDiagnostic(binName, failures) {
 	const noun = failures.length === 1 ? "entry" : "entries";
-	return `${binName === "" ? "" : `${binName}: `}${severity}: ${String(failures.length)} ${noun} did not activate\n${failures.map((failure) => failure.diagnostic).join("\n")}\n`;
+	return `${binName}: warning: ${String(failures.length)} ${noun} did not activate\n${failures.map(inactiveDiagnostic).join("\n")}\n`;
+}
+/** Stable per-entry text for reload comparisons and optional warnings. */
+function inactiveDiagnostic({ entry, outcome }) {
+	const detail = outcome.kind === "failed" ? failureDetail(outcome) : `pending (waiting for ${outcome.missing.length === 1 ? "service" : "services"}: ${outcome.missing.join(", ") || "unknown"})`;
+	return `${entry.options.id} (${entry.options.name}): ${detail}`;
+}
+/** Group startup failures and pending services, marking every required entry. */
+function startupDiagnostic(binName, failures, required) {
+	const lines = [`${binName}: startup failed: ${String(required.size)} required ${required.size === 1 ? "plugin" : "plugins"} did not activate`];
+	const failed = failures.flatMap(({ entry, outcome }) => outcome.kind === "failed" ? [{
+		entry,
+		outcome
+	}] : []);
+	const pending = failures.flatMap(({ entry, outcome }) => outcome.kind === "pending" ? [{
+		entry,
+		outcome
+	}] : []);
+	pending.sort((left, right) => Number(required.has(right.entry)) - Number(required.has(left.entry)));
+	const label = (entry) => `${entry.options.id}${required.has(entry) ? " (required)" : ""}`;
+	if (failed.length > 0) {
+		lines.push("", `Failed plugins (${String(failed.length)}):`);
+		for (const { entry, outcome } of failed) {
+			lines.push(`  ${label(entry)}`, `    Package: ${entry.options.name}`);
+			lines.push(...failureDetail(outcome).split("\n").map((line) => `    ${line}`));
+		}
+	}
+	if (pending.length > 0) {
+		const width = Math.max(6, ...pending.map(({ entry }) => label(entry).length)) + 2;
+		lines.push("", `Plugins waiting for services (${String(pending.length)}):`, `  ${"Plugin".padEnd(width)}Missing services`);
+		for (const { entry, outcome } of pending) lines.push(`  ${label(entry).padEnd(width)}${outcome.missing.join(", ") || "unknown"}`);
+	}
+	return lines.join("\n");
 }
 /**
 * Apply DSH startup policy to a settled Loader tree.
 *
 * Inactive entries from the global required list reject startup. Other
-* inactive entries produce one warning and leave successful siblings running.
+* inactive entries join that failure diagnostic, or produce one warning when
+* no required entry failed and leave successful siblings running.
 * Required ids absent from the tree, and disabled required entries, are ignored.
 * A throwing disabled expression is an entry failure, not a disabled entry.
 * The bootstrap Include must activate so unreadable or invalid root config is fatal.
 * @param ctx - the settled context whose Loader entries to audit.
-* @param binName - the diagnostic prefix on optional-entry warnings.
+* @param binName - the prefix on startup diagnostics.
 * @param warn - sink for optional-entry warnings.
 * @returns after optional warnings if required startup checks pass.
-* @throws when the bootstrap Include or a required entry is inactive or its disabled expression throws.
+* @throws {@link StartupError} when the bootstrap Include or a required entry is inactive or its disabled expression throws;
+* its message includes optional failures too.
 */
 async function auditStartupEntries(ctx, binName, warn = (line) => void process.stderr.write(line)) {
 	const failures = await inactiveEntries(ctx);
-	const required = [];
-	const optional = [];
-	for (const failure of failures) (failure.entry === bootstrapIncludes.get(ctx) || requiredStartupEntryIds.has(failure.entry.options.id) ? required : optional).push(failure);
-	if (optional.length > 0) warn(activationDiagnostic(binName, "warning", optional));
-	if (required.length > 0) throw new Error(activationDiagnostic("", "required startup failure", required).trimEnd());
+	const required = new Set(failures.filter(({ entry }) => entry === bootstrapIncludes.get(ctx) || requiredStartupEntryIds.has(entry.options.id)).map(({ entry }) => entry));
+	if (required.size > 0) throw new StartupError(startupDiagnostic(binName, failures, required), failures.map(({ entry, outcome }) => ({
+		id: entry.options.id,
+		module: entry.options.name,
+		required: required.has(entry),
+		fiberState: entry.fiber?.state,
+		outcome
+	})));
+	if (failures.length > 0) warn(activationDiagnostic(binName, failures));
 }
 /**
 * Boot the Loader against `absoluteConfigPath` and return only after the whole
@@ -2539,13 +3642,28 @@ async function auditStartupEntries(ctx, binName, warn = (line) => void process.s
 * complete plugin set.
 * @returns the root context after the initial startup audit, or as soon as a
 * surface disposed the tree while startup was still in flight.
-* @throws a labelled error after disposing the partial context — `host
+* @throws {@link StartupError} for an inactive required entry, including all inactive plugins in its message;
+* otherwise a labelled error after disposing the partial context — `host
 * preparation failed` when `prepare` threw before any config-tree entry
 * mounted, `plugin tree failed to load` afterwards. Cyclic causes terminate
 * diagnostic traversal without replacing the original cause.
 */
 async function boot(binName, absoluteConfigPath, patches, prepare, bareModuleBaseUrl) {
 	const ctx = new Context();
+	const startupLogs = [];
+	const diagnostics = new Context();
+	diagnostics.logger = ctx.logger;
+	diagnostics.logger.exporter({
+		levels: { default: 2 },
+		export: ({ ts, name, type, args }) => {
+			if (type === "warn" || type === "error") startupLogs.push({
+				ts,
+				name,
+				type,
+				args
+			});
+		}
+	});
 	let stage = "host preparation failed";
 	try {
 		ctx.baseUrl = pathToFileURL(dirname(absoluteConfigPath)).href + "/";
@@ -2568,6 +3686,13 @@ async function boot(binName, absoluteConfigPath, patches, prepare, bareModuleBas
 		return ctx;
 	} catch (cause) {
 		await ctx.fiber.dispose();
+		if (cause instanceof StartupError) {
+			cause.startup = {
+				configurationPath: absoluteConfigPath,
+				messages: startupLogs
+			};
+			throw cause;
+		}
 		const detail = cause instanceof Error ? cause.message : String(cause);
 		let deepest = cause;
 		const seen = /* @__PURE__ */ new Set();
@@ -2577,6 +3702,8 @@ async function boot(binName, absoluteConfigPath, patches, prepare, bareModuleBas
 		}
 		const stack = deepest instanceof AggregateError ? `\n${deepest.stack ?? deepest.message}\n${deepest.errors.map(formatActivationError).join("\n")}` : deepest instanceof Error && deepest !== cause ? `\n${deepest.stack ?? deepest.message}` : "";
 		throw new Error(`${binName}: ${stage}: ${detail}${stack}`, { cause });
+	} finally {
+		await diagnostics.fiber.dispose();
 	}
 }
 /** Prompt-section name for the harness-source location line an app bin adds after boot. */
@@ -2606,4 +3733,4 @@ function addHarnessSourceSection(ctx, sourceRoot) {
 	});
 }
 //#endregion
-export { DEFAULT_PROFILE_BUNDLES, DEFAULT_PROFILE_PATCH_RELOAD, FAIL_LOUD_RELEASE_TIMEOUT_MS, HARNESS_SOURCE_SECTION, PROFILES_DIR, PROFILE_PATCH_FILENAME, PROFILE_TEMPLATES, PluginPackages, addHarnessSourceSection, auditStartupEntries, boot, composeEntries, createProfileResolutionGeneration, healProfilesModuleFallback, initProfile, installFailLoud, loadEnv, loadLayeredEnv, loadOptionalPatches, loadOverlayPatches, loadProfile, loadProfileDirectory, mountRootInclude, readProfileManifest, renderConfigDump, resolveBundleDir, resolveConfigPath, resolveProfileDir, watchUserPatches, writeProfileManifest };
+export { DEFAULT_PROFILE_BUNDLES, FAIL_LOUD_RELEASE_TIMEOUT_MS, HARNESS_SOURCE_SECTION, LOADER_EXPRESSION_SCHEMA, OPTIONAL_BUNDLES, PROFILES_DIR, PROFILE_PATCH_FILENAME, PROFILE_TEMPLATES, PluginPackages, StartupError, addHarnessSourceSection, auditStartupEntries, boot, bundlePatchFiles, bundlePatchPaths, composeEntries, createConfigProjector, createRuntimeResolution, generateConfigSchema, initProfile, installFailLoud, isNativeConfigSchema, loadEnv, loadLayeredEnv, loadOptionalPatches, loadOverlayPatches, loadProfile, loadProfileDirectory, mountRootInclude, readPluginMeta, readProfileManifest, readProfilePatches, readProfilePlugins, reconcileProfilePatches, reconcileProfilePlugins, removeLinkProjections, renderConfigDump, resolveBundleDir, resolveConfigPath, resolveProfileDir, resolveTelemetryPatch, sanitizeProfile, writeProfileBundles, writeProfileManifest };