better-dsh 0.3.0 → 0.3.1

package/lib/bundle-delivery.js

@@ -1,209 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import { mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
-
-//#region src/bundle-delivery.ts
-const name = "dashr-bundle-delivery";
-const inject = ["profileContext", "appReady"];
-const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
-const json = async (path$1) => JSON.parse(await readFile(path$1, "utf8"));
-async function optionalJson(path$1) {
-	try {
-		return await json(path$1);
-	} catch (error) {
-		if (error.code === "ENOENT") return void 0;
-		throw error;
-	}
-}
-async function contained(root, path$1) {
-	if (isAbsolute(path$1)) throw new Error("Pack delivery path must be relative");
-	const base = await realpath(root), file = await realpath(resolve(base, path$1));
-	const rel = relative(base, file);
-	if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) throw new Error("Pack delivery path escapes its owner");
-	return file;
-}
-/** A child process avoids inheriting a running HMR transaction's AsyncLocalStorage. */
-async function installNative(profile, archive, expected, signal) {
-	signal?.throwIfAborted();
-	const childScript = fileURLToPath(new URL("../scripts/register-bundle.mjs", import.meta.url));
-	return new Promise((done, fail) => {
-		const child = spawn(process.execPath, [childScript], {
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			cwd: profile.dir
-		});
-		let output = "", diagnostic = "";
-		const abort = () => {
-			child.kill("SIGTERM");
-		};
-		const timeout = setTimeout(abort, 36e4);
-		signal?.addEventListener("abort", abort, { once: true });
-		child.stdout.setEncoding("utf8").on("data", (chunk) => {
-			output = (output + chunk).slice(-32768);
-		});
-		child.stderr.setEncoding("utf8").on("data", (chunk) => {
-			diagnostic = (diagnostic + chunk).slice(-4096);
-		});
-		child.on("error", fail);
-		child.on("close", (code) => {
-			clearTimeout(timeout);
-			signal?.removeEventListener("abort", abort);
-			if (signal?.aborted) {
-				fail(signal.reason);
-				return;
-			}
-			if (code !== 0) {
-				fail(/* @__PURE__ */ new Error(`Native companion registration failed (${code}): ${diagnostic.trim() || output.trim()}`));
-				return;
-			}
-			try {
-				const result = JSON.parse(output);
-				if (result.exitCode !== 0) fail(/* @__PURE__ */ new Error(`Native companion registration failed (${result.exitCode}); diagnostics: ${result.logPath ?? "unavailable"}`));
-				else if (![
-					"installed",
-					"owner-changed",
-					"companion-changed",
-					"companion-removed"
-				].includes(result.disposition)) fail(/* @__PURE__ */ new Error("Native companion registration returned an invalid disposition"));
-				else done(result.disposition);
-			} catch (error) {
-				fail(error);
-			}
-		});
-		child.stdin.on("error", () => {});
-		child.stdin.end(JSON.stringify({
-			profile,
-			archive,
-			expected
-		}));
-	});
-}
-/** First registration enables a companion; native reconciliation preserves retained disablement. */
-async function reconcileBundledDelivery(profile, signal) {
-	const directory = join(profile.home, "bundle-artifacts");
-	await mkdir(directory, {
-		recursive: true,
-		mode: 448
-	});
-	const key = hash(profile.dir);
-	return withFileLock(join(directory, key + ".delivery"), async () => {
-		signal?.throwIfAborted();
-		const receiptPath = join(directory, key + ".json");
-		const receipts = await optionalJson(receiptPath) ?? {};
-		const manifest = await json(join(profile.dir, "package.json"));
-		const result = {
-			installed: [],
-			restartRequired: false
-		};
-		for (const owner of Object.keys(manifest.dependencies ?? {})) {
-			const ownerDir = join(profile.dir, "node_modules", owner);
-			const ownerManifest = await optionalJson(join(ownerDir, "package.json"));
-			if (ownerManifest?.superd?.delivery === void 0) continue;
-			const descriptorPath = await contained(ownerDir, ownerManifest.superd.delivery);
-			const descriptor = await json(descriptorPath);
-			if (!Array.isArray(descriptor.companions)) throw new Error("Invalid pack delivery descriptor");
-			for (const item of descriptor.companions) {
-				if (item.name !== "better-dsh" || item.version !== ownerManifest.dependencies?.[item.name] || !/^[a-f0-9]{64}$/.test(item.sha256)) throw new Error("Invalid companion identity/version/digest");
-				const bytes = await readFile(await contained(dirname(descriptorPath), item.tarball));
-				if (hash(bytes) !== item.sha256) throw new Error(`Pack companion SHA256 mismatch: ${item.name}`);
-				const archive = join(directory, `${item.name}-${item.sha256}.tgz`);
-				const cached = await optionalJson(join(profile.dir, "node_modules", item.name, "package.json"));
-				const current = await json(join(profile.dir, "package.json"));
-				const ownerSpec = current.dependencies?.[owner];
-				if (ownerSpec === void 0) continue;
-				const priorSpec = current.dependencies?.[item.name];
-				const receiptKey = `${owner}:${item.name}`;
-				if (priorSpec === void 0 && receipts[receiptKey] === item.sha256) continue;
-				if (priorSpec === "file:" + archive && cached?.name === item.name && cached.version === item.version) {
-					receipts[receiptKey] = item.sha256;
-					await writeFileAtomic(receiptPath, JSON.stringify(receipts) + "\n", { mode: 384 });
-					continue;
-				}
-				try {
-					if (hash(await readFile(archive)) !== item.sha256) throw new Error(`Cached companion SHA256 mismatch: ${item.name}`);
-				} catch (error) {
-					if (error.code !== "ENOENT") throw error;
-					const temporary = archive + "." + randomUUID() + ".tmp";
-					try {
-						await writeFile(temporary, bytes, {
-							flag: "wx",
-							mode: 384
-						});
-						await rename(temporary, archive);
-					} finally {
-						await rm(temporary, { force: true });
-					}
-				}
-				signal?.throwIfAborted();
-				const disposition = await installNative(profile, archive, {
-					owner,
-					ownerSpec,
-					companion: item,
-					...priorSpec === void 0 ? {} : { priorSpec }
-				}, signal);
-				if (disposition === "owner-changed" || disposition === "companion-changed") continue;
-				receipts[receiptKey] = item.sha256;
-				await writeFileAtomic(receiptPath, JSON.stringify(receipts) + "\n", { mode: 384 });
-				if (disposition === "companion-removed") continue;
-				result.installed.push(`${item.name}@${item.version}`);
-				result.restartRequired ||= priorSpec !== void 0;
-			}
-		}
-		return result;
-	}, { waitMs: 12e4 });
-}
-function apply(ctx) {
-	const signal = new AbortController();
-	let started = false, running = false, again = false;
-	const reconcile = async () => {
-		if (!started || signal.signal.aborted) return;
-		if (running) {
-			again = true;
-			return;
-		}
-		running = true;
-		try {
-			const result = await reconcileBundledDelivery(ctx.profileContext, signal.signal);
-			if (result.installed.length) {
-				ctx.logger.info(`Registered ${result.installed.join(", ")} from its containing local pack${result.restartRequired ? "; restart DSH to use the updated code" : ""}`);
-				ctx.emit("plugin-manager/changed", { reason: "install" });
-			}
-		} catch (error) {
-			if (!signal.signal.aborted) ctx.logger.error("Local pack companion registration failed; retry by re-enabling the bundle", error);
-		} finally {
-			running = false;
-			if (again && !signal.signal.aborted) {
-				again = false;
-				reconcile();
-			}
-		}
-	};
-	ctx.effect(() => {
-		const offReady = ctx.appReady.onReady(() => {
-			started = true;
-			reconcile();
-		});
-		const offChange = ctx.on("plugin-manager/changed", () => {
-			reconcile();
-		});
-		return () => {
-			offReady();
-			offChange();
-			signal.abort();
-		};
-	}, "bundle-delivery: native registration");
-}
-var bundle_delivery_default = {
-	name,
-	inject,
-	apply
-};
-
-//#endregion
-export { apply, bundle_delivery_default as default, inject, name, reconcileBundledDelivery };

package/lib/hmr.d.ts

@@ -1,32 +0,0 @@
-import Hmr, { HmrConfig } from "@deepseek-ai/dsh-hmr";
-import { Context } from "@deepseek-ai/cordis";
-
-//#region src/hmr.d.ts
-
-/**
- * Native runExclusive keeps a boolean in ALS. HTTP servers created while
- * replacing webServer inherit that boolean after the transaction finishes,
- * so subsequent native Plugin Manager requests are refused as nested.
- *
- * The public runExclusive/watchConfig APIs expose no selective context reset.
- * AsyncLocalStorage.snapshot() also resets AgentRegistry initiator attribution
- * and its teardown lineage, so it cannot safely repair this host transaction.
- * This compatibility bridge reads the native TS-private `executing` storage
- * after checking its runtime shape. It never replaces that storage or changes
- * upstream files: only exit() clears its inherited value while the unchanged
- * native method establishes the next transaction. Native queue, closing,
- * exact watchers, module reload and disposal retain their original semantics.
- *
- * The mutable token rejects nesting only while its operation is still active;
- * resources created by that operation can initiate later transactions.
- * A native implementation change fails initialization explicitly instead of
- * silently dropping queue or lifecycle guarantees.
- */
-declare class BetterHmr extends Hmr {
-  private readonly nativeTransactions;
-  private readonly liveTransactions;
-  constructor(ctx: Context, config: HmrConfig);
-  runExclusive<T>(operation: () => Promise<T>): Promise<T>;
-}
-//#endregion
-export { BetterHmr as default };

package/lib/hmr.js

@@ -1,49 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import Hmr from "@deepseek-ai/dsh-hmr";
-
-//#region src/hmr.ts
-/**
-* Native runExclusive keeps a boolean in ALS. HTTP servers created while
-* replacing webServer inherit that boolean after the transaction finishes,
-* so subsequent native Plugin Manager requests are refused as nested.
-*
-* The public runExclusive/watchConfig APIs expose no selective context reset.
-* AsyncLocalStorage.snapshot() also resets AgentRegistry initiator attribution
-* and its teardown lineage, so it cannot safely repair this host transaction.
-* This compatibility bridge reads the native TS-private `executing` storage
-* after checking its runtime shape. It never replaces that storage or changes
-* upstream files: only exit() clears its inherited value while the unchanged
-* native method establishes the next transaction. Native queue, closing,
-* exact watchers, module reload and disposal retain their original semantics.
-*
-* The mutable token rejects nesting only while its operation is still active;
-* resources created by that operation can initiate later transactions.
-* A native implementation change fails initialization explicitly instead of
-* silently dropping queue or lifecycle guarantees.
-*/
-var BetterHmr = class extends Hmr {
-	nativeTransactions;
-	liveTransactions = new AsyncLocalStorage();
-	constructor(ctx, config) {
-		super(ctx, config);
-		const storage = this.executing;
-		if (!(storage instanceof AsyncLocalStorage) || typeof storage.getStore !== "function" || typeof storage.exit !== "function" || typeof storage.run !== "function") throw new Error("Better Dash HMR cannot reset this native HMR transaction context: expected executing AsyncLocalStorage");
-		this.nativeTransactions = storage;
-	}
-	runExclusive(operation) {
-		if (this.liveTransactions.getStore()?.active) return Promise.reject(/* @__PURE__ */ new Error("HMR transactions cannot be nested"));
-		return this.nativeTransactions.exit(() => super.runExclusive(() => {
-			const token = { active: true };
-			return this.liveTransactions.run(token, async () => {
-				try {
-					return await operation();
-				} finally {
-					token.active = false;
-				}
-			});
-		}));
-	}
-};
-
-//#endregion
-export { BetterHmr as default };

package/lib/kernel-bridge.py

@@ -1,172 +0,0 @@
-#!/usr/bin/env python3
-"""stdio <-> ZeroMQ bridge for the DASHR REPL.
-
-The host (Node/TS) owns the kernel lifecycle but must not link a native ZMQ
-binding: `zeromq` was a hard npm dependency whose install script compiles C++
-inside the consumer's install transaction (and whose top-level import killed
-the whole plugin when the binding was missing). This process is the only ZMQ
-speaker on the host side; it speaks JSON lines on stdio to Node.
-
-    Node  ──stdio JSON lines──►  kernel-bridge.py  ──pyzmq/jupyter_client──►  ipykernel
-
-Requirements come from the kernel's own environment: `jupyter_client` and
-`pyzmq` are transitive dependencies of the `ipykernel` we provision (see
-`kernel-env.ts`), so nothing extra is fetched from any package manager.
-
-Protocol
---------
-stdin (one JSON object per line)::
-
-    {"op":"send","channel":"shell"|"control","header":{...},"content":{...}}
-    {"op":"interrupt"}
-    {"op":"shutdown"}
-
-stdout (one JSON object per line)::
-
-    {"ev":"ready"}
-    {"ev":"msg","channel":"shell"|"iopub"|"control"|"stdin","msg":{...}}
-    {"ev":"fatal","message":"..."}
-
-The caller-supplied `header` is passed to `Session.msg` verbatim, so the
-message id the host generated is the id on the wire — parent-matching and
-request/response correlation stay exactly as they were on the raw-socket path.
-"""
-from __future__ import annotations
-
-import json
-import queue
-import sys
-import threading
-
-CHANNELS = ("iopub", "shell", "control", "stdin")
-POLL_SECONDS = 0.2
-
-# Protocol output goes to the real stdout; anything a library prints must never
-# corrupt the byte stream the host parses, so sys.stdout is repointed to stderr.
-_PROTOCOL_OUT = sys.stdout
-sys.stdout = sys.stderr
-
-_write_lock = threading.Lock()
-
-
-def emit(payload: dict) -> None:
-    """Write one protocol line, atomically across the pump threads."""
-    # `default=str`: jupyter_client hands back parsed values (a header `date`
-    # arrives as `datetime`, for instance) that are not JSON-native; the host
-    # only reads msg_id/msg_type/content, so stringifying the rest is lossless
-    # for its purposes and keeps one pump thread from dying on a header field.
-    line = json.dumps(payload, ensure_ascii=False, default=str)
-    with _write_lock:
-        _PROTOCOL_OUT.write(line + "\n")
-        _PROTOCOL_OUT.flush()
-
-
-def _clean(value: object) -> object:
-    """Strip binary buffers: this protocol carries JSON only."""
-    if isinstance(value, dict):
-        return {key: _clean(item) for key, item in value.items() if key != "buffers"}
-    if isinstance(value, (list, tuple)):
-        return [_clean(item) for item in value]
-    if isinstance(value, bytes):
-        return value.decode("utf-8", "replace")
-    return value
-
-
-def pump(client, name: str, stop: threading.Event) -> None:
-    """Relay one client channel onto stdout until `stop` is set."""
-    channel = getattr(client, f"{name}_channel")
-    while not stop.is_set():
-        try:
-            message = channel.get_msg(timeout=POLL_SECONDS)
-        except queue.Empty:
-            continue
-        except Exception as error:  # channel torn down, or the socket died
-            if not stop.is_set():
-                emit({"ev": "fatal", "channel": name, "message": f"{type(error).__name__}: {error}"})
-        try:
-            emit({
-                "ev": "msg",
-                "channel": name,
-                "msg": {
-                    "header": message.get("header") or {},
-                    "parent_header": message.get("parent_header") or {},
-                    "content": _clean(message.get("content") or {}),
-                    "metadata": _clean(message.get("metadata") or {}),
-                },
-            })
-        except Exception as error:  # never let one message kill a channel pump
-            sys.stderr.write(f"kernel-bridge: cannot relay {name} message: {type(error).__name__}: {error}\n")
-            sys.stderr.flush()
-
-
-def main() -> int:
-    if len(sys.argv) != 2:
-        emit({"ev": "fatal", "message": "usage: kernel-bridge.py <connection-file>"})
-        return 2
-
-    try:
-        from jupyter_client import BlockingKernelClient
-    except Exception as error:  # the kernel environment is incomplete
-        emit({"ev": "fatal", "message": f"jupyter_client unavailable: {type(error).__name__}: {error}"})
-        return 3
-
-    try:
-        client = BlockingKernelClient(connection_file=sys.argv[1])
-        client.load_connection_file()
-        client.start_channels()
-    except Exception as error:
-        emit({"ev": "fatal", "message": f"cannot connect to the kernel: {type(error).__name__}: {error}"})
-        return 4
-
-    stop = threading.Event()
-    for name in CHANNELS:
-        threading.Thread(target=pump, args=(client, name, stop), name=f"pump-{name}", daemon=True).start()
-
-    emit({"ev": "ready"})
-
-    try:
-        for line in sys.stdin:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                request = json.loads(line)
-            except Exception:
-                continue
-            op = request.get("op")
-            if op == "send":
-                channel_name = request.get("channel")
-                if channel_name not in ("shell", "control"):
-                    emit({"ev": "fatal", "message": f"unknown send channel {channel_name!r}"})
-                    continue
-                channel = getattr(client, f"{channel_name}_channel")
-                try:
-                    header = request.get("header") or None
-                    message = client.session.msg(
-                        header["msg_type"] if header else "comm_msg",
-                        content=request.get("content") or {},
-                        header=header,
-                    )
-                    channel.send(message)
-                except Exception as error:
-                    emit({"ev": "fatal", "channel": channel_name, "message": f"send failed: {type(error).__name__}: {error}"})
-            elif op == "interrupt":
-                try:
-                    client.interrupt_kernel()
-                except Exception as error:
-                    emit({"ev": "fatal", "message": f"interrupt failed: {type(error).__name__}: {error}"})
-            elif op == "shutdown":
-                break
-    except (KeyboardInterrupt, BrokenPipeError):
-        pass
-    finally:
-        stop.set()
-        try:
-            client.stop_channels()
-        except Exception:
-            pass
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/lib/kernel-env-D8UOWeji.js

@@ -1,195 +0,0 @@
-import { execFile } from "node:child_process";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { existsSync, mkdirSync } from "node:fs";
-import { promisify } from "node:util";
-
-//#region src/kernel-env.ts
-const execFileAsync = promisify(execFile);
-/** The installed package root (where `lib/` and `src/` live): the default home of the managed venv. */
-const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-/** The config value meaning "no explicit interpreter — auto-manage a venv". */
-const AUTO_PYTHON_SENTINEL = "python3";
-/** Preferred CPython version for a managed venv. */
-const DEFAULT_KERNEL_PYTHON_VERSION = "3.11";
-/** Pinned, tested `ipykernel` version (2026-09-02 tested value; upgrade = explicit change + regression). */
-const IPYKERNEL_VERSION = "7.3.0";
-/** Pinned, tested `dill` version. */
-const DILL_VERSION = "0.4.1";
-/** A probe that never imports user modules and reports exactly what we need. */
-const PROBE_CODE = [
-	"import json, sys",
-	"r = {\"version\": sys.version.split()[0], \"ipykernel\": False, \"dill\": False}",
-	"try:",
-	"    import ipykernel  # noqa: F401",
-	"    r[\"ipykernel\"] = True",
-	"except Exception:",
-	"    pass",
-	"try:",
-	"    import dill  # noqa: F401",
-	"    r[\"dill\"] = True",
-	"except Exception:",
-	"    pass",
-	"print(json.dumps(r))"
-].join("\n");
-async function probePython(python) {
-	try {
-		const { stdout } = await execFileAsync(python, ["-c", PROBE_CODE], { timeout: 15e3 });
-		const parsed = JSON.parse(stdout.trim());
-		return {
-			version: typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown",
-			ipykernel: parsed.ipykernel === true,
-			dill: parsed.dill === true
-		};
-	} catch {
-		return null;
-	}
-}
-/** The venv interpreter path for this platform. */
-function venvPythonPath(venvDir) {
-	return process.platform === "win32" ? join(venvDir, "Scripts", "python.exe") : join(venvDir, "bin", "python");
-}
-async function commandExists(cmd) {
-	try {
-		await execFileAsync(cmd, ["--version"], { timeout: 1e4 });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** Tool-cache env for uv: caches live NEXT TO the venv (plugin territory), so a read-only home can never block provisioning. */
-function uvToolEnv(venvDir) {
-	const cacheDir = join(dirname(venvDir), ".uv-cache");
-	return {
-		...process.env,
-		UV_CACHE_DIR: cacheDir,
-		UV_PYTHON_INSTALL_DIR: join(cacheDir, "python"),
-		UV_LINK_MODE: "copy"
-	};
-}
-/** uv venv arguments (pure; unit-tested). */
-function uvVenvArgs(venvDir, pythonVersion) {
-	return [
-		"venv",
-		venvDir,
-		"--python",
-		pythonVersion
-	];
-}
-/** python3 -m venv fallback arguments (pure; cache-free by construction). */
-function venvFallbackArgs(venvDir) {
-	return [
-		"-m",
-		"venv",
-		venvDir
-	];
-}
-/** uv pip install arguments with pinned versions (pure; unit-tested). */
-function uvInstallArgs(python) {
-	return [
-		"pip",
-		"install",
-		"--python",
-		python,
-		"--quiet",
-		`ipykernel==${IPYKERNEL_VERSION}`,
-		`dill==${DILL_VERSION}`
-	];
-}
-/** pip install arguments with pinned versions for the venv interpreter (pure). */
-function pipInstallArgs() {
-	return [
-		"-m",
-		"pip",
-		"install",
-		"--quiet",
-		"--disable-pip-version-check",
-		`ipykernel==${IPYKERNEL_VERSION}`,
-		`dill==${DILL_VERSION}`
-	];
-}
-/** Create the venv (when absent) and return its interpreter path. */
-async function createVenv(venvDir, pythonVersion) {
-	const python = venvPythonPath(venvDir);
-	if (existsSync(python)) return python;
-	if (await commandExists("uv")) {
-		mkdirSync(join(dirname(venvDir), ".uv-cache"), { recursive: true });
-		await execFileAsync("uv", uvVenvArgs(venvDir, pythonVersion), {
-			timeout: 12e4,
-			env: uvToolEnv(venvDir)
-		});
-	} else await execFileAsync("python3", venvFallbackArgs(venvDir), { timeout: 12e4 });
-	return python;
-}
-/** Install pinned `ipykernel` + `dill` into the venv interpreter. */
-async function installDeps(python, venvDir) {
-	if (await commandExists("uv")) await execFileAsync("uv", uvInstallArgs(python), {
-		timeout: 18e4,
-		env: uvToolEnv(venvDir)
-	});
-	else await execFileAsync(python, pipInstallArgs(), { timeout: 18e4 });
-}
-/** Provision (or repair) the managed venv so it has `ipykernel` + `dill`. */
-async function ensureVenv(venvDir, pythonVersion, log) {
-	const python = venvPythonPath(venvDir);
-	const existing = existsSync(python) ? await probePython(python) : null;
-	if (existing?.ipykernel === true && existing.dill === true) return python;
-	await createVenv(venvDir, pythonVersion);
-	if (!existsSync(python)) throw new Error(`dashr-repl: managed kernel venv was not created at ${venvDir} (no interpreter at ${python})`);
-	log?.("info", `dashr-repl: provisioning kernel venv at ${venvDir} (ipykernel + dill)`);
-	await installDeps(python, venvDir);
-	return python;
-}
-/**
-* Resolve the kernel interpreter, provisioning a managed venv when no
-* explicit interpreter is configured. Throws when the resolved interpreter
-* cannot run `ipykernel`; a missing `dill` only disables snapshots (warned).
-*/
-async function resolveKernelEnv(options = {}) {
-	const log = options.log;
-	const explicit = options.python !== void 0 && options.python !== "" && options.python !== AUTO_PYTHON_SENTINEL ? options.python : void 0;
-	if (explicit !== void 0) {
-		const probe$1 = await probePython(explicit);
-		if (probe$1 === null) throw new Error(`dashr-repl: kernel python ${JSON.stringify(explicit)} could not be executed — check the path`);
-		if (!probe$1.ipykernel) throw new Error(`dashr-repl: kernel python ${JSON.stringify(explicit)} has no ipykernel — install it (pip install ipykernel) or set python to a managed venv`);
-		if (!probe$1.dill) log?.("warn", `dashr-repl: kernel python ${JSON.stringify(explicit)} has no dill — namespace snapshots are DISABLED (install it: pip install dill)`);
-		return {
-			python: explicit,
-			managed: false,
-			venvDir: void 0,
-			dill: probe$1.dill,
-			ipykernel: true,
-			version: probe$1.version
-		};
-	}
-	const venvDir = options.venvDir ?? join(PACKAGE_ROOT, ".venv-kernel");
-	const python = venvPythonPath(venvDir);
-	if (options.autoInstall === false) {
-		const probe$1 = await probePython(python);
-		if (probe$1 === null || !probe$1.ipykernel) throw new Error(`dashr-repl: managed kernel venv is missing or incomplete at ${venvDir} — run 'npm run kernel:venv' in the dashr package, or set kernelAutoInstall: true (or python to a prepared interpreter)`);
-		if (!probe$1.dill) log?.("warn", `dashr-repl: kernel venv at ${venvDir} has no dill — namespace snapshots are DISABLED (run 'npm run kernel:venv' to reinstall)`);
-		return {
-			python,
-			managed: true,
-			venvDir,
-			dill: probe$1.dill,
-			ipykernel: true,
-			version: probe$1.version
-		};
-	}
-	const resolved = await ensureVenv(venvDir, options.pythonVersion ?? DEFAULT_KERNEL_PYTHON_VERSION, log);
-	const probe = await probePython(resolved);
-	if (probe === null || !probe.ipykernel) throw new Error(`dashr-repl: managed kernel venv at ${venvDir} still has no ipykernel after provisioning — check uv/python3-venv availability and retry`);
-	if (!probe.dill) log?.("warn", `dashr-repl: managed kernel venv at ${venvDir} has no dill after provisioning — namespace snapshots are DISABLED`);
-	return {
-		python: resolved,
-		managed: true,
-		venvDir,
-		dill: probe.dill,
-		ipykernel: true,
-		version: probe.version
-	};
-}
-
-//#endregion
-export { PACKAGE_ROOT as a, uvInstallArgs as c, venvFallbackArgs as d, IPYKERNEL_VERSION as i, uvToolEnv as l, DEFAULT_KERNEL_PYTHON_VERSION as n, pipInstallArgs as o, DILL_VERSION as r, resolveKernelEnv as s, AUTO_PYTHON_SENTINEL as t, uvVenvArgs as u };

package/lib/webserver.d.ts

@@ -1,10 +0,0 @@
-import { Service } from "@deepseek-ai/cordis";
-import { WebServer } from "@deepseek-ai/dsh-host-webserver";
-
-//#region src/webserver.d.ts
-declare class BetterWebServer extends WebServer {
-  static inject: string[];
-  [Service.init](): Promise<void>;
-}
-//#endregion
-export { BetterWebServer as default };