@xrn1997/dsh-session-delete 0.0.0-stage → 0.0.1

package/lib/index.js

@@ -0,0 +1,876 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, rename, rm, stat } from "node:fs/promises";
+//#region src/shared/wire.ts
+/**
+* 跨半 wire 契约：`/dsh-session-delete-api` 的**前缀、四个端点段、请求字段名**——
+* Node 半（`src/api/dispatch.ts` 注册并分发）与浏览器半（`src/client/remote.ts` 同源 fetch）
+* 之间唯一的那份真相。两侧都 import 它，不各写一份字面量。
+*
+* 两条构建期硬约束（不是偏好）：
+*  ① tsdown 的浏览器半纯度门拦 Node 内建与平台模块表外的 `@deepseek-ai/*` 值 import——
+*     本文件两者都不涉及，且**零运行时依赖**（client 半把它整个 inline 进 bundle）；
+*  ② 跨插件一律 `import type`——本文件干脆没有 import。
+*
+* 信封（`RemoteResult`）与失败形状（`RemoteFailure`）也在这里——**因为它们本来就是两半的共同契约**：
+* Node 半按它产出（`src/api/dispatch.ts` 的失败支就是 `RemoteFailure` 那两件），浏览器半按它判别
+* （`src/client/remote.ts` 的 `unwrapRemoteResult` / `failureOf`）。形状取自宿主网关客户端面的原文
+* 「每次 unary 调用 resolve 成 RemoteResult、不为载体问题 reject」，但**它是本仓自己的 wire 契约**，
+* 不是对宿主模块的 import。
+*/
+/**
+* 插件专属前缀。
+*
+* 为什么必须带插件名：宿主 web server 的 `register({kind:'prefix', path})` 对**重复的 (kind, path)
+* 直接抛错**（`dsh-host-webserver` 原文 `webserver: duplicate ${route.kind} route "${route.path}"`），
+* 撞了就是整棵插件树 boot 失败——所以这条路径是与生态的硬边界，不是显示好不好看的问题。
+*/
+const SESSION_DELETE_API_PREFIX = "/dsh-session-delete-api";
+/** 四个端点的段名（相对前缀；`GET list` 读、其余三个 `POST` 写）。 */
+const ROUTES = {
+	list: "/list",
+	delete: "/delete",
+	restore: "/restore",
+	purge: "/purge"
+};
+/** 请求体字段名：浏览器半发、Node 半读，同名同义（`purge` 的 `entryId` 缺席 = 清空）。 */
+const PARAMS = {
+	sessionId: "sessionId",
+	entryId: "entryId"
+};
+/**
+* 进程内判别「这已经是一次失败」——**按标记位认，不按 `instanceof`**（跨 realm / 跨 bundle 都不成立）。
+* 位名与判法取自宿主网关客户端面的原文：
+* `if (typeof value === "object" && value !== null && value.isDSHRemoteError === true && typeof value.code === "string") return value`。
+*
+* 线上递过来的是**一段 JSON**（标记位不跟着过线）⇒ 落到哪一端，由那端的构造处就地补上标记：
+* 浏览器半是 `src/client/remote.ts` 的 `throwRemoteFailure`。
+*/
+function isDSHRemoteError(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.isDSHRemoteError === true && typeof candidate.code === "string";
+}
+//#endregion
+//#region src/verbs/errors.ts
+/** 五个码（设计稿 §6 的表）。**唯一定义处**：`remote/map-error.ts` 从这份数组反推它的 `Code`，
+*  免得"加了一个码只在一边加"让两张表各自漂移（漂移的后果是那个码静默降级成 `io`）。 */
+const VERB_CODES = [
+	"live",
+	"not-found",
+	"trash-empty",
+	"project-missing",
+	"io"
+];
+function verbError(code, message, cause) {
+	const e = new Error(message);
+	e.code = `sessiondelete/${code}`;
+	e.cause = cause;
+	return e;
+}
+//#endregion
+//#region src/remote/map-error.ts
+/** 插件专属远程域名（设计稿 §6）：与宿主官方域（`workspace/*`、`session/*`、`gateway/*`…）不重名。 */
+const DOMAIN = "sessiondelete";
+/** 宿主两条类型化错误 → 我们的码（设计稿 §6 的两行映射）。
+*  类不可 import（跨插件值 import 是红线；且宿主包与运行中的宿主不同代）⇒ 按官方构造器写死的 `this.name` 认。
+*  证据：asar `dsh/node_modules/@deepseek-ai/dsh-workspace/lib/index.js` 原文
+*  `var WorkspaceUnknownSessionError = class extends Error { …; this.name = "WorkspaceUnknownSessionError"; }`
+*  `var WorkspaceActiveSessionError  = class extends Error { …; this.name = "WorkspaceActiveSessionError"; }`。 */
+const HOST_ERROR_CODE = {
+	WorkspaceUnknownSessionError: "not-found",
+	WorkspaceActiveSessionError: "live"
+};
+/** 错误与它的 `cause` 链上最近的一个宿主类型化错误码（深度有界，链坏掉不递归下去）。 */
+function hostCodeOf(error) {
+	let current = error;
+	for (let depth = 0; depth < 8; depth++) {
+		if (current === null || typeof current !== "object") return void 0;
+		const name = current.name;
+		if (typeof name === "string" && Object.hasOwn(HOST_ERROR_CODE, name)) return HOST_ERROR_CODE[name];
+		current = current.cause;
+	}
+}
+/** 上屏原文：`Error` 取 `.message`；**带 `message` 字符串的非 Error 抛出物也照取**（否则会退化成
+*  `[object Object]`，把设计稿 §6「`message` 是上屏的原文」这条许诺落空）；其余一律 `String()`。 */
+function messageOf(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null) {
+		const message = error.message;
+		if (typeof message === "string") return message;
+	}
+	return String(error);
+}
+/**
+* 把任意抛出物折成失败信封里的**那两件**（设计稿 §6 唯一那张映射表）。
+*
+* - 已经是远程失败（`isDSHRemoteError` 认得的结构标记）⇒ 原样带出它自己的 `code` / `message`，不再包一层。
+* - 宿主类型化错误（自身或 `cause` 链上，见 {@link HOST_ERROR_CODE}）⇒ 映射成 `live` / `not-found`。
+*   放在动词码之前判：动词把宿主错误包成笼统的 `io` 并把原错误挂在 cause 上（`verbError('io', …, cause)`），
+*   不这样看进 cause 链，§6 那两行映射就永远到不了客户端。
+* - 动词的 `sessiondelete/<五个码>` ⇒ 原样过桥。
+* - 其余（含别域码、前缀外的因、非 Error 抛出物）⇒ `io`，message 保留原文。
+*
+* **返回的是线上形状、不是 `Error`**：这份东西唯一的去处是 `src/api/dispatch.ts` 的失败信封，两种判别
+* （`isDSHRemoteError` 与 {@link HOST_ERROR_CODE}）都只用到 `code` / `message`——造一个真 `Error` 没有消费者，
+* 而本仓的跨插件 import 红线也不许为此去引宿主的 `RemoteError` 类（实例也上不了线：信封只走这两件）。
+*/
+function toRemoteFailure(error) {
+	if (isDSHRemoteError(error)) return {
+		code: error.code,
+		message: String(error.message)
+	};
+	const raw = error?.code;
+	const reason = typeof raw === "string" && raw.startsWith(`${DOMAIN}/`) ? raw.slice(14) : void 0;
+	const fromVerb = reason !== void 0 && VERB_CODES.includes(reason) ? reason : void 0;
+	const code = hostCodeOf(error) ?? fromVerb ?? "io";
+	return {
+		code: `${DOMAIN}/${code}`,
+		message: messageOf(error)
+	};
+}
+//#endregion
+//#region src/trash/entry.ts
+const pad = (n, w = 2) => String(n).padStart(w, "0");
+function makeEntryId(deletedAt, sessionDirName) {
+	const d = new Date(deletedAt);
+	return `${`${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}T${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}Z`}-${sessionDirName}`;
+}
+const ENTRY_ID_RE = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z-(.+)$/;
+/** `makeEntryId` 的逆。时间戳按 UTC 拆字段再 `Date.UTC` 合回——不交给 `Date.parse`
+*  去猜（`20260930T130500Z` 不是任何被承认的日期格式，猜出来的是 NaN）。 */
+function parseEntryId(id) {
+	const m = ENTRY_ID_RE.exec(id);
+	if (!m) throw new Error(`bad entry id: ${id}`);
+	const [, y, mo, d, h, mi, s, sessionDirName] = m;
+	return {
+		deletedAt: Date.UTC(+y, +mo - 1, +d, +h, +mi, +s),
+		sessionDirName
+	};
+}
+function sessionDirOf(projectDir, sessionDirName, home) {
+	return `${home}/sessions/${projectDir}/${sessionDirName}`;
+}
+function trashDirOf(entryId, home) {
+	return `${home}/session-trash/${entryId}`;
+}
+//#endregion
+//#region src/verbs/delete-session.ts
+function deleteSession(deps) {
+	return async function deleteSession(sessionId) {
+		if (await deps.host.isLive(sessionId)) throw verbError("live", `会话正在运行：${sessionId}`);
+		const projectDir = await deps.host.projectDirOf(sessionId);
+		if (!projectDir) throw verbError("not-found", `宿主的持久化里没有这个会话：${sessionId}`);
+		const workspaceId = await deps.host.workspaceOf(sessionId);
+		const sessionDir = sessionDirOf(projectDir, sessionId, deps.home);
+		if (!await deps.fs.exists(sessionDir)) throw verbError("not-found", `会话目录不存在：${sessionDir}`);
+		const wasArchived = await deps.host.isArchived(sessionId);
+		const deletedAt = deps.now();
+		const entryId = makeEntryId(deletedAt, sessionId);
+		const trashDir = trashDirOf(entryId, deps.home);
+		let title;
+		let sizeBytes;
+		try {
+			title = await deps.host.titleOf(sessionId);
+			sizeBytes = await deps.fs.sizeOfDir(sessionDir);
+		} catch (error) {
+			throw verbError("io", `读取会话现场失败：${String(error)}`, error);
+		}
+		if (!wasArchived) try {
+			await deps.host.archive(sessionId, workspaceId);
+		} catch (error) {
+			throw verbError("io", `归档失败：${String(error)}`, error);
+		}
+		if (workspaceId !== void 0) try {
+			await deps.host.detach(sessionId, workspaceId);
+		} catch (error) {
+			if (!wasArchived) await deps.host.unarchive(sessionId).catch(() => {});
+			throw verbError("io", `摘账本失败：${String(error)}`, error);
+		}
+		const entry = {
+			id: entryId,
+			sessionId,
+			projectDir,
+			workspaceId: workspaceId ?? "",
+			wasArchived,
+			deletedAt,
+			title,
+			sizeBytes
+		};
+		try {
+			await deps.fs.ensureDir(`${deps.home}/session-trash`);
+			await deps.fs.rename(sessionDir, trashDir);
+		} catch (error) {
+			if (workspaceId !== void 0) await deps.host.attach(sessionId, workspaceId).catch(() => {});
+			if (!wasArchived) await deps.host.unarchive(sessionId).catch(() => {});
+			throw verbError("io", `移动会话目录失败：${String(error)}`, error);
+		}
+		try {
+			await deps.manifest.add(entry);
+		} catch (error) {
+			await deps.fs.rename(trashDir, sessionDir).catch(() => {});
+			if (workspaceId !== void 0) await deps.host.attach(sessionId, workspaceId).catch(() => {});
+			if (!wasArchived) await deps.host.unarchive(sessionId).catch(() => {});
+			throw verbError("io", `登记回收站条目失败：${String(error)}`, error);
+		}
+		if (await deps.host.evictLive(sessionId) !== "unknown") await deps.host.announceRemoved(sessionId);
+		return entry;
+	};
+}
+//#endregion
+//#region src/verbs/purge-trash.ts
+function purgeTrash(deps) {
+	return async function purgeTrash(entryId) {
+		const all = await deps.manifest.list();
+		const targets = entryId ? all.filter((e) => e.id === entryId) : all;
+		if (entryId && targets.length === 0) throw verbError("trash-empty", `回收站里没有这一条：${entryId}`);
+		let freedBytes = 0;
+		for (const entry of targets) {
+			const dir = trashDirOf(entry.id, deps.home);
+			if (await deps.fs.exists(dir)) {
+				freedBytes += await deps.fs.sizeOfDir(dir);
+				await deps.fs.removeDir(dir).catch((error) => {
+					throw verbError("io", `删除回收站目录失败：${String(error)}`, error);
+				});
+			}
+			await deps.manifest.remove(entry.id);
+			if (await deps.host.evictLive(entry.sessionId) !== "unknown") await deps.host.announceRemoved(entry.sessionId);
+		}
+		return {
+			removed: targets.length,
+			freedBytes
+		};
+	};
+}
+//#endregion
+//#region src/verbs/restore-session.ts
+function restoreSession(deps) {
+	return async function restoreSession(entryId) {
+		const entry = (await deps.manifest.list()).find((e) => e.id === entryId);
+		if (!entry) throw verbError("trash-empty", `回收站里没有这一条：${entryId}`);
+		const trashDir = trashDirOf(entry.id, deps.home);
+		const sessionDir = sessionDirOf(entry.projectDir, parseEntryId(entry.id).sessionDirName, deps.home);
+		if (!await deps.fs.exists(trashDir)) throw verbError("trash-empty", `回收站条目已不在磁盘上：${trashDir}`);
+		const projectRoot = sessionDirOf(entry.projectDir, "", deps.home).replace(/\/$/, "");
+		if (!await deps.fs.exists(`${deps.home}/sessions`) || !await deps.fs.exists(projectRoot)) throw verbError("project-missing", `原项目目录已不存在：${projectRoot}`);
+		await deps.fs.rename(trashDir, sessionDir).catch((error) => {
+			throw verbError("io", `放回会话目录失败：${String(error)}`, error);
+		});
+		if (entry.workspaceId !== "") try {
+			await deps.host.attach(entry.sessionId, entry.workspaceId);
+		} catch (error) {
+			await deps.fs.rename(sessionDir, trashDir).catch(() => {});
+			throw verbError("io", `挂回账本失败：${String(error)}`, error);
+		}
+		if (!entry.wasArchived) try {
+			await deps.host.unarchive(entry.sessionId);
+		} catch (error) {
+			await deps.host.archive(entry.sessionId, entry.workspaceId || void 0).catch(() => {});
+			if (entry.workspaceId !== "") await deps.host.detach(entry.sessionId, entry.workspaceId).catch(() => {});
+			await deps.fs.rename(sessionDir, trashDir).catch(() => {});
+			throw verbError("io", `取消归档失败：${String(error)}`, error);
+		}
+		try {
+			await deps.manifest.remove(entry.id);
+		} catch (error) {
+			if (!entry.wasArchived) await deps.host.archive(entry.sessionId, entry.workspaceId || void 0).catch(() => {});
+			if (entry.workspaceId !== "") await deps.host.detach(entry.sessionId, entry.workspaceId).catch(() => {});
+			await deps.fs.rename(sessionDir, trashDir).catch(() => {});
+			throw verbError("io", `摘回收站条目失败：${String(error)}`, error);
+		}
+		await deps.host.announceRestored(entry.sessionId);
+		return entry;
+	};
+}
+//#endregion
+//#region src/api/dispatch.ts
+/** 请求体字节上限：这条通道只收几个 id，1MiB 是"够用且不给自己开一条内存放大器"的量级。 */
+const JSON_BODY_MAX_BYTES = 1048576;
+/** 回环地址的三种写法（IPv4 / IPv6 / IPv4-mapped IPv6）。 */
+const LOOPBACK = [
+	"127.0.0.1",
+	"::1",
+	"::ffff:127.0.0.1"
+];
+/**
+* 桌面壳那条路（asar `/lib/main.js` 的 `forwardWebRequest`）：渲染进程从 `dsh-app://app/` 加载，
+* 页面里对**非静态路径**的请求（`/`、`/index.html`、`/assets/*`、`/plugins/…` 之外的一切——包括
+* 我们这条前缀路由）都由 `protocol.handle("dsh-app")` 转给宿主自己的 web server；转发前它把
+* `host` / `origin` / `cookie` / `sec-fetch-site` 四个头**删掉**、换上一枚宿主自己的 cookie，路径与
+* 查询串原样带走（逐字：`for (const name of ["host","origin","cookie","sec-fetch-site"]) headers.delete(name)`）。
+* ⇒ 桌面版打到我们这条路由上的请求是**没有 `Origin`** 的，`Referer` 则保留（同源请求照常带，
+* 页面就住在 `dsh-app://app/`）。壳自己在上游只放行 `origin ∈ {null, "dsh-app://app"}`。
+*/
+const DESKTOP_APP_SCHEME = "dsh-app:";
+const DESKTOP_APP_HOST = "app";
+/**
+* 「这是桌面壳自己的页面吗」。**必须按 `protocol` + `host` 判，不能比 `URL.origin`**：`dsh-app:`
+* 不是 WHATWG 的 special scheme，`new URL('dsh-app://app/').origin` 是字符串 `"null"`（Node 实测），
+* 拿它跟字面量比永远为假 ⇒ 栅栏会把真机上的每一次请求都挡成 403，四个入口一个都不出现。
+*
+* 这个判据为什么不可能被外人伪造：`Origin` 与 `Referer` 都是 forbidden header，网页改不了，
+* 只能是浏览器/壳自己带上；而 `dsh-app://app` 只可能是桌面壳自己的页面。
+*/
+function isDesktopShellUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === DESKTOP_APP_SCHEME && url.host === DESKTOP_APP_HOST;
+	} catch {
+		return false;
+	}
+}
+function writeJson(res, status, body) {
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
+}
+function writeOk(res, value) {
+	writeJson(res, 200, {
+		ok: true,
+		value
+	});
+}
+/** 失败信封：码与原文都来自 `toRemoteFailure`（本插件唯一的错误映射表），值就是线上形状本身。 */
+function writeFailure(res, error, status = 200) {
+	writeJson(res, status, {
+		ok: false,
+		error: toRemoteFailure(error)
+	});
+}
+/**
+* 同源栅栏（见文件头 ④）。看 `origin` 而不只看 `referer` 的理由：恶意页
+* `<meta name="referrer" content="no-referrer">` 能让 Referer 缺席，但浏览器对跨源请求**总是**发 Origin。
+*
+* 放行的三种形状，各自都是"浏览器/壳自动带上、网页改不了"的那种：
+* ① `Origin` 与 `Host` 同源（浏览器直接打开宿主那行 URL）；② `Origin` 是桌面壳的 `dsh-app://app`
+* （壳自己在上游也只放行这个 origin）；③ `Referer` 是桌面壳的 `dsh-app://app`（**真机那条路**：
+* 壳把 `Origin` 删掉了、只留下 Referer，见 {@link isDesktopShellUrl}）。两者都缺席 = 本机工具 /
+* curl（注释即此承诺）。**恶意网页拿不到 ②③ 里的任何一个**：那两个头都是 forbidden header、
+* 页面伪造不了；而**写口（POST）在任何跨源形态下都必带 Origin** ⇒ 两个头全缺席就等于本机工具。
+* 唯一的缝是跨源 `no-cors` 的 **GET**（Referer 被 `no-referrer` 掐掉、Origin 也不带）——它只够得到
+* 只读的 `list`，而 no-cors 的回包是 opaque、页面读不出内容 ⇒ 不构成泄露。
+*/
+function isTrustedRequest(req) {
+	if (!LOOPBACK.includes(req.socket.remoteAddress ?? "")) return false;
+	const host = req.headers.host;
+	const origin = req.headers.origin;
+	if (origin !== void 0 && !isDesktopShellUrl(origin)) try {
+		if (new URL(origin).host !== host) return false;
+	} catch {
+		return false;
+	}
+	const referer = req.headers.referer;
+	if (referer === void 0) return true;
+	if (isDesktopShellUrl(referer)) return true;
+	try {
+		return new URL(referer).host === host;
+	} catch {
+		return false;
+	}
+}
+/** 流式读 body 并解析成 JSON 对象：空体回 `null`，超限 / 非法 JSON / 不是对象一律抛（→ 失败信封）。 */
+async function readJsonBody(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buf.length;
+		if (size > JSON_BODY_MAX_BYTES) throw new Error(`请求体超过 ${JSON_BODY_MAX_BYTES} 字节上限`);
+		chunks.push(buf);
+	}
+	const text = Buffer.concat(chunks).toString("utf8").trim();
+	if (text === "") return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw new Error(`请求体不是合法 JSON：${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("请求体需为 JSON 对象");
+	return parsed;
+}
+/** 必填的非空字符串字段（缺、空串、类型不对都是**同一句话**：说清是哪个字段）。 */
+function requireString(body, field) {
+	const value = body?.[field];
+	if (typeof value !== "string" || value === "") throw new Error(`请求体需带非空字符串字段 ${field}`);
+	return value;
+}
+/** `purge` 的 `entryId` 可选（缺席 = 清空），但在场就必须是像样的值——不把 `42` 当成"没带"。 */
+function optionalString(body, field) {
+	const value = body?.[field];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || value === "") throw new Error(`字段 ${field} 若在场必须是非空字符串`);
+	return value;
+}
+function requireMethod(method, want, route) {
+	if (method !== want) throw new Error(`方法不允许：${method}（${SESSION_DELETE_API_PREFIX}${route} 需 ${want}）`);
+}
+/** 路由表：段名 → 一个把「方法 + 请求体」变成返回值的处理器。动词在每次调用时才取。 */
+async function dispatch(method, rest, req, deps) {
+	if (rest === ROUTES.list) {
+		requireMethod(method, "GET", ROUTES.list);
+		return await deps.manifest.list();
+	}
+	if (rest === ROUTES.delete) {
+		requireMethod(method, "POST", ROUTES.delete);
+		return await deleteSession(deps)(requireString(await readJsonBody(req), PARAMS.sessionId));
+	}
+	if (rest === ROUTES.restore) {
+		requireMethod(method, "POST", ROUTES.restore);
+		return await restoreSession(deps)(requireString(await readJsonBody(req), PARAMS.entryId));
+	}
+	if (rest === ROUTES.purge) {
+		requireMethod(method, "POST", ROUTES.purge);
+		return await purgeTrash(deps)(optionalString(await readJsonBody(req), PARAMS.entryId));
+	}
+	throw new Error(`未知路由：${method} ${rest === "" ? SESSION_DELETE_API_PREFIX : rest}`);
+}
+/** 宿主 `webServer.register({kind:'prefix', path: SESSION_DELETE_API_PREFIX, handler})` 的那个 handler。 */
+function createApiHandler(deps) {
+	return async function handle(req, res) {
+		if (!isTrustedRequest(req)) {
+			writeFailure(res, /* @__PURE__ */ new Error("非受信来源"), 403);
+			return;
+		}
+		try {
+			const url = new URL(req.url ?? "/", "http://dsh.internal");
+			if (!url.pathname.startsWith("/dsh-session-delete-api")) throw new Error(`未知路由：${url.pathname}`);
+			writeOk(res, await dispatch(req.method ?? "GET", url.pathname.slice(23), req, deps));
+		} catch (error) {
+			writeFailure(res, error);
+		}
+	};
+}
+//#endregion
+//#region src/ports/fs-port.ts
+/** 模块级递归：端口方法**解构出来单独调**也不能靠 `this`（`{ sizeOfDir } = port` 会让方法体的
+*  `this` 变成 undefined）。所以端口只做转发，递归在模块作用域里自调。 */
+async function sizeOfDir(p) {
+	let total = 0;
+	for (const e of await readdir(p, { withFileTypes: true })) {
+		const child = join(p, e.name);
+		total += e.isDirectory() ? await sizeOfDir(child) : (await stat(child)).size;
+	}
+	return total;
+}
+function createFsPort() {
+	return {
+		async exists(p) {
+			return existsSync(p);
+		},
+		async ensureDir(p) {
+			await mkdir(p, { recursive: true });
+		},
+		async rename(from, to) {
+			await rename(from, to);
+		},
+		async removeDir(p) {
+			await rm(p, {
+				recursive: true,
+				force: true
+			});
+		},
+		sizeOfDir: (p) => sizeOfDir(p)
+	};
+}
+//#endregion
+//#region src/ports/host-port.ts
+/** live store 的最小方法面判据（同 `projectionCacheOf` 的手法：按方法面判，不按 constructor.name）。 */
+function liveSessionsOf(ctx) {
+	const store = ctx.get("sessions");
+	if (store === void 0 || store === null) return void 0;
+	if (typeof store.get !== "function" || typeof store.liveEntryFor !== "function") return void 0;
+	return store;
+}
+/** 无 cwd 的会话落在 `<sessions>/_no-cwd/`（asar `dsh-session-persistence-jsonl/lib/index.js`
+*  的 `projectDir(root, cwd)`：`if (cwd === void 0) return join(root, "_no-cwd");`）。 */
+const NO_CWD_PROJECT_DIR = "_no-cwd";
+/**
+* 宿主的**项目目录名**算法（`projectKey`）逐字镜像。
+*
+* 为什么是镜像而不是 import：它在 `@deepseek-ai/dsh-session-persistence-jsonl` 里面，是**宿主包**，
+* 跨插件值 import 是生态红线，它也不在本插件依赖里；宿主没有把这个名字暴露成任何服务
+* （`stat()`/`list()` 的返回只有 `{header, revision, sizeBytes}`，`locate()` 的 `{kind:'jsonl', path}` 只挂在错误上）。
+*
+* 原文（asar `dsh/node_modules/@deepseek-ai/dsh-session-persistence-jsonl/lib/index.js`）：
+* `function projectKey(cwd) { … if (ch === "/" || ch === "\\" || ch === ":") { if (!separatorRun) readable += "-"; separatorRun = true; }
+*  else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) { readable += ch; separatorRun = false; }
+*  else { readable += "~" + code.toString(16).toUpperCase().padStart(4, "0"); separatorRun = false; }
+*  return \`--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--\`; }`
+* 调用链：`locate(meta)` → `logPath(root, meta.cwd, meta.id, …)` → `projectDir(root, cwd)` → `projectKey(cwd)`。
+* 本机实测对得上：`D:/develop/GitHub/dsh-session-delete` → `--D-develop-GitHub-dsh-session-delete--`
+* （`~/.dsh/sessions` 下真有这个目录名；`D:/document/deepseek-harness/default-workspace` 同理）。
+*/
+function projectKey(cwd) {
+	let readable = "";
+	let separatorRun = false;
+	for (let i = 0; i < cwd.length; i++) {
+		const code = cwd.charCodeAt(i);
+		const ch = String.fromCharCode(code);
+		if (ch === "/" || ch === "\\" || ch === ":") {
+			if (!separatorRun) readable += "-";
+			separatorRun = true;
+		} else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
+			readable += ch;
+			separatorRun = false;
+		} else {
+			readable += `~${code.toString(16).toUpperCase().padStart(4, "0")}`;
+			separatorRun = false;
+		}
+	}
+	return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
+}
+/** 投影缓存服务的最小方法面判据（按方法面判，不按 `constructor.name` 判）。 */
+function projectionCacheOf(ctx) {
+	const cache = ctx.get("sessionProjectionCache");
+	if (cache === void 0 || cache === null) return void 0;
+	if (typeof cache.cachedSnapshot !== "function" || typeof cache.cachedPredecessorTitle !== "function") return void 0;
+	return cache;
+}
+/**
+* 「账本里没有这个会话」的判别串——宿主 `readSessionHeader(id)` 对未知会话抛的是**裸 `Error`**
+* （没有类型、没有码），只认这一句。asar `dsh-workspace/lib/types/index.js` 原文（逐字）：
+* `throw new Error(\`cannot validate session '${id}': session persistence holds no such session\`)`。
+*
+* 为什么按消息判而不是全吞：同一个方法里 `listStoredHeaders()` / `indexHeaders()` 会抛**真存储故障**
+* （读盘失败、账本不一致…），那是 `io` 该走的路，绝不能被当成「无此会话」。
+* 同文件另一处近似句是有类型的那条（`cannot ${verb} session '…': live sessions and session persistence
+* hold no such session`，`WorkspaceUnknownSessionError`）——`holds` 与 `hold`、有无 `live sessions and`
+* 都不相同，所以这条串不会误伤它，`toRemoteFailure` 的 cause 链映射仍按 `name` 走。
+*/
+const NO_SUCH_SESSION = "session persistence holds no such session";
+/** 只认上面那一句；其余（含非 Error 抛出物）一律**不算未命中**。 */
+function isUnknownSession(error) {
+	return error instanceof Error && error.message.includes(NO_SUCH_SESSION);
+}
+/**
+* 宿主服务层的**真实绑定**：十二个方法各自把动词层的问题翻成宿主官方服务的调用。
+*
+* 每个方法的依据（服务 / 方法 / 入参）与原文切片见各自的实现处注释。
+* 出错一律**原样抛**（不在这里裹动词码）：动词层把原始错误挂在 `cause` 上，
+* `toRemoteFailure` 再按 `name` 把它映射回 `sessiondelete/<码>`（设计稿 §6 的两行映射）。
+*/
+function createHostPort(ctx) {
+	const host = ctx;
+	const registry = host.workspaceRegistry;
+	return {
+		/** 账本里记着这个会话的工作区：`registry.list()` 的实体 `sessionIds`（该 getter 已按 canonical cwd 过滤过）。 */
+		async workspaceOf(sessionId) {
+			return registry.list().find((workspace) => workspace.sessionIds.includes(sessionId))?.id;
+		},
+		/**
+		* 原生 cwd → 宿主项目目录名（`projectKey`）；没有 cwd 时按宿主约定落到 `_no-cwd`。
+		*
+		* 「账本里没有这个会话」= **未命中**，回 `undefined`（不是抛）：这正是本方法声明的类型，
+		* 也是 `delete-session.ts` 已经写好的那条分支 `if (!projectDir) throw
+		* verbError('not-found', …)` 的入口。若让它裸抛，那句话永远为假 ⇒ 设计稿 §6 的 `not-found`
+		* （「会话目录或账本条目不存在」）在这条最自然的路径上拿不到码，客户端只会看到 `sessiondelete/io`。
+		*
+		* **只吞这一种**：其余错误（真存储故障）照抛，让 `toRemoteFailure` 兜成 `io` 而不是假 `not-found`。
+		*/
+		async projectDirOf(sessionId) {
+			let header;
+			try {
+				header = await registry.readSessionHeader(sessionId);
+			} catch (error) {
+				if (isUnknownSession(error)) return void 0;
+				throw error;
+			}
+			return header.cwd === void 0 ? NO_CWD_PROJECT_DIR : projectKey(header.cwd);
+		},
+		/**
+		* 标题：走官方**投影缓存**读面（`title` 投影单元的 `wire.view` 值就是标题文本本身：
+		* 单元定义原文 `{ key: "title", stateVersion: 1, wire: { view: (state) => state } }`，
+		* 所以 `values.title` 是 `string | null`）。
+		* 契约：**尽力取、取不到返回空串、绝不因此让删除失败** ⇒ 这里吞掉一切异常。
+		*/
+		async titleOf(sessionId) {
+			try {
+				const header = await registry.readSessionHeader(sessionId);
+				const cache = projectionCacheOf(host);
+				const title = (cache?.cachedSnapshot(header, ["title"]) ?? cache?.cachedPredecessorTitle(header))?.values.title;
+				return typeof title === "string" ? title : "";
+			} catch {
+				return "";
+			}
+		},
+		/**
+		* 活跃判据 = 宿主官方那一条（设计稿 §5）：`workspace/session-activity` waterfall 问一次，
+		* **空数组 = 无活动**；与宿主自己的 `archiveSession` 准入同源，不自创第二套。
+		* asar 原文：`const activity = await this.ctx.waterfall('workspace/session-activity', { sessionId }, () => Promise.resolve([]));
+		* if (activity.length > 0) throw new WorkspaceActiveSessionError(sessionId, activity);`
+		*/
+		async isLive(sessionId) {
+			return (await host.waterfall("workspace/session-activity", { sessionId }, () => Promise.resolve([]))).length > 0;
+		},
+		/** registry 全局归档集（数组，`state.archivedSessionIds`）。 */
+		async isArchived(sessionId) {
+			return registry.archivedSessionIds.includes(sessionId);
+		},
+		/**
+		* 从 `ctx.sessions`（live store）里摘掉一个会话。
+		*
+		* **为什么需要**：会话列表读面是并集——`sessionQuery.listSessions()` = 磁盘上的持久化 ∪ `ctx.sessions` 里的活体
+		* （见设计稿 §4 末）。搬走文件只清掉一侧；本机运行期打开过的会话是活体，列表照样把它交出来，
+		* 于是"删了还在"（真机实测：文件已进回收站、账本已摘，侧栏仍留着那一行）。
+		*
+		* **这是未声明为契约的内部入口**（设计稿 §4 末记了这次偏离）：`liveEntryFor` / `entry.detach()` 是 store
+		* 给**会话 owner**（agent 的 effect 链）用的，宿主自己的控制器 `createOrAdopt` 只取 `agents.create()`
+		* 返回的 `.agent`、把带 `dispose` 的 handle 丢掉了，`ctx.agents` 也没有 `liveEntryFor` 那样的入口
+		* （会话 store 有、agent store 没有，逐成员面核过）⇒ 只能摘到"会话"这一层，上面那具 agent 摘不到，
+		* 它之后若走到 `flush(session)` 会撞 `liveEntryFor` 抛 `session "…" is not live in this store`。
+		*
+		* **所以判据是三态**：读不到 store / 形状不符（旧版宿主）/ detach 抛 ⇒ `unknown`（**不通告**，
+		* 因为无法断言宿主列表已经干净）；内存里本来没有 ⇒ `not-live`；摘成功 ⇒ `evicted`。
+		* 任何一步都不抛：删除的持久化部分已经完成，这里不该把它翻成失败。
+		*/
+		async evictLive(sessionId) {
+			try {
+				const store = liveSessionsOf(host);
+				if (store === void 0) return "unknown";
+				const session = store.get(sessionId);
+				if (session === void 0 || session === null) return "not-live";
+				const entry = store.liveEntryFor(session);
+				if (entry === void 0 || entry === null || typeof entry.detach !== "function") return "unknown";
+				entry.detach();
+				return "evicted";
+			} catch {
+				return "unknown";
+			}
+		},
+		/**
+		* 通告客户端"这个会话没了"。
+		*
+		* **为什么需要**：客户端那一行只由两条路更新——重连时的整表重列（`handleConnected` → `refreshList`），
+		* 或宿主转发的 `api-session/*` 事件。删除一个**冷**会话时宿主不会发任何事件（`session/disposed` 只在摘掉
+		* 活体时才有），所以那一行会一直挂到下次重连为止（真机实测就是这个形状）。
+		*
+		* **为什么这样发是对的**：`api-session/removed` 是宿主**自己声明并转发**的事件
+		* （asar `dsh-api-remotes/lib/remote-events.js` 的 `API_REMOTE_FORWARDED_EVENTS` 里
+		* `{ event: "api-session/removed", mode: "emit" }`；转发器就是 `ctx.on(event, …)` 的普通监听者）；
+		* 我们不带 carrier 地 emit ⇒ 全量派发到它（见 {@link HostCtxLike.emit}）⇒ 客户端
+		* `ctx.remote.$on("api-session/removed", …)` 收到后 `recordMutation({kind:'remove'})` + `handleRemoved()`。
+		* **只在"宿主列表确实已经不含它"时调用**（调用方按 {@link EvictionOutcome} 判）：这条通告在语义上是**如实**
+		* 的，不是障眼法。
+		*/
+		async announceRemoved(sessionId) {
+			try {
+				host.emit("api-session/removed", sessionId);
+			} catch {}
+		},
+		/**
+		* 通告客户端"这个会话回来了"（恢复用）。
+		*
+		* 摘要**取自宿主自己的会话列表**（`ctx.sessionController.list()`），不自己造一行：客户端 `handleSessionAdded`
+		* 要的是宿主 `summaryFor` 那套形状（sessionId / updatedAt / blank / projections…），照抄宿主的那一份最可靠。
+		* 取不到（控制器缺席 / 列表里没有它 / 抛错）就**一条都不发**——恢复本身已经完成，只是要等下次重连才上屏。
+		*/
+		async announceRestored(sessionId) {
+			try {
+				const controller = host.get("sessionController");
+				if (controller === void 0 || controller === null || typeof controller.list !== "function") return;
+				const listed = await controller.list();
+				const items = Array.isArray(listed) ? listed : listed?.items;
+				if (!Array.isArray(items)) return;
+				const summary = items.find((item) => item?.sessionId === sessionId);
+				if (summary === void 0) return;
+				host.emit("api-session/added", JSON.parse(JSON.stringify(summary)));
+			} catch {}
+		},
+		/** 官方 `unarchiveSession(sessionId)`：未归档是幂等 no-op。 */
+		async unarchive(sessionId) {
+			await registry.unarchiveSession(sessionId);
+		},
+		/** 摘账本：实体方法 `detachSession`（顶层没有）；未知工作区**响亮失败**，不静默当成功。 */
+		async detach(sessionId, workspaceId) {
+			const workspace = registry.get(workspaceId);
+			if (workspace === void 0) throw new Error(`workspace not found (detach): ${workspaceId}`);
+			await workspace.detachSession(sessionId);
+		},
+		/** 挂账本：实体方法 `attachSession`（顶层没有）。 */
+		async attach(sessionId, workspaceId) {
+			const workspace = registry.get(workspaceId);
+			if (workspace === void 0) throw new Error(`workspace not found (attach): ${workspaceId}`);
+			await workspace.attachSession(sessionId);
+		},
+		/** 确保归档：官方 `archiveSession(sessionId)`。归档是 registry **全局**的，与工作区账目无关
+		*  （JSDoc 原文 "its workspace accounting — or lack of one — is irrelevant"），所以 `workspaceId` 不用
+		*  ——未分组的会话没有工作区可传，签名里它是可选的。
+		*  不带 `stopActivity` ⇒ 有活动即抛 `WorkspaceActiveSessionError`（→ `sessiondelete/live`，设计稿 §6）。 */
+		async archive(sessionId) {
+			await registry.archiveSession(sessionId);
+		}
+	};
+}
+//#endregion
+//#region src/trash/manifest.ts
+function createStorageManifest$1(domain) {
+	return {
+		async list() {
+			return (await domain.readAll()).sort((a, b) => b.deletedAt - a.deletedAt);
+		},
+		async add(e) {
+			await domain.put(e);
+		},
+		async remove(id) {
+			await domain.delete(id);
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+const name = "@xrn1997/dsh-session-delete";
+/**
+* 插件依赖：**只写字符串数组**（隔离数据根上实测：写成 `{ required, optional }` 会让插件停在
+* `pending (waiting for services: required, optional)`）。
+*
+* 三项都是在隔离数据根上实测注入成功、且本插件真正用到的宿主服务。三个**故意不写**的：
+* - `remote`：那是**浏览器半**的服务（asar `dsh-api-gateway/lib/client.js`：`super(ctx, "remote")`），
+*   Node 半挂的是 `ctx.typertGateway`。把它写进 Node 半的 inject 会让插件永远 pending（同 `slots` 那次的形状）。
+* - `sessions` / `sessionProjectionCache`：前者本实现不用（活跃判据走 waterfall，见设计稿 §5）；后者是**可选**服务，
+*   官方消费方也按可选读（`ctx.get('sessionProjectionCache')?.…`），inject 一个可能没挂的服务 = 整个插件 pending。
+*   它取不到时 `titleOf` 返回空串，正是契约允许的降级。
+*
+* `webServer` 是**浏览器半取数通道的承载者**（那条薄线）：插件用它注册 `/dsh-session-delete-api`
+* 前缀路由，浏览器半同源 fetch 那四个端点。它是宿主 web 组成里的硬依赖（`dsh-host-webserver` 的
+* `super(ctx, "webServer")`），服务名与 `register({kind:'prefix', path, handler})` 的形状按
+* `dsh-host-webserver/lib/index.js` 与 `README.md` 原文读实，不是猜的。
+*/
+const inject = [
+	"workspaceRegistry",
+	"storageDomain",
+	"webServer"
+];
+/** 本插件自己的域（设计稿 §3：介质落在 `~/.dsh/storages/`）。
+*
+*  **名字必须带插件专属前缀**：domain 名是 `storageDomain` facility 里的**全局键**，而**一个名字在
+*  一个 facility 里只能 `open()` 一次**（句柄归调用方所有）——别人先占了同名域，本插件会**在激活时**
+*  抛错，整个插件不工作。前缀取 npm scope（`xrn1997`），后面接插件与内容。
+*  名字还要过宿主的 `UNIT_NAME_RE`（asar `dsh-storage/lib/index.js` 原文 `/^[a-z][a-z0-9_]*$/`）
+*  ⇒ 只能小写字母数字下划线，`@` / `/` / `-` 都不行。 */
+const TRASH_DOMAIN_NAME = "xrn1997_session_delete_trash";
+const UNIT_NAME_RE = /^[a-z][a-z0-9_]*$/;
+/**
+* `defineDomain` / `domainTable` 的窄镜像。官方实现在 asar
+* `dsh/node_modules/@deepseek-ai/dsh-storage-domain/lib/index.js`：
+* `function domainTable(schema) { return { valueSchema: schema }; }`；
+* `defineDomain(spec)` 逐项校验（`UNIT_NAME_RE`、version 为非负整数、`compatibleVersions` 必须低于 version、
+* `layout` ∈ {single, per-record}、`invalidRecords` ∈ {backup-and-skip}、表名同样过 `UNIT_NAME_RE`）后**原样返回 spec**。
+* 它是宿主包：跨插件值 import 是红线，它也不在本插件依赖里 ⇒ 照原文写一份本地镜像。
+*/
+function domainTable(schema) {
+	return { valueSchema: schema };
+}
+function defineDomain(spec) {
+	if (!UNIT_NAME_RE.test(spec.name)) throw new Error(`domain name '${spec.name}' must match ${UNIT_NAME_RE}`);
+	if (!Number.isInteger(spec.version) || spec.version < 0) throw new Error(`domain '${spec.name}' version must be a non-negative integer, got ${spec.version}`);
+	if (spec.layout !== void 0 && spec.layout !== "single" && spec.layout !== "per-record") throw new Error(`domain '${spec.name}' layout must be 'single' or 'per-record', got ${spec.layout}`);
+	if (spec.invalidRecords !== void 0 && spec.invalidRecords !== "backup-and-skip") throw new Error(`domain '${spec.name}' invalidRecords must be 'backup-and-skip' when present`);
+	for (const table of Object.keys(spec.tables)) if (!UNIT_NAME_RE.test(table)) throw new Error(`domain '${spec.name}' table name '${table}' must match ${UNIT_NAME_RE}`);
+	return spec;
+}
+/** `TrashEntry` 的字段面（`src/trash/entry.ts` 的接口逐项）。 */
+const TRASH_ENTRY_FIELDS = {
+	id: "string",
+	sessionId: "string",
+	projectDir: "string",
+	workspaceId: "string",
+	wasArchived: "boolean",
+	deletedAt: "number",
+	title: "string",
+	sizeBytes: "number"
+};
+/**
+* 回收站清单的域声明。
+*
+* `layout: 'per-record'` + `invalidRecords: 'backup-and-skip'`：一条坏记录被域层移开并跳过（清单是可丢数据，
+* 不该让一份坏文档把整个域开不起来）；`single` 布局下没有 `backupRecord`，一条坏记录会让 `open()` 整个失败。
+* 同款选择：官方 `session_projcache` 域也是 `per-record` + `backup-and-skip`（其 spec 的 JSDoc 明写理由）。
+*/
+const trashDomainSpec = defineDomain({
+	name: TRASH_DOMAIN_NAME,
+	version: 1,
+	layout: "per-record",
+	invalidRecords: "backup-and-skip",
+	tables: { entries: domainTable({ parse(raw) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new TypeError("session trash entry record must be a plain object");
+		for (const [field, kind] of Object.entries(TRASH_ENTRY_FIELDS)) if (typeof raw[field] !== kind) throw new TypeError(`session trash entry record field "${field}" must be a ${kind}`);
+		return raw;
+	} }) }
+});
+/**
+* 清单的真实绑定：官方 storage domain → `ManifestPort`（`StorageDomainLike` 在动词层保持一种读法）。
+* 域**懒开**且只开一次（`apply` 是同步的，而 `open()` 是异步的），并挂一条 `ctx.effect` 清理：
+* 插件卸载时关掉句柄（句柄归调用方所有，这是 `open()` 的 JSDoc 明写的契约）。
+*/
+function createStorageManifest(ctx) {
+	const host = ctx;
+	let opening;
+	ctx.effect(() => () => {
+		opening?.then((handle) => handle.close()).catch(() => {});
+	}, "session-delete.manifest");
+	const table = async () => {
+		opening ??= host.storageDomain.open(trashDomainSpec);
+		return (await opening).table("entries");
+	};
+	return createStorageManifest$1({
+		readAll: async () => [...(await table()).entries()].map(([, record]) => record),
+		put: async (record) => {
+			await (await table()).put(record.id, record);
+		},
+		delete: async (key) => {
+			await (await table()).delete(key);
+		}
+	});
+}
+/**
+* 宿主数据根。官方解析器在 asar `dsh/node_modules/@deepseek-ai/dsh-home-paths/lib/index.js`：
+* `resolveDshHome(configured, env)` 的优先级 = 显式配置 > `$DSH_HOME`（**空白视为未设**，免得非法覆盖把 home
+* 解析成当前工作目录）> `~/.dsh`，并 `resolve()` 规范化、展开 `~/`。
+*
+* **只镜像后两级，且这与平台的同款设施等价**——"显式配置"那一级对插件**不可得**，三条实证：
+*  ① 平台自己的 helper `dshHomePath(...segments)` 逐字是 `join(resolveDshHome(), ...segments)`，
+*     **同样不传 `configured`**；
+*  ② `ctx.profileContext` 按 launcher 原文只装「profile 位置 / 启动 bundle 名 / 调用覆盖 / 遥测开关」，
+*     里面没有数据根；
+*  ③ 宿主自己的服务也不是"问出来"的——它们各自声明 `Config.dshHome`，由**装配那一行的人**填。
+* ⇒ 后果与边界（设计稿 §5）：显式配置过的 profile 上我们算出的根与宿主不一致 ⇒ 文件探测落空 ⇒
+* 删除/恢复以 `not-found` **响亮拒绝、零副作用**；**不会**动到别的树（sessions 与回收站同源 ⇒ 同卷）。
+* 本机两条路径都因此对得上：桌面版走 `~/.dsh`（实测 profile 在其下），隔离探针靠 `$DSH_HOME`。
+*/
+function resolveHome(env = process.env) {
+	const fromEnv = env.DSH_HOME;
+	const raw = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join(homedir(), ".dsh");
+	if (raw === "~") return homedir();
+	if (raw.startsWith("~/") || raw.startsWith("~\\")) return resolve(join(homedir(), raw.slice(2)));
+	return resolve(raw);
+}
+/**
+* 装配顺序：**清单 → 端口 → 动词依赖 → 前缀路由**（`DeleteDeps` 就是前两者的合一）。
+*
+* 路由用 `ctx.effect` 挂、disposer 归装载它的那根 fiber：插件卸载即摘路由（`register` 返回的
+* disposer 是官方契约）。**同一进程里只注册一次**这件事由宿主把住：重复的 `(kind, path)`
+* 在 `register` 里直接抛（`webserver: duplicate prefix route "…"`），响亮失败而不是悄悄覆盖。
+*/
+function apply(ctx) {
+	const deps = {
+		fs: createFsPort(),
+		host: createHostPort(ctx),
+		manifest: createStorageManifest(ctx),
+		home: resolveHome(),
+		now: () => Date.now()
+	};
+	const webServer = ctx.webServer;
+	ctx.effect(() => {
+		const dispose = webServer.register({
+			kind: "prefix",
+			path: SESSION_DELETE_API_PREFIX,
+			handler: createApiHandler(deps)
+		});
+		return () => {
+			dispose();
+		};
+	}, "session-delete: /dsh-session-delete-api routes");
+}
+//#endregion
+export { apply, createStorageManifest, inject, name };