@dsh-electron/dsh-plugin-multi-root-workspace 0.1.0 → 0.1.1

package/lib/{command-BSkrYOAf.js → command-DyOWujPo.js}

@@ -1,7 +1,6 @@
-import { f as resolveRootRef, i as canonicalRoot, o as entryRootRef, r as availableRoots, s as expandRootInput, t as RootValidationError } from "./roots-DyT2jgEP.js";
-import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
-import { statSync } from "node:fs";
+import { f as resolveRootRef, i as canonicalRoot, o as entryRootRef, r as availableRoots, t as RootValidationError } from "./roots-DasWEBJk.js";
 import "@deepseek-ai/cordis";
+import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
 import { z } from "zod";
 //#region src/contract.ts
 /**
@@ -53,8 +52,7 @@ const PANEL_ENDPOINTS = [
 * would hide the drift.
 */
 const panelRequestSchema = z.object({
-	primaryRoot: z.string().optional(),
-	sessionId: z.string().optional(),
+	sessionId: z.string().min(1),
 	entry: z.object({
 		ordinal: z.number().int().positive(),
 		id: z.string(),
@@ -170,8 +168,7 @@ function parseRevealedView(value) {
 function narrowCall(endpoint, value) {
 	return {
 		endpoint,
-		...value.primaryRoot === void 0 ? {} : { primaryRoot: value.primaryRoot },
-		...value.sessionId === void 0 ? {} : { sessionId: value.sessionId },
+		sessionId: value.sessionId,
 		...value.entry === void 0 ? {} : { entry: value.entry },
 		...value.id === void 0 ? {} : { id: value.id },
 		...value.path === void 0 ? {} : { path: value.path },
@@ -200,35 +197,6 @@ function firstIssue(error) {
 }
 //#endregion
 //#region src/command.ts
-/**
-* The user-facing surface: the `/workspace-folders` command and the panel's
-* RPC channel.
-*
-* They share one module because they are one thing — the operator-facing edge
-* over `ctx.multiRootRegistry`. The command serves the text surfaces (the
-* composer, headless diagnostics) and the channel serves the browser panel;
-* both resolve the same canonical workspace root, call the same registry, and
-* report the same `RootValidationCode` values.
-*
-* Both are also the two places a READ happens, so both go through the same
-* revalidation entry point: `registry.refresh()` re-stats every registered
-* directory, re-resolves it against the directory it was granted for, and
-* republishes the scope BEFORE the list is rendered. Listing is therefore
-* enough to notice that a directory disappeared (and enough to bring a
-* restored one back) — which is what the panel's "Retry" button and the
-* command's `list` both promise.
-*
-* Both halves are SOFT: the command registers only where a command registry is
-* composed, and the channel only where a host Connection and web server exist
-* (web), so a headless profile mounts this row with zero effect on the
-* providers.
-*
-* The command's own text is English: a host-side command handler has no active
-* locale to consult (the browser owns locale state). The panel is bilingual.
-* That split is recorded in the M3 plan and the requirements as a known limit.
-*
-* @module @dsh-electron/dsh-plugin-multi-root-workspace/command
-*/
 /** Services this row needs before it may activate. */
 const inject = [
 	"commands",
@@ -487,31 +455,26 @@ async function targetOf(registry, primaryRoot, text) {
 	};
 }
 /**
-* Resolve the workspace root a panel request acts on.
+* Derive the primary root a panel request may act on.
+*
+* The browser names a live session; the host looks that session up and uses
+* its immutable cwd. There is no client-supplied path and no deployment-default
+* fallback: a panel call without a real host session has no workspace to
+* manage. Property access would demand an injected `sessions` dependency this
+* row does not name, so the lookup stays an explicit sibling `get` (the same
+* pattern as `directoryPicker` / `subprocess`).
 *
-* A client-supplied `primaryRoot` is accepted — the browser is the operator's
-* own trusted client, and the panel names the root it displays — but it must be
-* an existing directory. Otherwise the session's immutable cwd, then the
-* deployment fallback, decides.
+* @param ctx - the host context that may carry `sessions`.
+* @param sessionId - the id the panel sent; already required by the wire schema.
+* @returns the canonical cwd of that session.
+* @throws {RootValidationError} `session-not-found` when the service is absent,
+*   the id does not name a live session, or that session has no cwd.
 */
-function primaryRootOf(ctx, request) {
-	if (request.primaryRoot !== void 0 && request.primaryRoot !== "") {
-		const canonical = canonicalRoot(expandRootInput(request.primaryRoot));
-		let isDirectory = false;
-		try {
-			isDirectory = statSync(canonical).isDirectory();
-		} catch {
-			isDirectory = false;
-		}
-		if (!isDirectory) throw new RootValidationError("missing", `"${request.primaryRoot}" is not an existing directory`, { reference: request.primaryRoot });
-		return canonical;
-	}
-	if (request.sessionId !== void 0 && request.sessionId !== "") {
-		const cwd = ctx.get("sessions")?.get(request.sessionId)?.header.cwd;
-		if (cwd !== void 0 && cwd !== "") return canonicalPath(cwd);
-	}
-	const policy = ctx.sandboxPolicy.resolve();
-	return canonicalRoot(policy.workspaceRoot);
+function resolvePanelPrimaryRoot(ctx, sessionId) {
+	const session = ctx.get("sessions")?.get(sessionId);
+	const cwd = session?.header.cwd;
+	if (session === void 0 || cwd === void 0 || cwd === "") throw new RootValidationError("session-not-found", `session "${sessionId}" is not an active host session`, { reference: sessionId });
+	return canonicalPath(cwd);
 }
 /** Project one status into the panel's view. */
 function toRootView(status, index) {
@@ -589,7 +552,7 @@ async function dispatchPanelRequest(ctx, endpoint, payload, _signal) {
 		};
 		const request = parsed.value;
 		const registry = ctx.multiRootRegistry;
-		const primaryRoot = primaryRootOf(ctx, request);
+		const primaryRoot = resolvePanelPrimaryRoot(ctx, request.sessionId);
 		switch (request.endpoint) {
 			case "list": return {
 				ok: true,
@@ -724,4 +687,4 @@ async function revealRoot(ctx, path) {
 	if (outcome.exitCode !== 0) throw new RootValidationError("reveal-unavailable", `the file manager exited with ${String(outcome.exitCode)}`);
 }
 //#endregion
-export { renderRootsReport as a, PANEL_ENDPOINTS as c, parseRootsView as d, parseFoldersCommand as i, parsePanelCall as l, apply as n, revealArgv as o, inject as r, PANEL_CHANNEL as s, COMMAND_NAME as t, parseRevealedView as u };
+export { renderRootsReport as a, PANEL_CHANNEL as c, parseRevealedView as d, parseRootsView as f, parseFoldersCommand as i, PANEL_ENDPOINTS as l, apply as n, resolvePanelPrimaryRoot as o, inject as r, revealArgv as s, COMMAND_NAME as t, parsePanelCall as u };

package/lib/command.js

@@ -1,2 +1,2 @@
-import { a as renderRootsReport, i as parseFoldersCommand, n as apply, o as revealArgv, r as inject, t as COMMAND_NAME } from "./command-BSkrYOAf.js";
-export { COMMAND_NAME, apply, inject, parseFoldersCommand, renderRootsReport, revealArgv };
+import { a as renderRootsReport, i as parseFoldersCommand, n as apply, o as resolvePanelPrimaryRoot, r as inject, s as revealArgv, t as COMMAND_NAME } from "./command-DyOWujPo.js";
+export { COMMAND_NAME, apply, inject, parseFoldersCommand, renderRootsReport, resolvePanelPrimaryRoot, revealArgv };

package/lib/compat-nFYqN5wt.js

@@ -0,0 +1,267 @@
+import { createRequire } from "node:module";
+import { Service } from "@deepseek-ai/cordis";
+//#region src/compat/dsh-version.ts
+/**
+* The DSH compatibility contract: which upstream releases this plugin is
+* actually verified against, and how an installation is judged against that
+* list.
+*
+* This module is the ONE place the support matrix is spelled out. It is
+* deliberately pure — no cordis, no logging, no process exit — so that the
+* runtime gate (`src/compat.ts`), the static gate (`scripts/check-dsh-compat.mjs`)
+* and the tests all judge an installation by the same code instead of three
+* drifting copies of the same list.
+*
+* Why a contract exists at all: this plugin replaces `ctx.fs` and `ctx.sandbox`
+* with subclasses of the upstream providers, and `src/dialects.ts` recognizes
+* the kernel-sandbox profile by OBSERVING the argv shape `super.confine`
+* produced (ADR-0003). Both couplings are to pre-stable upstream internals that
+* carry no semver promise. An npm range like `>=0.1.2-alpha.4 <0.2.0` therefore
+* promises far more than the code was ever verified against; the allowlist
+* below promises exactly what CI has run.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/dsh-version
+*/
+/**
+* The releases this plugin is verified against, as EXACT version strings.
+*
+* Not a semver range, on purpose: a range is a prediction about releases that
+* do not exist yet, and this plugin's coupling to upstream argv shapes makes
+* that prediction unsafe. Adding an entry is always a human act performed after
+* the upgrade smoke passed on that exact version — a green CI run on an
+* unlisted release is evidence, not authorization (ADR-0009).
+*/
+const SUPPORTED_DSH_RELEASES = ["0.1.5-rc.2", "0.1.6-alpha.1"];
+/**
+* Packages whose absence means this plugin cannot function at all: every one of
+* them is either subclassed, imported for a value, or the owner of a service
+* key the providers inject.
+*/
+const REQUIRED_CORE_PACKAGES = [
+	"@deepseek-ai/dsh-fs",
+	"@deepseek-ai/dsh-fs-local",
+	"@deepseek-ai/dsh-sandbox",
+	"@deepseek-ai/dsh-sandbox-local",
+	"@deepseek-ai/dsh-sandbox-policy",
+	"@deepseek-ai/dsh-storage-domain"
+];
+/**
+* Packages a full composition provides and a minimal one legitimately omits.
+* Absence is fine; a version that DISAGREES with the required packages is not —
+* that is the mixed-installation failure this contract exists to catch.
+*/
+const OPTIONAL_CORE_PACKAGES = [
+	"@deepseek-ai/dsh-agent",
+	"@deepseek-ai/dsh-agent-instructions",
+	"@deepseek-ai/dsh-client-connection",
+	"@deepseek-ai/dsh-commands",
+	"@deepseek-ai/dsh-llm",
+	"@deepseek-ai/dsh-session",
+	"@deepseek-ai/dsh-subprocess",
+	"@deepseek-ai/dsh-system-prompt"
+];
+/** Every package the contract inspects, required first. */
+const CORE_PACKAGES = [...REQUIRED_CORE_PACKAGES, ...OPTIONAL_CORE_PACKAGES];
+/** The environment variable that relaxes the gate. */
+const COMPAT_ENFORCEMENT_ENV = "DSH_MULTI_ROOT_COMPAT";
+/**
+* Read one package's declared version through Node resolution.
+*
+* Resolution runs from THIS module, which is what makes the answer meaningful:
+* the upstream packages are peer dependencies, so they resolve to the single
+* copy the host provides — the same copy the providers will subclass at
+* runtime. A package that cannot be resolved is reported absent rather than
+* throwing, because "not installed" is a legitimate answer for every optional
+* package.
+* @param packageName - the package to inspect.
+* @returns the declared version, or `undefined` when the package or its
+*   manifest cannot be resolved.
+*/
+function readInstalledVersion(packageName) {
+	try {
+		const manifest = createRequire(import.meta.url)(`${packageName}/package.json`);
+		return typeof manifest.version === "string" ? manifest.version : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Judge one installation against the contract.
+*
+* The three checks run in this order, and the first failure wins, because each
+* later check would report nonsense about an installation that failed an
+* earlier one: a missing required package has no version to compare, and a
+* mixed installation has no single version to look up in the allowlist.
+* @param readVersion - version reader; defaults to Node resolution. Tests and
+*   the static checker pass their own.
+* @returns the report; never throws.
+*/
+function classifyInstallation(readVersion = readInstalledVersion) {
+	const packages = CORE_PACKAGES.map((name) => ({
+		name,
+		version: readVersion(name),
+		required: REQUIRED_CORE_PACKAGES.includes(name)
+	}));
+	const missing = packages.filter((entry) => entry.required && entry.version === void 0);
+	if (missing.length > 0) return report("incomplete", void 0, packages, [
+		"multi-root workspace: required DSH packages are not installed.",
+		"",
+		...missing.map((entry) => `  missing: ${entry.name}`)
+	]);
+	const releases = [...new Set(packages.flatMap((entry) => entry.version === void 0 ? [] : [entry.version]))].sort();
+	const [release, ...extra] = releases;
+	if (release === void 0) return report("incomplete", void 0, packages, ["multi-root workspace: no DSH package could be inspected."]);
+	if (extra.length > 0) return report("mixed", void 0, packages, [
+		"multi-root workspace: this installation mixes several DSH releases.",
+		"",
+		"The filesystem fence and the kernel-sandbox dialects must agree on one upstream",
+		"release; a mixed installation means one half of the sandbox was verified against a",
+		"shape the other half no longer produces. Align every @deepseek-ai/dsh* package on",
+		"one release.",
+		"",
+		`  releases found: ${releases.join(", ")}`
+	]);
+	if (!SUPPORTED_DSH_RELEASES.includes(release)) return report("unsupported", release, packages, [
+		`multi-root workspace: DSH ${release} is not a supported release.`,
+		"",
+		"This plugin replaces the workspace filesystem fence and the kernel-sandbox provider,",
+		"and it recognizes the sandbox profile by the argv shape the upstream provider produces.",
+		"Upstream makes no semver promise, so the plugin refuses to grant additional roots on a",
+		"release it has never been verified against rather than guess at that shape.",
+		"",
+		`  supported: ${SUPPORTED_DSH_RELEASES.join(", ")}`,
+		`  installed: ${release}`
+	]);
+	return report("supported", release, packages, [`multi-root workspace: DSH ${release} is a supported release.`]);
+}
+/**
+* Read the enforcement mode.
+*
+* `warn` exists for exactly one caller: the upgrade smoke, which must run the
+* whole behavior matrix against a release that is deliberately NOT on the
+* allowlist yet — that run is how a release earns its place on the list. It is
+* not a production escape hatch, and the warning says so.
+* @param env - the environment to read; defaults to this process's.
+* @returns `warn` only when explicitly requested, `enforce` otherwise.
+*/
+function compatEnforcement(env = process.env) {
+	return env["DSH_MULTI_ROOT_COMPAT"] === "warn" ? "warn" : "enforce";
+}
+/** Compose a report, appending the package inventory and the recovery pointer. */
+function report(verdict, release, packages, lines) {
+	return {
+		verdict,
+		release,
+		packages,
+		message: (verdict === "supported" ? [...lines] : [
+			...lines,
+			"",
+			"Inspected packages:",
+			...packages.map((entry) => `  ${entry.name} ${entry.version ?? "(not installed)"}`),
+			"",
+			"See docs/troubleshooting/unsupported-dsh-release.md"
+		]).join("\n")
+	};
+}
+//#endregion
+//#region src/compat.ts
+/**
+* `multi-root-compat`: the startup gate that turns the DSH compatibility
+* contract from documentation into a precondition.
+*
+* The four security-relevant rows of this bundle — `multi-root-fs`,
+* `multi-root-sandbox`, `multi-root-registry`, `multi-root-instructions` —
+* inject `multiRootCompat`. Cordis will not start a plugin whose injected
+* service is absent, so this row is what decides whether they run at all:
+*
+* ```text
+* compat check passes  →  ctx.multiRootCompat exists  →  the providers start
+* compat check fails   →  the row throws             →  they never start
+* ```
+*
+* That is why the gate is a plain `apply` and not a `Service` subclass mounted
+* directly: the check has to be able to fail BEFORE the service exists. A
+* `Service` constructor has already run `super(ctx, name)` — and therefore
+* already claimed the service key — by the time it could inspect anything.
+*
+* The verdict itself, and the allowlist it is judged against, live in
+* `./compat/dsh-version.ts`. This module owns only the reaction to it.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat
+*/
+/**
+* Raised when the installed DSH release is not one this plugin is verified
+* against. It is thrown from `apply`, so it surfaces as a plugin load failure
+* with the full diagnosis attached — never as a silently degraded sandbox.
+*/
+var DshCompatUnsupportedError = class extends Error {
+	/** The report that produced the refusal. */
+	report;
+	constructor(report) {
+		super(report.message);
+		this.name = "DshCompatUnsupportedError";
+		this.report = report;
+	}
+};
+/**
+* The `ctx.multiRootCompat` service: the resolved compatibility verdict, held
+* where the gated providers can read it.
+*
+* It intentionally exposes no per-version capability flags. The adapters under
+* `./compat/` detect the shape they need STRUCTURALLY — whether a return value
+* is a thenable, which export name a module carries — because a structural
+* probe also survives upstream reshaping something within one release, while a
+* version comparison does not. The release string here is for the gate and for
+* diagnostics.
+*/
+var MultiRootCompatService = class extends Service {
+	/** The verdict this composition started under. */
+	report;
+	constructor(ctx, report) {
+		super(ctx, "multiRootCompat");
+		this.report = report;
+	}
+	/** The single DSH release every inspected core package agreed on. */
+	get release() {
+		return this.report.release;
+	}
+	/** Whether the installation is on the allowlist. */
+	get supported() {
+		return this.report.verdict === "supported";
+	}
+};
+/** This row needs nothing: it is the thing everything else waits for. */
+const inject = [];
+/**
+* Apply the gate policy to one report.
+*
+* Under `DSH_MULTI_ROOT_COMPAT=warn` exactly one verdict is relaxed: an
+* `unsupported` release that every inspected package agrees on. That is the
+* only shape the upgrade smoke probes — a coherent tree on a release the
+* allowlist does not name yet, which is how a release earns its place there.
+* `mixed` and `incomplete` describe an installation the contract cannot judge
+* at all, so they are refused in either mode; production deployments leave the
+* variable unset and get the refusal for everything.
+* @param report - the verdict to act on.
+* @param enforcement - how to react to a non-`supported` verdict.
+* @returns the warning to log, or `undefined` when there is nothing to say.
+* @throws {DshCompatUnsupportedError} when refusing to run.
+*/
+function assertSupportedInstallation(report, enforcement) {
+	if (report.verdict === "supported") return void 0;
+	if (enforcement === "enforce" || report.verdict !== "unsupported") throw new DshCompatUnsupportedError(report);
+	return `${report.message}\n\nProceeding anyway because ${COMPAT_ENFORCEMENT_ENV}=warn. This is an upgrade-smoke mode: additional workspace roots are about to be granted through a sandbox profile shape that has not been verified on this release. Supported releases: ${SUPPORTED_DSH_RELEASES.join(", ")}.`;
+}
+/**
+* Judge the installation, then either refuse to provide the service or provide
+* it.
+* @param ctx - the row's context.
+*/
+function apply(ctx) {
+	const report = classifyInstallation();
+	const warning = assertSupportedInstallation(report, compatEnforcement());
+	if (warning !== void 0) ctx.logger.warn(warning);
+	ctx.plugin(MultiRootCompatService, report);
+}
+//#endregion
+export { inject as a, REQUIRED_CORE_PACKAGES as c, compatEnforcement as d, readInstalledVersion as f, assertSupportedInstallation as i, SUPPORTED_DSH_RELEASES as l, MultiRootCompatService as n, CORE_PACKAGES as o, apply as r, OPTIONAL_CORE_PACKAGES as s, DshCompatUnsupportedError as t, classifyInstallation as u };

package/lib/compat.js

@@ -0,0 +1,2 @@
+import { a as inject, i as assertSupportedInstallation, n as MultiRootCompatService, r as apply, t as DshCompatUnsupportedError } from "./compat-nFYqN5wt.js";
+export { DshCompatUnsupportedError, MultiRootCompatService, apply, assertSupportedInstallation, inject };

package/lib/{fs-D7UoCb7T.js → fs-D_Sw3o5z.js}

@@ -1,8 +1,8 @@
+import { dirname, sep } from "node:path";
+import { writableRoots } from "@deepseek-ai/dsh-sandbox";
 import { FsError } from "@deepseek-ai/dsh-fs";
 import { LocalFileSystem } from "@deepseek-ai/dsh-fs-local";
-import { writableRoots } from "@deepseek-ai/dsh-sandbox";
 import { stat } from "node:fs/promises";
-import { dirname, sep } from "node:path";
 //#region src/containment.ts
 const MISSING_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
 function isMissing(error) {
@@ -64,7 +64,11 @@ async function isPathUnder(path, root, caseSensitive = process.platform !== "win
 * roots.
 */
 var MultiRootFileSystem = class extends LocalFileSystem {
-	static inject = ["sandboxPolicy", "multiRootScope"];
+	static inject = [
+		"multiRootCompat",
+		"sandboxPolicy",
+		"multiRootScope"
+	];
 	defaultMode;
 	constructor(ctx, config) {
 		super(ctx, config);

package/lib/fs.js

@@ -1,2 +1,2 @@
-import { t as MultiRootFileSystem } from "./fs-D7UoCb7T.js";
+import { t as MultiRootFileSystem } from "./fs-D_Sw3o5z.js";
 export { MultiRootFileSystem, MultiRootFileSystem as default };

package/lib/index.js

@@ -1,9 +1,11 @@
-import { t as MultiRootFileSystem } from "./fs-D7UoCb7T.js";
-import { t as MultiRootSandboxProvider } from "./sandbox-BhuMTDgH.js";
+import { c as REQUIRED_CORE_PACKAGES, d as compatEnforcement, f as readInstalledVersion, i as assertSupportedInstallation, l as SUPPORTED_DSH_RELEASES, n as MultiRootCompatService, o as CORE_PACKAGES, s as OPTIONAL_CORE_PACKAGES, t as DshCompatUnsupportedError, u as classifyInstallation } from "./compat-nFYqN5wt.js";
+import { a as composeInstructionMessage, c as createInstructionMessage, l as instructionsApi, r as PLUGIN_SOURCE, t as DEFAULT_MAX_BYTES, u as renderInstructions } from "./instructions-BRGoC82G.js";
+import { n as widenConfined, t as MultiRootSandboxProvider } from "./sandbox-D8Fw95FM.js";
+import { a as classifyStoredRoots, c as indexedStatuses, f as resolveRootRef, i as canonicalRoot, l as isCanonicallyUnder, n as additionalRootId, p as validateRootCandidate, r as availableRoots, s as expandRootInput, t as RootValidationError, u as removeStatusAt } from "./roots-DasWEBJk.js";
+import { t as MultiRootFileSystem } from "./fs-D_Sw3o5z.js";
 import { MultiRootScopeService, renderWorkspaceRootsContext, sanitizeAdditionalRoots } from "./scope.js";
-import { a as classifyStoredRoots, c as indexedStatuses, f as resolveRootRef, i as canonicalRoot, l as isCanonicallyUnder, n as additionalRootId, p as validateRootCandidate, r as availableRoots, s as expandRootInput, t as RootValidationError, u as removeStatusAt } from "./roots-DyT2jgEP.js";
-import { DOMAIN_NAME, MAX_ALIAS_LENGTH, MultiRootRegistry, multiRootDomainSpec } from "./registry.js";
-import { a as renderRootsReport, c as PANEL_ENDPOINTS, d as parseRootsView, i as parseFoldersCommand, l as parsePanelCall, o as revealArgv, s as PANEL_CHANNEL, t as COMMAND_NAME, u as parseRevealedView } from "./command-BSkrYOAf.js";
+import { c as RegistryLeaseContendedError, i as REGISTRY_CONTENDED_MESSAGE, n as MAX_ALIAS_LENGTH, o as multiRootDomainSpec, r as MultiRootRegistry, s as RegistryAuthorityLease, t as DOMAIN_NAME } from "./registry-DySMbjgW.js";
+import { a as renderRootsReport, c as PANEL_CHANNEL, d as parseRevealedView, f as parseRootsView, i as parseFoldersCommand, l as PANEL_ENDPOINTS, o as resolvePanelPrimaryRoot, s as revealArgv, t as COMMAND_NAME, u as parsePanelCall } from "./command-DyOWujPo.js";
 //#region src/index.ts
 /**
 * Carrier plugin face for the bare-package-name loader row (see the module
@@ -14,4 +16,4 @@ import { a as renderRootsReport, c as PANEL_ENDPOINTS, d as parseRootsView, i as
 const inject = [];
 function apply() {}
 //#endregion
-export { COMMAND_NAME, DOMAIN_NAME, MAX_ALIAS_LENGTH, MultiRootFileSystem, MultiRootRegistry, MultiRootSandboxProvider, MultiRootScopeService, PANEL_CHANNEL, PANEL_ENDPOINTS, RootValidationError, additionalRootId, apply, availableRoots, canonicalRoot, classifyStoredRoots, expandRootInput, indexedStatuses, inject, isCanonicallyUnder, multiRootDomainSpec, parseFoldersCommand, parsePanelCall, parseRevealedView, parseRootsView, removeStatusAt, renderRootsReport, renderWorkspaceRootsContext, resolveRootRef, revealArgv, sanitizeAdditionalRoots, validateRootCandidate };
+export { COMMAND_NAME, CORE_PACKAGES, DEFAULT_MAX_BYTES, DOMAIN_NAME, DshCompatUnsupportedError, MAX_ALIAS_LENGTH, MultiRootCompatService, MultiRootFileSystem, MultiRootRegistry, MultiRootSandboxProvider, MultiRootScopeService, OPTIONAL_CORE_PACKAGES, PANEL_CHANNEL, PANEL_ENDPOINTS, PLUGIN_SOURCE, REGISTRY_CONTENDED_MESSAGE, REQUIRED_CORE_PACKAGES, RegistryAuthorityLease, RegistryLeaseContendedError, RootValidationError, SUPPORTED_DSH_RELEASES, additionalRootId, apply, assertSupportedInstallation, availableRoots, canonicalRoot, classifyInstallation, classifyStoredRoots, compatEnforcement, composeInstructionMessage, createInstructionMessage, expandRootInput, indexedStatuses, inject, instructionsApi, isCanonicallyUnder, multiRootDomainSpec, parseFoldersCommand, parsePanelCall, parseRevealedView, parseRootsView, readInstalledVersion, removeStatusAt, renderInstructions, renderRootsReport, renderWorkspaceRootsContext, resolvePanelPrimaryRoot, resolveRootRef, revealArgv, sanitizeAdditionalRoots, validateRootCandidate, widenConfined };