dsh-win-multi-bash 0.1.0

package/lib/bash-wsl/index.js

@@ -0,0 +1,335 @@
+import { spawnSync } from "node:child_process";
+import z from "@deepseek-ai/schemastery";
+import { LocalBashExecutor } from "@deepseek-ai/dsh-bash-local";
+import { classifyDenial, classifyRunnerFailure, matchesSignature } from "../vendor/helpers.js";
+import { BWRAP_RUNNER_FAILURE_RULES, bwrapProfileArgs } from "../vendor/bwrap-profiles.js";
+import { lstatSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * The bwrap denial dialect: a denied file effect prints this signature on
+ * stderr (mirrors DENIAL_SIGNATURES.bwrap in the base sandbox-local), so the
+ * sandbox facts the tool renders can report `denied` instead of always false.
+ */
+const BWRAP_DENIAL_SIGNATURES = ["read-only file system"];
+/**
+ * Derive a config schema from a base object schema WITHOUT mutating it.
+ * schemastery's Schema#set() mutates the shared `dict` in place, so chaining
+ * .set() on LocalBashExecutor.Config lets whichever subclass module loads
+ * last overwrite the earlier one's fields — git-bash's probeTimeoutMs default
+ * silently became wsl-bash's 30000 and its sandbox union gained the invalid
+ * 'bwrap' value. Spreading the base dict into a fresh z.object makes every
+ * derivation independent of both the base and other subclasses.
+ */
+function deriveConfig(base, fields) {
+	const derived = z.object({ ...base.dict });
+	if (base.meta !== void 0) derived.meta = { ...base.meta };
+	for (const key of Object.keys(fields)) derived.set(key, fields[key]);
+	return derived;
+}
+//#region lib/types/resolve.js
+/**
+* WSL executable and distro resolution for the bash-wsl executor, dependency-free
+* and parameterized (env/platform) so resolution is a pure function of its
+* inputs on every platform — the twin of dsh-bash-git's resolveBashPath and
+* dsh-pwsh-local's resolvePwshPath.
+* @module @deepseek-ai/dsh-bash-wsl/resolve
+*/
+/**
+* Well-known WSL executable locations: System32 (the shipped wsl.exe) plus
+* PATH entries.
+* @param env - the environment to probe; defaults to the process environment.
+* @returns candidate `wsl.exe` paths in resolution order.
+*/
+function candidateWslPaths(env = process.env) {
+	const candidates = [join(env.SystemRoot ?? "C:\\Windows", "System32", "wsl.exe")];
+	for (const entry of (env.PATH ?? "").split(";")) {
+		const trimmed = entry.trim().replace(/^"|"$/g, "");
+		if (trimmed.length === 0) continue;
+		candidates.push(join(trimmed, "wsl.exe"));
+	}
+	return candidates;
+}
+function candidateExists(candidate) {
+	try {
+		const stat = lstatSync(candidate);
+		return stat.isFile() || stat.isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve the wsl.exe executable this executor spawns. Returns undefined on
+* win32 when no candidate exists (the executor turns that into a loud
+* route-time error naming the probes); non-win32 hosts resolve a bare
+* `wsl` for PATH resolution, mirroring resolvePwshPath.
+* @param configured - an explicit `wslPath` config value, trusted as-is.
+* @param env - the environment to probe on Windows; defaults to the process environment.
+* @param platform - the platform to resolve for; defaults to the process platform.
+* @returns the first existing well-known location on win32, else `wsl`, else undefined.
+*/
+function resolveWslPath(configured, env = process.env, platform = process.platform) {
+	if (configured !== void 0 && configured.length > 0) return configured;
+	if (platform === "win32") {
+		for (const candidate of candidateWslPaths(env)) if (candidateExists(candidate)) return candidate;
+		return;
+	}
+	return "wsl";
+}
+/**
+* Parse `wsl -l -q` output into distro names. wsl.exe writes UTF-16LE with
+* null-byte interleaving when stdout is redirected, so NUL bytes are stripped
+* before splitting; surrounding quotes and blank lines are dropped.
+* @param output - raw `-l -q` stdout.
+* @returns distro names in output order.
+*/
+function parseWslDistroList(output) {
+	const distros = [];
+	for (const raw of output.replace(/\0/g, "").split(/\r?\n/)) {
+		const line = raw.trim().replace(/^"|"$/g, "");
+		if (line.length === 0) continue;
+		distros.push(line);
+	}
+	return distros;
+}
+/**
+* Convert a Windows drive-letter path to the WSL /mnt/<drive>/... form used
+* as the bwrap workspace root inside the distro. Anything without a
+* drive-letter form fails loud: wsl.exe's own `--cd` translation covers
+* workdirs, but the bwrap profile needs an explicit Linux-side root.
+* @param winPath - the Windows path to convert.
+* @returns the Linux-side path.
+* @throws Error when the path has no drive-letter form.
+*/
+function toWslPath(winPath) {
+	const match = /^([A-Za-z]):[\\/](.+)$/.exec(winPath);
+	if (match === null) throw new Error(`unsupported Windows path: ${winPath}`);
+	const drive = match[1];
+	const rest = match[2];
+	/* v8 ignore next -- the regex guarantees both captures whenever it matches */
+	if (drive === void 0 || rest === void 0) throw new Error(`unsupported Windows path: ${winPath}`);
+	return `/mnt/${drive.toLowerCase()}/${rest.replaceAll("\\", "/")}`;
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* WSL Service Provider for the bash capability seam: a LocalBashExecutor
+* whose argv is `[wslPath, --cd workdir?, -d distro?, --, bash, -c, payload]`.
+* The command rides as a base64 payload through `echo <b64> | base64 -d | bash`
+* so wsl.exe's Windows→Linux argument serialization can never damage quotes.
+* Sandbox: `auto` probes bubblewrap inside the distro (once, lazily, at the
+* first sandboxMode read or the first command) and runs unconfined without
+* sandbox facts when absent; `bwrap` fails loud at first use when the probe
+* fails; `none` never probes or confines.
+* @module @deepseek-ai/dsh-bash-wsl
+*/
+/**
+* WSL executor over the local bash mechanics: argv is the resolved wsl.exe
+* followed by `--cd`/`-d`/`--` `bash -c` with the base64 payload, and the
+* sandbox stance (`auto`/`bwrap`/`none`) is applied lazily per the module
+* doc's probe contract.
+*/
+var WslBashExecutor = class extends LocalBashExecutor {
+	static Config = deriveConfig(LocalBashExecutor.Config, {
+		wslPath: z.string(),
+		wslDistro: z.string(),
+		sandbox: z.union([
+			z.const("auto"),
+			z.const("none"),
+			z.const("bwrap")
+		]).default("auto"),
+		probeTimeoutMs: z.natural().default(3e4),
+		requireSandbox: z.boolean().default(false)
+	});
+	/** Test hook mirroring the sandbox-local internals pattern. */
+	internals = {};
+	sandboxStance;
+	probeTimeoutMs;
+	bwrapVerdict;
+	distroProbed = false;
+	distroVerdict;
+	constructor(ctx, config) {
+		super(ctx, config);
+		const entry = config;
+		this.sandboxStance = entry.sandbox;
+		this.probeTimeoutMs = entry.probeTimeoutMs;
+		this.requireSandbox = entry.requireSandbox;
+	}
+	/**
+	 * The capability fact: the policy default mode while bwrap is usable. With
+	 * `requireSandbox`, the mode is declared even when the probe fails, so the
+	 * tool layer advertises escalation (`sandbox_permissions`) and the executor
+	 * can refuse unconfined runs outside danger-full-access.
+	 */
+	get sandboxMode() {
+		if (this.sandboxStance === "none") return void 0;
+		if (this.requireSandbox) return this.ctx.sandboxPolicy.defaultMode;
+		return this.requireBwrapUsable() ? this.ctx.sandboxPolicy.defaultMode : void 0;
+	}
+	/** Auto: false means run unconfined. Explicit bwrap: a failed probe throws loud. */
+	requireBwrapUsable() {
+		if (this.probeBwrapOnce()) return true;
+		if (this.sandboxStance === "bwrap") throw new Error("bash-wsl: bwrap was not found in the WSL distro (explicit sandbox \"bwrap\" is configured); install bubblewrap or set sandbox: auto/none");
+		return false;
+	}
+	tryWslPath() {
+		return (this.internals.resolveWslPath ?? ((configured) => resolveWslPath(configured)))(this.config.wslPath);
+	}
+	wslPath() {
+		const path = this.tryWslPath();
+		if (path !== void 0) return path;
+		throw new Error(`bash-wsl: WSL was not found (probed ${candidateWslPaths().join(", ")}). Enable Windows Subsystem for Linux or set wslBash.wslPath.`);
+	}
+	probeDistroOnce() {
+		if (!this.distroProbed) {
+			this.distroProbed = true;
+			const probe = this.internals.probeDistro;
+			if (probe !== void 0) return this.distroVerdict = probe();
+			const wsl = this.tryWslPath();
+			if (wsl === void 0) {
+				this.distroVerdict = void 0;
+				/* v8 ignore next 2 -- every executor path resolves wslPath before this probe, so the guard is defensive only. */
+				return;
+			}
+			const run = spawnSync(wsl, ["-l", "-q"], {
+				timeout: this.probeTimeoutMs,
+				encoding: "utf8"
+			});
+			this.distroVerdict = run.status === 0 ? parseWslDistroList(run.stdout)[0] : void 0;
+		}
+		return this.distroVerdict;
+	}
+	distro() {
+		return this.config.wslDistro ?? this.probeDistroOnce();
+	}
+	probeBwrapOnce() {
+		if (this.bwrapVerdict !== void 0) return this.bwrapVerdict;
+		const probe = this.internals.probeBwrap;
+		if (probe !== void 0) return this.bwrapVerdict = probe();
+		const wsl = this.tryWslPath();
+		if (wsl === void 0) return this.bwrapVerdict = false;
+		const distro = this.distro();
+		const run = spawnSync(wsl, [
+			...distro !== void 0 ? ["-d", distro] : [],
+			"-e",
+			"bash",
+			"-c",
+			"command -v bwrap"
+		], {
+			timeout: this.probeTimeoutMs,
+			stdio: "ignore"
+		});
+		return this.bwrapVerdict = run.status === 0;
+	}
+	payload(command) {
+		return `echo ${Buffer.from(command, "utf8").toString("base64")} | base64 -d | bash`;
+	}
+	/** The workdir `resolve()` fills when a request omits one. */
+	defaultWorkdir() {
+		return this.config.cwd ?? process.cwd();
+	}
+	/**
+	* The plain WSL argv for one spec (no sandbox). `--cd` is passed only when
+	* the workdir differs from the default, so the subprocess cwd and the WSL
+	* start directory agree without a redundant wsl.exe translation; a Linux
+	* workdir passes through verbatim.
+	*/
+	argv(spec) {
+		const head = [this.wslPath()];
+		if (spec.workdir !== this.defaultWorkdir()) head.push("--cd", spec.workdir);
+		const distro = this.distro();
+		if (distro !== void 0) head.push("-d", distro);
+		head.push("--", "bash", "-c", this.payload(spec.command));
+		return head;
+	}
+	confinedPolicy(spec) {
+		return spec.sandboxPolicy ?? this.ctx.sandboxPolicy.resolve();
+	}
+	/** The bwrap-wrapped argv; the workspace root is translated to its /mnt/<drive> form. */
+	bwrapArgv(spec) {
+		const policy = this.confinedPolicy(spec);
+		const linuxRoot = toWslPath(policy.workspaceRoot);
+		const head = [this.wslPath()];
+		if (spec.workdir !== this.defaultWorkdir()) head.push("--cd", spec.workdir);
+		const distro = this.distro();
+		if (distro !== void 0) head.push("-d", distro);
+		const mode = policy.mode;
+		head.push("--", "bwrap", ...bwrapProfileArgs({
+			mode,
+			workspaceRoot: linuxRoot
+		}), "bash", "-c", this.payload(spec.command));
+		return head;
+	}
+	async run(spec) {
+		const policy = this.confinedPolicy(spec);
+		if (policy.mode === "danger-full-access") return {
+			...await this.runArgv(spec, this.argv(spec)),
+			sandbox: {
+				mode: "danger-full-access",
+				denied: false
+			}
+		};
+		if (this.sandboxStance === "none") return this.runArgv(spec, this.argv(spec));
+		if (!this.requireBwrapUsable()) {
+			if (this.requireSandbox) throw new Error("bash-wsl: sandbox unavailable — bwrap was not found in the WSL distro; refusing to run unconfined under " + policy.mode + " mode. Install bubblewrap or retry the command with sandbox_permissions: \"danger-full-access\" and a justification.");
+			return this.runArgv(spec, this.argv(spec));
+		}
+		const result = await this.runArgv(spec, this.bwrapArgv(spec));
+		if (classifyRunnerFailure(result.exitCode, result.stderr.text, BWRAP_RUNNER_FAILURE_RULES) !== void 0) return {
+			...result,
+			sandbox: {
+				mode: policy.mode,
+				denied: false,
+				enforcement: "full",
+				runnerFailed: true
+			}
+		};
+		return {
+			...result,
+			sandbox: {
+				mode: policy.mode,
+				denied: classifyDenial(result, BWRAP_DENIAL_SIGNATURES),
+				enforcement: "full"
+			}
+		};
+	}
+	/** Per-process confinement facts retained until settlement (bash-sandbox pattern). */
+	processFacts = /* @__PURE__ */ new Map();
+	start(spec) {
+		const policy = this.confinedPolicy(spec);
+		if (policy.mode === "danger-full-access") return this.startArgv(spec, this.argv(spec));
+		if (this.sandboxStance === "none") return this.startArgv(spec, this.argv(spec));
+		if (!this.requireBwrapUsable()) {
+			if (this.requireSandbox) throw new Error("bash-wsl: sandbox unavailable — bwrap was not found in the WSL distro; refusing to run unconfined under " + policy.mode + " mode. Install bubblewrap or retry the command with sandbox_permissions: \"danger-full-access\" and a justification.");
+			return this.startArgv(spec, this.argv(spec));
+		}
+		const proc = this.startArgv(spec, this.bwrapArgv(spec));
+		this.processFacts.set(proc, { mode: policy.mode });
+		return proc;
+	}
+	/** Stamp per-process sandbox facts before `done` settles (bash-sandbox semantics). */
+	onProcessDone(proc, stderr, spawnFailed, spawnError) {
+		const facts = this.processFacts.get(proc);
+		if (facts !== void 0) {
+			this.processFacts.delete(proc);
+			proc.sandbox = classifyRunnerFailure(proc.exitCode, stderr, BWRAP_RUNNER_FAILURE_RULES) !== void 0 ? {
+				mode: facts.mode,
+				denied: false,
+				enforcement: "full",
+				runnerFailed: true
+			} : {
+				mode: facts.mode,
+				denied: matchesSignature(proc.exitCode, stderr, BWRAP_DENIAL_SIGNATURES),
+				enforcement: "full"
+			};
+		}
+		super.onProcessDone(proc, stderr, spawnFailed, spawnError);
+	}
+	resolve(request) {
+		return {
+			...super.resolve(request),
+			sandboxPolicy: request.sandboxPolicy ?? this.ctx.sandboxPolicy.resolve()
+		};
+	}
+};
+//#endregion
+export { WslBashExecutor, WslBashExecutor as default };

package/lib/bash-wsl/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-bash-wsl`.
+* @module @deepseek-ai/dsh-bash-wsl/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-bash-wsl";
+/** Cordis companion plugin name. */
+const name = "bash-wsl-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this package exposes no independent event sequence or mutable data relation
+* beyond contracts enforced at its owning seam.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/index.js

@@ -0,0 +1,20 @@
+// dsh-win-multi-bash — self-contained Windows multi-bash plugin.
+//
+// This package carries the whole feature implementation, bundled from the
+// DeepSeek Harness project's shell packages (see THIRD_PARTY_NOTICES),
+// compiled to plain ESM JS:
+//
+//   lib/shell-select/   — ShellSelectExecutor (the ctx.shell selector)
+//   lib/bash-git/       — GitBashExecutor (MSYS / Git for Windows)
+//   lib/bash-wsl/       — WslBashExecutor (WSL distros, base64 payloads)
+//   lib/tool-bash/      — defineShellTool factory + git_bash / wsl_bash instances
+//   lib/vendor/         — helpers.js (bash-sandbox classification) and
+//                         bwrap-profiles.js (bwrap rules/args) — the two
+//                         helper modules not exported by the base runtime.
+//
+// Only published @deepseek-ai base packages are imported (dsh-shell,
+// dsh-sandbox, dsh-pwsh-sandbox, dsh-tools, dsh-llm, ...), so the plugin runs
+// on any standard deployment — no additional runtime packages required.
+//
+// The composition wiring lives in cordis.patch.yml.
+export {}

package/lib/shell-select/index.js

@@ -0,0 +1,169 @@
+import z from "@deepseek-ai/schemastery";
+import { HarnessError } from "@deepseek-ai/dsh-llm";
+import { SHELL_SETTINGS_NAMESPACE, ShellExecutor } from "@deepseek-ai/dsh-shell";
+import { installSettingsSection } from "@deepseek-ai/dsh-settings";
+import { GitBashExecutor } from "../bash-git/index.js";
+import { WslBashExecutor } from "../bash-wsl/index.js";
+import { SandboxPwshExecutor } from "@deepseek-ai/dsh-pwsh-sandbox";
+import { assertServiceableBashConfig } from "@deepseek-ai/dsh-bash-local";
+import { assertServiceablePwshConfig } from "@deepseek-ai/dsh-pwsh-local";
+//#region lib/types/index.js
+/**
+* Selector Service Provider for the bash capability seam: occupies the single
+* `ctx.shell` seat and routes each request to one of several backends held as
+* plain instances. The tool name selects the backend (`request.shell`); a
+* request without one goes to the configured `default`. Backends are
+* constructed on their own child fibers with isolated `shell`/`settings`
+* scopes so their inherited Service registration and settings wiring cannot
+* collide with this executor's own seat. win32 compositions only; POSIX
+* compositions keep a single backend directly on the seat.
+* @module @deepseek-ai/dsh-shell-select
+*/
+/** Error code for routing to an unknown or disabled backend. */
+const SHELL_BACKEND_UNAVAILABLE = "SHELL_BACKEND_UNAVAILABLE";
+const DEFAULT_FACTORIES = {
+	"git-bash": (ctx, config) => new GitBashExecutor(ctx, GitBashExecutor.Config(config)),
+	"wsl-bash": (ctx, config) => new WslBashExecutor(ctx, WslBashExecutor.Config(config)),
+	pwsh: (ctx, config) => new SandboxPwshExecutor(ctx, SandboxPwshExecutor.Config(config))
+};
+/**
+* Selector executor over the bash capability seam. Registers as `ctx.shell`
+* (the single seat), routes every request to one enabled backend by name, and
+* stamps the chosen name on the resolved spec as `shellBackend`. Enabled
+* names without a factory fail loud at the first rebuild; routing to an
+* unbuilt name throws `SHELL_BACKEND_UNAVAILABLE`.
+*/
+var ShellSelectExecutor = class ShellSelectExecutor extends ShellExecutor {
+	static inject = [
+		"subprocess",
+		"sandbox",
+		"sandboxPolicy"
+	];
+	static Config = z.object({
+		backends: z.array(z.string()).default([
+			"git-bash",
+			"wsl-bash",
+			"pwsh"
+		]),
+		default: z.string().default("pwsh"),
+		gitBash: GitBashExecutor.Config.default({}),
+		wslBash: WslBashExecutor.Config.default({}),
+		pwsh: SandboxPwshExecutor.Config.default({})
+	});
+	/** Test hook: replace backend construction wholesale (mirrors the sandbox-local internals pattern). */
+	internals = {};
+	/** The currently authoritative config: the settings section, or the composition entry. */
+	source;
+	backends = /* @__PURE__ */ new Map();
+	fibers = [];
+	constructor(ctx, config) {
+		super(ctx);
+		const entry = config;
+		assertServiceableBashConfig(entry.gitBash);
+		assertServiceableBashConfig(entry.wslBash);
+		assertServiceablePwshConfig(entry.pwsh);
+		this.source = () => entry;
+		installSettingsSection(ctx, SHELL_SETTINGS_NAMESPACE, ShellSelectExecutor.Config, entry, {
+			validate: (value) => {
+				const v = value;
+				assertServiceableBashConfig(v.gitBash);
+				assertServiceableBashConfig(v.wslBash);
+				assertServiceablePwshConfig(v.pwsh);
+			},
+			setSource: (current) => {
+				this.source = current;
+			},
+			onChange: () => {
+				this.rebuildBackends(this.config);
+			}
+		});
+	}
+	/** Validated config (schemastery applied the defaults before construction). */
+	get config() {
+		return this.source();
+	}
+	/**
+	* The first sandbox mode any enabled backend declares (tool-layer
+	* advertisement). One backend's probe/verdict failure (e.g. explicit
+	* `sandbox: bwrap` without bubblewrap installed) must not brick the whole
+	* selector: that backend advertises no mode here and its error resurfaces
+	* loudly at its first routed command — the documented lazy contract.
+	*/
+	get sandboxMode() {
+		this.ensureBackends();
+		for (const name of this.config.backends) {
+			let mode;
+			try {
+				mode = this.backends.get(name)?.sandboxMode;
+			} catch {
+				continue;
+			}
+			if (mode !== void 0) return mode;
+		}
+	}
+	resolve(request) {
+		this.ensureBackends();
+		const name = request.shell ?? this.config.default;
+		return {
+			...this.requireBackend(name).resolve(request),
+			shellBackend: name
+		};
+	}
+	run(spec) {
+		this.ensureBackends();
+		return this.requireBackend(spec.shellBackend ?? this.config.default).run(spec);
+	}
+	start(spec) {
+		this.ensureBackends();
+		return this.requireBackend(spec.shellBackend ?? this.config.default).start(spec);
+	}
+	requireBackend(name) {
+		const backend = this.backends.get(name);
+		if (backend === void 0) throw new HarnessError(`shell-select: backend "${name}" is not enabled (enabled: ${[...this.backends.keys()].join(", ")})`, SHELL_BACKEND_UNAVAILABLE);
+		return backend;
+	}
+	/** The first rebuild runs at first use, after the internals hook is installed. */
+	ensureBackends() {
+		if (this.backends.size > 0) return;
+		this.rebuildBackends(this.config);
+	}
+	/**
+	* Construct one backend per enabled name on its own child fiber with
+	* isolated shell/settings scopes (see the class doc), or throw for an
+	* unknown name. Old fibers are disposed first so rebuilds never leak.
+	*/
+	rebuildBackends(entry) {
+		for (const fiber of this.fibers.splice(0)) fiber.dispose();
+		this.backends.clear();
+		for (const name of entry.backends) {
+			const factory = this.internals.factories?.[name] ?? DEFAULT_FACTORIES[name];
+			if (factory === void 0) throw new Error(`shell-select: unknown backend "${name}" (enabled: ${entry.backends.join(", ")})`);
+			const fiber = this.ctx.plugin({
+				inject: [
+					"subprocess",
+					"sandbox",
+					"sandboxPolicy"
+				],
+				apply: () => {}
+			});
+			this.fibers.push(fiber);
+			const backendCtx = fiber.ctx.isolate("shell", Symbol(name)).isolate("settings", Symbol(name));
+			this.backends.set(name, factory(backendCtx, backendConfig(name, entry)));
+		}
+	}
+};
+/**
+* The config partition for one backend name. Names without a dedicated
+* partition (test-hook factories) receive an empty config; the owning factory
+* decides what it needs.
+*/
+function backendConfig(name, entry) {
+	switch (name) {
+		case "git-bash": return entry.gitBash;
+		case "wsl-bash": return entry.wslBash;
+		case "pwsh": return entry.pwsh;
+		default: return {};
+	}
+}
+//#endregion
+export { SHELL_BACKEND_UNAVAILABLE, ShellSelectExecutor, ShellSelectExecutor as default };

package/lib/shell-select/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-shell-select`.
+* @module @deepseek-ai/dsh-shell-select/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-shell-select";
+/** Cordis companion plugin name. */
+const name = "shell-select-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this package exposes no independent event sequence or
+* mutable data relation beyond contracts enforced at its owning seams.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };