soulnet-dsh 0.1.0

package/lib/index.js

@@ -0,0 +1,2547 @@
+import { a as isReplyTier, n as DEFAULT_REPLY_TIER, o as normalizeTier, t as sendAndArchive } from "./send-DcYQC5CC.js";
+import { i as ProtocolFile, n as SOULMIRROR_PLUGIN, t as RELAY_FORM } from "./events-DHPK3pow.js";
+import { n as NetworkErrorCode, t as NetworkError } from "./types-zwvjR1n5.js";
+import { createRequire } from "node:module";
+import { delimiter, dirname, isAbsolute, join } from "node:path";
+import { accessSync, chmodSync, constants, realpathSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createInterface } from "node:readline";
+//#region src/api/index.ts
+const API_PREFIX = "/soulmirror/api/";
+function readJson(req, limit = 262144) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > limit) {
+				reject(/* @__PURE__ */ new Error("request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (chunks.length === 0) {
+				resolve({});
+				return;
+			}
+			try {
+				const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+				resolve(typeof parsed === "object" && parsed !== null ? parsed : {});
+			} catch (error) {
+				reject(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function send(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store",
+		"content-length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+function errorBody(error) {
+	if (error instanceof NetworkError) return { error: {
+		code: error.code,
+		message: error.message
+	} };
+	return { error: {
+		code: -32603,
+		message: error instanceof Error ? error.message : String(error)
+	} };
+}
+const bad = (message) => ({
+	status: 400,
+	body: { error: {
+		code: -32602,
+		message
+	} }
+});
+const text = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+const num = (value) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) return Number(value);
+};
+/** `fps` as a JSON array (POST) or a comma-separated query value (GET). */
+const fpList = (value) => {
+	if (Array.isArray(value)) return value.filter((v) => typeof v === "string" && v !== "");
+	if (typeof value === "string") return value.split(",").map((v) => v.trim()).filter((v) => v !== "");
+	return [];
+};
+/** GET routes whose query string stands in for the JSON body (`?fp=…&since=…&limit=…`, `?fps=a,b`). */
+const QUERY_ROUTES = /* @__PURE__ */ new Set([
+	"state",
+	"conversation.get",
+	"presence",
+	"session.latest",
+	"session.history",
+	"protocol.get",
+	"drafts.list"
+]);
+function createApiHandler(options) {
+	const { client } = options;
+	const sseClients = /* @__PURE__ */ new Set();
+	const protocol = ProtocolFile.at(join(options.home, "a2a"));
+	const broadcast = (event) => {
+		if (sseClients.size === 0) return;
+		const frame = `event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`;
+		for (const res of sseClients) try {
+			res.write(frame);
+		} catch {
+			sseClients.delete(res);
+		}
+	};
+	const unsubscribe = client.subscribe(broadcast);
+	/** Direct send through the peer (the settings' debug "send as myself"), broadcast as `outbound` to every SSE client. */
+	const sendDirect = async (fp, body) => {
+		const result = await sendAndArchive(client, fp, body);
+		broadcast({
+			kind: "outbound",
+			fp,
+			entry: result.entry
+		});
+		return result;
+	};
+	/** The friend row as the browser sees it: the peer's record + the plugin's tier + pending draft count. */
+	const friendRow = (friend, sessions) => {
+		const fp = friend["fp"];
+		const tier = sessions?.tierOf(fp) ?? options.settings().defaultTier;
+		const explicit = sessions?.tierStored(fp) !== void 0;
+		const drafts = sessions?.drafts.count(fp) ?? 0;
+		return {
+			...friend,
+			tier,
+			...explicit ? { tierExplicit: true } : {},
+			...drafts > 0 ? { drafts } : {}
+		};
+	};
+	const state = async () => {
+		const status = client.status();
+		let identity = null;
+		let friends = [];
+		let pending = [];
+		let error;
+		const sessions = options.sessions();
+		try {
+			const id = await client.identity();
+			if (id !== void 0) {
+				identity = {
+					fp: id.fp,
+					name: id.name,
+					cardUri: id.cardUri,
+					...id.createdAt === void 0 ? {} : { createdAt: id.createdAt }
+				};
+				const [f, p] = await Promise.all([client.friends.list(), client.friends.pending()]);
+				pending = [...p];
+				let online = {};
+				if (f.length > 0) try {
+					online = await client.presence(f.map((x) => x.fp));
+				} catch {}
+				friends = f.map((x) => friendRow(online[x.fp] === void 0 ? x : {
+					...x,
+					online: online[x.fp]
+				}, sessions));
+			}
+		} catch (e) {
+			error = e instanceof Error ? e.message : String(e);
+		}
+		const settings = options.settings();
+		const alterState = sessions?.latest();
+		return {
+			backend: client.backend,
+			status,
+			home: options.home,
+			settingsNamespace: options.settingsNamespace,
+			identity,
+			friends,
+			pending,
+			drafts: sessions?.drafts.list() ?? [],
+			alter: {
+				sessionId: sessions?.sessionId() ?? null,
+				status: alterState?.status ?? "idle",
+				defaultTier: settings.defaultTier,
+				autoReplyPerHour: settings.autoReplyPerHour,
+				directSend: settings.directSend,
+				protocolPath: protocol.path,
+				protocolExists: protocol.exists(),
+				legacyFriendSessions: sessions?.legacyFriendSessions() ?? {}
+			},
+			...error === void 0 ? {} : { error }
+		};
+	};
+	const handle = async (route, method, body) => {
+		switch (route) {
+			case "state": return {
+				status: 200,
+				body: await state()
+			};
+			case "identity.create": {
+				const name = text(body["name"]);
+				if (name === void 0) return bad("name must not be empty");
+				return {
+					status: 200,
+					body: { identity: await client.createIdentity(name) }
+				};
+			}
+			case "card.parse": {
+				const uri = text(body["uri"]);
+				if (uri === void 0) return bad("uri must not be empty");
+				return {
+					status: 200,
+					body: await client.parseCard(uri)
+				};
+			}
+			case "friends.add": {
+				const cardUri = text(body["card_uri"]);
+				if (cardUri === void 0) return bad("card_uri must not be empty");
+				const friend = await client.friends.add(cardUri, text(body["note"]));
+				options.log("info", `friend request sent to ${friend.name} (${friend.fp}) via settings/command`);
+				return {
+					status: 200,
+					body: { friend }
+				};
+			}
+			case "friends.accept": {
+				const id = text(body["id"]);
+				if (id === void 0) return bad("id must not be empty");
+				const friend = await client.friends.accept(id, text(body["note"]));
+				options.sessions()?.noteFriend(friend);
+				return {
+					status: 200,
+					body: { friend: friendRow(friend, options.sessions()) }
+				};
+			}
+			case "friends.reject": {
+				const id = text(body["id"]);
+				if (id === void 0) return bad("id must not be empty");
+				await client.friends.reject(id);
+				return {
+					status: 200,
+					body: { ok: true }
+				};
+			}
+			case "friends.set": {
+				const fp = text(body["fp"]);
+				if (fp === void 0) return bad("fp must not be empty");
+				const note = text(body["note"]);
+				const protocolOverride = typeof body["protocol"] === "string" ? body["protocol"] : void 0;
+				const tierValue = body["tier"];
+				if (tierValue !== void 0 && tierValue !== null && tierValue !== "" && !isReplyTier(tierValue)) return bad("tier must be notify | draft | auto (empty = default)");
+				const sessions = options.sessions();
+				let friend = (await client.friends.list()).find((f) => f.fp === fp);
+				if (friend === void 0) return {
+					status: 404,
+					body: { error: {
+						code: -32002,
+						message: "not a friend"
+					} }
+				};
+				if (note !== void 0 || protocolOverride !== void 0) {
+					friend = await client.friends.set(fp, {
+						...note === void 0 ? {} : { remark: note },
+						...protocolOverride === void 0 ? {} : { protocol: protocolOverride }
+					});
+					sessions?.noteFriend(friend);
+				}
+				if (tierValue !== void 0 && sessions !== void 0) await sessions.setTier(fp, isReplyTier(tierValue) ? tierValue : void 0);
+				options.log("info", `friends.set ${fp}: ${[
+					note !== void 0 ? "note" : "",
+					protocolOverride !== void 0 ? "protocol" : "",
+					tierValue !== void 0 ? `tier=${String(tierValue)}` : ""
+				].filter((s) => s !== "").join(" ")}`);
+				return {
+					status: 200,
+					body: { friend: friendRow(friend, sessions) }
+				};
+			}
+			case "friends.card": {
+				const fp = text(body["fp"]);
+				if (fp === void 0) return bad("fp must not be empty");
+				return {
+					status: 200,
+					body: await client.friends.card(fp)
+				};
+			}
+			case "conversation.markRead": {
+				const fp = text(body["fp"]);
+				if (fp === void 0) return bad("fp required");
+				await client.markRead(fp, typeof body["seq"] === "number" ? body["seq"] : 0);
+				await options.sessions()?.markRead(fp);
+				return {
+					status: 200,
+					body: { ok: true }
+				};
+			}
+			case "conversation.get": {
+				const fp = text(body["fp"]);
+				if (fp === void 0) return bad("fp must not be empty");
+				const since = num(body["since"]);
+				const limit = num(body["limit"]);
+				return {
+					status: 200,
+					body: await client.conversation(fp, {
+						...since === void 0 ? {} : { since },
+						...limit === void 0 ? {} : { limit }
+					})
+				};
+			}
+			case "message.send": {
+				const fp = text(body["fp"]);
+				if (fp === void 0) return bad("fp must not be empty");
+				const msg = typeof body["body"] === "string" ? body["body"].replace(/\s+$/, "") : "";
+				if (msg === "") return bad("body must not be empty");
+				const result = await sendDirect(fp, msg);
+				options.log("info", `direct send to ${fp} (debug): ${result.receipt.id} (${result.receipt.status}, seq ${result.receipt.seq ?? "?"})`);
+				return {
+					status: 200,
+					body: result
+				};
+			}
+			case "message.typing": {
+				const fp = text(body["fp"]);
+				if (fp === void 0) return bad("fp must not be empty");
+				await client.typing(fp, body["on"] !== false && body["on"] !== "false" && body["on"] !== 0);
+				return {
+					status: 200,
+					body: { ok: true }
+				};
+			}
+			case "presence": {
+				const fps = fpList(body["fps"]);
+				return {
+					status: 200,
+					body: { online: await client.presence(fps) }
+				};
+			}
+			case "alter.instruct": {
+				const instruction = typeof body["text"] === "string" ? body["text"].replace(/\s+$/, "") : "";
+				if (instruction === "") return bad("text must not be empty");
+				const sessions = options.sessions();
+				if (sessions === void 0) return {
+					status: 503,
+					body: { error: {
+						code: -32603,
+						message: "sessions plugin not mounted"
+					} }
+				};
+				const result = await sessions.instruct(instruction);
+				options.log("info", `owner → alter: session ${result.sessionId}, message ${result.messageId}`);
+				return {
+					status: 200,
+					body: {
+						...result,
+						state: sessions.latest() ?? null
+					}
+				};
+			}
+			case "session.latest": return {
+				status: 200,
+				body: { state: options.sessions()?.latest() ?? null }
+			};
+			case "session.history": {
+				const sessions = options.sessions();
+				const limit = num(body["limit"]);
+				if (sessions === void 0) return {
+					status: 200,
+					body: {
+						sessionId: null,
+						status: "idle",
+						chat: {
+							items: [],
+							running: false,
+							seq: 0
+						}
+					}
+				};
+				const h = sessions.history(limit);
+				return {
+					status: 200,
+					body: {
+						sessionId: h.sessionId ?? null,
+						status: h.status,
+						chat: h.chat
+					}
+				};
+			}
+			case "drafts.list": {
+				const fp = text(body["fp"]);
+				return {
+					status: 200,
+					body: { drafts: options.sessions()?.drafts.list(fp) ?? [] }
+				};
+			}
+			case "drafts.decide": {
+				const id = text(body["id"]);
+				if (id === void 0) return bad("id must not be empty");
+				const action = text(body["action"]);
+				const sessions = options.sessions();
+				if (sessions === void 0) return {
+					status: 503,
+					body: { error: {
+						code: -32603,
+						message: "sessions plugin not mounted"
+					} }
+				};
+				if (action === "approve") {
+					const edited = typeof body["body"] === "string" ? body["body"] : void 0;
+					return {
+						status: 200,
+						body: {
+							ok: true,
+							...await sessions.decideDraft(id, {
+								action: "approve",
+								...edited === void 0 ? {} : { body: edited }
+							})
+						}
+					};
+				}
+				if (action === "reject") return {
+					status: 200,
+					body: {
+						ok: true,
+						...await sessions.decideDraft(id, { action: "reject" })
+					}
+				};
+				if (action === "revise") {
+					const feedback = text(body["feedback"]);
+					if (feedback === void 0) return bad("feedback must not be empty");
+					return {
+						status: 200,
+						body: {
+							ok: true,
+							...await sessions.decideDraft(id, {
+								action: "revise",
+								feedback
+							})
+						}
+					};
+				}
+				return bad("action must be approve | reject | revise");
+			}
+			case "protocol.get": return {
+				status: 200,
+				body: {
+					text: protocol.read(),
+					path: protocol.path,
+					exists: protocol.exists()
+				}
+			};
+			case "protocol.set":
+				if (typeof body["text"] !== "string") return bad("text must be a string");
+				protocol.write(body["text"]);
+				options.log("info", `diplomacy protocol saved (${body["text"].length} chars) → ${protocol.path}`);
+				return {
+					status: 200,
+					body: {
+						ok: true,
+						text: protocol.read(),
+						path: protocol.path
+					}
+				};
+			default: return {
+				status: 404,
+				body: { error: {
+					code: -32601,
+					message: `unknown route ${method} ${route}`
+				} }
+			};
+		}
+	};
+	const handler = (async (req, res) => {
+		const url = new URL(req.url ?? "/", "http://localhost");
+		const route = url.pathname.startsWith("/soulmirror/api/") ? url.pathname.slice(16) : "";
+		if (route === "events" && req.method === "GET") {
+			res.writeHead(200, {
+				"content-type": "text/event-stream",
+				"cache-control": "no-store",
+				connection: "keep-alive"
+			});
+			res.write(`event: status\ndata: ${JSON.stringify({
+				kind: "status",
+				status: client.status()
+			})}\n\n`);
+			sseClients.add(res);
+			const keepAlive = setInterval(() => {
+				try {
+					res.write(": keep-alive\n\n");
+				} catch {
+					clearInterval(keepAlive);
+				}
+			}, 25e3);
+			keepAlive.unref?.();
+			req.on("close", () => {
+				clearInterval(keepAlive);
+				sseClients.delete(res);
+			});
+			return;
+		}
+		if (req.method !== "POST" && !(req.method === "GET" && QUERY_ROUTES.has(route))) {
+			send(res, 405, { error: {
+				code: -32600,
+				message: "use POST with application/json (GET only for state / conversation.get / presence / session.latest / session.history / drafts.list / protocol.get / events)"
+			} });
+			return;
+		}
+		try {
+			const body = req.method === "POST" ? await readJson(req) : Object.fromEntries(url.searchParams.entries());
+			const result = await handle(route, req.method ?? "GET", body);
+			send(res, result.status, result.body);
+		} catch (error) {
+			options.log("warn", `api ${route} failed: ${String(error)}`);
+			send(res, error instanceof NetworkError ? 400 : 500, errorBody(error));
+		}
+	});
+	handler.broadcast = broadcast;
+	handler.dispose = () => {
+		unsubscribe();
+		for (const res of sseClients) try {
+			res.end();
+		} catch {}
+		sseClients.clear();
+	};
+	return handler;
+}
+/** Mount the API on `ctx.webServer` when (and for as long as) that service exists. */
+function mountApi(ctx, options) {
+	ctx.inject(["webServer"], (wctx) => {
+		const handler = createApiHandler(options);
+		const dispose = wctx.webServer.register({
+			kind: "prefix",
+			path: API_PREFIX.slice(0, -1),
+			handler
+		});
+		options.log("info", `browser API mounted at ${API_PREFIX} (port ${wctx.webServer.port})`);
+		wctx.inject(["soulmirrorSessions"], (sctx) => {
+			const off = sctx.soulmirrorSessions.on((event) => {
+				handler.broadcast(event);
+			});
+			sctx.effect(() => off, "soulmirror: alter events → SSE");
+		});
+		wctx.effect(() => () => {
+			dispose();
+			handler.dispose();
+		}, "soulmirror: browser API");
+	});
+}
+//#endregion
+//#region src/network/fake.ts
+const fp$1 = (s) => s;
+const mid$1 = () => `a2a-${crypto.randomUUID()}`;
+const FAKE_FRIENDS = [{
+	fp: fp$1("fp-alice-1f2e3d4c5b6a7988"),
+	name: "college friend",
+	cardName: "Alice",
+	remark: "college friend",
+	online: true,
+	unread: 0,
+	count: 0
+}, {
+	fp: fp$1("fp-bob-9a8b7c6d5e4f3021"),
+	name: "Bob",
+	cardName: "Bob",
+	online: false,
+	unread: 0,
+	count: 0
+}];
+const FAKE_PENDING = [{
+	id: "req-carol-1",
+	fp: fp$1("fp-carol-5566778899aabbcc"),
+	name: "Carol",
+	greeting: "Hi, Alice gave me your card."
+}];
+function createFakeNetworkClient(options = {}) {
+	const listeners = /* @__PURE__ */ new Set();
+	const friends = new Map(FAKE_FRIENDS.map((f) => [f.fp, f]));
+	const pending = new Map(FAKE_PENDING.map((p) => [p.id, p]));
+	const conversations = /* @__PURE__ */ new Map();
+	let identity = options.noIdentity === true ? void 0 : {
+		fp: fp$1("fp-me-0000aaaabbbbcccc"),
+		name: "dsh tester",
+		cardUri: "soulmirror://card?v=1&pk=FAKE&xpk=FAKE&name=dsh%20tester"
+	};
+	let firstInboundFired = false;
+	let disposed = false;
+	const status = {
+		backend: "fake",
+		state: "ready",
+		restarts: 0
+	};
+	const emit = (event) => {
+		for (const l of listeners) try {
+			l(event);
+		} catch {}
+	};
+	const archive = (peer, entry) => {
+		const list = conversations.get(peer) ?? [];
+		const full = {
+			seq: list.length + 1,
+			...entry
+		};
+		list.push(full);
+		conversations.set(peer, list);
+		const friend = friends.get(peer);
+		if (friend !== void 0) friends.set(peer, {
+			...friend,
+			count: list.length,
+			unread: entry.dir === "in" ? friend.unread + 1 : friend.unread,
+			lastTs: entry.ts,
+			lastBody: entry.body
+		});
+		return full;
+	};
+	const deliver = (from, body, auto) => {
+		if (disposed) return;
+		const friend = friends.get(from);
+		const id = mid$1();
+		const ts = Date.now();
+		const entry = archive(from, {
+			dir: "in",
+			id,
+			body,
+			ts,
+			...auto ? { auto } : {}
+		});
+		emit({
+			kind: "message",
+			message: {
+				id,
+				from,
+				name: friend?.name ?? from,
+				body,
+				ts,
+				seq: entry.seq,
+				...auto ? { auto } : {}
+			}
+		});
+	};
+	const requireIdentity = () => {
+		if (identity === void 0) throw new NetworkError("no identity yet (identity.create first)", NetworkErrorCode.noIdentity);
+		return identity;
+	};
+	const friendFromCard = (uri, remark) => ({
+		fp: fp$1(`fp-${uri.slice(-8).replace(/[^a-z0-9]/gi, "") || "card"}`),
+		name: remark ?? `card ${uri.slice(-4)}`,
+		cardName: `card ${uri.slice(-4)}`,
+		...remark === void 0 ? {} : { remark },
+		unread: 0,
+		count: 0
+	});
+	return {
+		backend: "fake",
+		status: () => status,
+		identity: () => Promise.resolve(identity),
+		createIdentity: (name) => {
+			if (identity !== void 0) return Promise.reject(new NetworkError("identity already exists", NetworkErrorCode.identityExists));
+			identity = {
+				fp: fp$1("fp-me-0000aaaabbbbcccc"),
+				name,
+				cardUri: `soulmirror://card?v=1&pk=FAKE&xpk=FAKE&name=${encodeURIComponent(name)}`
+			};
+			return Promise.resolve(identity);
+		},
+		card: () => Promise.resolve(requireIdentity().cardUri),
+		parseCard: (uri) => {
+			if (!uri.startsWith("soulmirror://card")) return Promise.reject(new NetworkError("invalid card link", NetworkErrorCode.badCard));
+			const f = friendFromCard(uri);
+			return Promise.resolve({
+				fp: f.fp,
+				name: f.cardName ?? f.name,
+				uri
+			});
+		},
+		friends: {
+			list: () => Promise.resolve([...friends.values()]),
+			pending: () => Promise.resolve([...pending.values()]),
+			add: (uri, remark) => {
+				requireIdentity();
+				if (!uri.startsWith("soulmirror://card")) return Promise.reject(new NetworkError("invalid card link", NetworkErrorCode.badCard));
+				const f = friendFromCard(uri, remark);
+				friends.set(f.fp, f);
+				setTimeout(() => {
+					if (!disposed) emit({
+						kind: "friend_accept",
+						friend: f
+					});
+				}, 300);
+				return Promise.resolve(f);
+			},
+			accept: (requestId, note) => {
+				const req = pending.get(requestId);
+				if (req === void 0) return Promise.reject(new NetworkError("no such pending request", NetworkErrorCode.notFound));
+				pending.delete(requestId);
+				const f = {
+					fp: req.fp,
+					name: note ?? req.name,
+					cardName: req.name,
+					...note === void 0 ? {} : { remark: note },
+					unread: 0,
+					count: 0
+				};
+				friends.set(f.fp, f);
+				return Promise.resolve(f);
+			},
+			reject: (requestId) => {
+				if (!pending.delete(requestId)) return Promise.reject(new NetworkError("no such pending request", NetworkErrorCode.notFound));
+				return Promise.resolve();
+			},
+			set: (id, patch) => {
+				const cur = friends.get(id);
+				if (cur === void 0) return Promise.reject(new NetworkError("not a friend", NetworkErrorCode.notFriend));
+				const { protocol: _old, ...rest } = cur;
+				const protocol = patch.protocol === void 0 ? cur.protocol : patch.protocol.trim() === "" ? void 0 : patch.protocol;
+				const next = {
+					...rest,
+					...patch.remark === void 0 ? {} : {
+						remark: patch.remark,
+						name: patch.remark
+					},
+					...protocol === void 0 ? {} : { protocol }
+				};
+				friends.set(id, next);
+				return Promise.resolve(next);
+			},
+			remove: (id) => {
+				if (!friends.delete(id)) return Promise.reject(new NetworkError("not a friend", NetworkErrorCode.notFriend));
+				return Promise.resolve();
+			},
+			card: (id) => {
+				const cur = friends.get(id);
+				if (cur === void 0) return Promise.reject(new NetworkError("not a friend", NetworkErrorCode.notFriend));
+				return Promise.resolve({
+					fp: cur.fp,
+					name: cur.cardName ?? cur.name,
+					uri: `soulmirror://card?v=1&pk=FAKE-${cur.fp}&xpk=FAKE&name=${encodeURIComponent(cur.cardName ?? cur.name)}`
+				});
+			}
+		},
+		send: (to, body, options) => {
+			requireIdentity();
+			if (!friends.has(to)) return Promise.reject(new NetworkError("not a friend (friends.add first)", NetworkErrorCode.notFriend));
+			const id = mid$1();
+			const entry = archive(to, {
+				dir: "out",
+				id,
+				body,
+				ts: Date.now(),
+				status: "sent",
+				...options?.auto === true ? { auto: true } : {}
+			});
+			setTimeout(() => {
+				deliver(to, `(auto-reply) got it: "${body.slice(0, 40)}"`, true);
+			}, 600);
+			return Promise.resolve({
+				id,
+				seq: entry.seq,
+				status: "sent"
+			});
+		},
+		typing: (to, on) => {
+			if (!friends.has(to)) return Promise.reject(new NetworkError("not a friend", NetworkErrorCode.notFriend));
+			return Promise.resolve();
+		},
+		conversation: (target, opts = {}) => {
+			let entries = conversations.get(target) ?? [];
+			if (opts.since !== void 0) entries = entries.filter((e) => e.seq > opts.since);
+			if (opts.limit !== void 0 && opts.limit > 0 && entries.length > opts.limit) entries = entries.slice(-opts.limit);
+			return Promise.resolve({
+				entries,
+				typing: false
+			});
+		},
+		markRead: (target) => {
+			const cur = friends.get(target);
+			if (cur === void 0) return Promise.reject(new NetworkError("not a friend", NetworkErrorCode.notFriend));
+			friends.set(target, {
+				...cur,
+				unread: 0
+			});
+			return Promise.resolve();
+		},
+		presence: (fps) => Promise.resolve(Object.fromEntries(fps.map((f) => [f, friends.get(f)?.online ?? false]))),
+		subscribe: (listener) => {
+			listeners.add(listener);
+			if (!firstInboundFired) {
+				firstInboundFired = true;
+				const delay = options.firstInboundDelayMs ?? 1500;
+				if (delay >= 0) {
+					const alice = FAKE_FRIENDS[0];
+					setTimeout(() => {
+						deliver(alice.fp, "Hey, are you around? Hiking this weekend - bring your alter ego too!");
+					}, delay);
+				}
+			}
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		dispose: () => {
+			disposed = true;
+			listeners.clear();
+			return Promise.resolve();
+		},
+		debug: { inject: (from, body) => {
+			deliver(from, body);
+		} }
+	};
+}
+//#endregion
+//#region src/network/jsonrpc.ts
+/**
+* Minimal line-delimited JSON-RPC 2.0 endpoint over a pair of Node streams.
+*
+* Used by the `soulnet` backend (stdin/stdout of the peer process) and by the
+* unit tests (PassThrough streams standing in for a peer). One JSON object per
+* line; requests carry an incrementing numeric id; frames without an id are
+* notifications and are handed to `onNotification`.
+*/
+/** A JSON-RPC error response, or a transport failure (code -32099 family). */
+var JsonRpcError = class extends Error {
+	code;
+	data;
+	name = "JsonRpcError";
+	constructor(message, code, data) {
+		super(message);
+		this.code = code;
+		this.data = data;
+	}
+};
+/** Transport-level code: the endpoint closed before the response arrived. */
+const JSONRPC_CLOSED = -32099;
+/** Transport-level code: no response within the request timeout. */
+const JSONRPC_TIMEOUT = -32098;
+var JsonRpcEndpoint = class {
+	input;
+	output;
+	options;
+	pending = /* @__PURE__ */ new Map();
+	reader;
+	nextId = 1;
+	closed = false;
+	constructor(input, output, options = {}) {
+		this.input = input;
+		this.output = output;
+		this.options = options;
+		this.reader = createInterface({
+			input,
+			crlfDelay: Infinity
+		});
+		this.reader.on("line", (line) => {
+			this.handleLine(line);
+		});
+		this.reader.on("close", () => {
+			this.close();
+		});
+		input.on("error", (error) => {
+			this.close(error);
+		});
+		output.on("error", (error) => {
+			this.close(error);
+		});
+	}
+	get isClosed() {
+		return this.closed;
+	}
+	/** Send a request and await its result; rejects with {@link JsonRpcError}. */
+	request(method, params, options = {}) {
+		if (this.closed) return Promise.reject(new JsonRpcError(`${method}: endpoint is closed`, JSONRPC_CLOSED));
+		const id = this.nextId++;
+		return new Promise((resolve, reject) => {
+			const timeoutMs = options.timeoutMs ?? this.options.timeoutMs ?? 0;
+			const timer = timeoutMs > 0 ? setTimeout(() => {
+				this.pending.delete(id);
+				reject(new JsonRpcError(`${method}: no response within ${timeoutMs} ms`, JSONRPC_TIMEOUT));
+			}, timeoutMs) : void 0;
+			timer?.unref?.();
+			const settle = (fn) => {
+				if (timer !== void 0) clearTimeout(timer);
+				this.pending.delete(id);
+				fn();
+			};
+			this.pending.set(id, {
+				method,
+				timer,
+				resolve: (value) => {
+					settle(() => {
+						resolve(value);
+					});
+				},
+				reject: (error) => {
+					settle(() => {
+						reject(error);
+					});
+				}
+			});
+			if (options.signal !== void 0) {
+				const onAbort = () => {
+					this.pending.get(id)?.reject(new JsonRpcError(`${method}: aborted`, JSONRPC_CLOSED));
+				};
+				if (options.signal.aborted) onAbort();
+				else options.signal.addEventListener("abort", onAbort, { once: true });
+			}
+			if (!this.write({
+				jsonrpc: "2.0",
+				id,
+				method,
+				...params === void 0 ? {} : { params }
+			})) this.pending.get(id)?.reject(new JsonRpcError(`${method}: endpoint is closed`, JSONRPC_CLOSED));
+		});
+	}
+	/** Fire-and-forget request without an id (no response expected). */
+	notify(method, params) {
+		this.write({
+			jsonrpc: "2.0",
+			method,
+			...params === void 0 ? {} : { params }
+		});
+	}
+	/** Reject every pending request and stop reading. Idempotent. */
+	close(error) {
+		if (this.closed) return;
+		this.closed = true;
+		this.reader.close();
+		const reason = new JsonRpcError(error === void 0 ? "endpoint closed" : `endpoint closed: ${error.message}`, JSONRPC_CLOSED);
+		for (const entry of [...this.pending.values()]) entry.reject(reason);
+		this.pending.clear();
+		this.options.onClose?.(error);
+	}
+	write(frame) {
+		if (this.closed) return false;
+		try {
+			this.output.write(`${JSON.stringify(frame)}\n`);
+			return true;
+		} catch (error) {
+			this.close(error instanceof Error ? error : new Error(String(error)));
+			return false;
+		}
+	}
+	handleLine(line) {
+		const trimmed = line.trim();
+		if (trimmed === "") return;
+		let frame;
+		try {
+			frame = JSON.parse(trimmed);
+		} catch (error) {
+			this.options.onProtocolError?.(error instanceof Error ? error : new Error(String(error)), line);
+			return;
+		}
+		if (typeof frame !== "object" || frame === null) {
+			this.options.onProtocolError?.(/* @__PURE__ */ new Error("frame is not an object"), line);
+			return;
+		}
+		const f = frame;
+		if (typeof f.method === "string" && (f.id === void 0 || f.id === null)) {
+			this.options.onNotification?.({
+				method: f.method,
+				params: f.params
+			});
+			return;
+		}
+		if (typeof f.id !== "number") {
+			this.options.onProtocolError?.(/* @__PURE__ */ new Error("response without a numeric id"), line);
+			return;
+		}
+		const entry = this.pending.get(f.id);
+		if (entry === void 0) {
+			this.options.onProtocolError?.(/* @__PURE__ */ new Error(`response for unknown request id ${f.id}`), line);
+			return;
+		}
+		if (f.error !== void 0 && f.error !== null) {
+			const e = f.error;
+			entry.reject(new JsonRpcError(typeof e.message === "string" ? e.message : `${entry.method} failed`, typeof e.code === "number" ? e.code : -32603, e.data));
+			return;
+		}
+		entry.resolve(f.result);
+	}
+};
+//#endregion
+//#region src/network/soulnet.ts
+/**
+* `soulnet` backend: spawns the soulnet light peer (Go, ../cmd/soulnet) and
+* drives it over line-delimited JSON-RPC 2.0 on stdio (protocol: cmd/soulnet/
+* README.md, `initialize.protocol === "soulnet/1"`).
+*
+*  - request/response by id, notifications → `subscribe` listeners;
+*  - the process is restarted with exponential backoff when it dies;
+*  - `dispose()` sends `shutdown`, then kills the process if it lingers;
+*  - calls issued while the peer is (re)starting wait for it up to the request
+*    timeout instead of failing immediately.
+*
+* Binary lookup (`resolveSoulnetBinary` / `locateSoulnetBinary`), in order:
+*   1. the explicit `peerBinary` setting (absolute path, or a bare name looked up on PATH);
+*   2. the platform package `soulnet-peer-<os>-<arch>` installed next to
+*      this plugin as an optional dependency (`require.resolve('<pkg>/package.json')`
+*      from this file and from its realpath, so pnpm's symlinked virtual store and
+*      the hoisted layout both work) -> `<pkg>/bin/soulnet[.exe]`;
+*   3. `soulnet` on PATH;
+*   4. `<plugin dir>/bin/soulnet[.exe]` (a hand-dropped binary for development).
+* The winner and its source are reported in `BackendStatus.binary` / `binarySource`.
+*/
+const DEFAULT_RELAY = "https://relay.startupworld.cn";
+const SOULNET_PROTOCOL = "soulnet/1";
+/** Default home: `$SOULNET_HOME`, else `~/.soulnet` (same rule as the binary itself). */
+function defaultSoulnetHome(env = process.env) {
+	const fromEnv = env["SOULNET_HOME"];
+	if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+	return join(homedir(), ".soulnet");
+}
+function isExecutable(path) {
+	try {
+		accessSync(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** npm scope of the platform packages that ship the binary. */
+/** Prefix of the per-platform binary packages on npm (`soulnet-peer-<os>-<arch>`). */
+const PLATFORM_PACKAGE_PREFIX = "soulnet-peer-";
+/** The `<os>-<arch>` pairs a platform package exists for (must match dsh/packages/soulnet-*). */
+const PLATFORM_PACKAGE_TARGETS = [
+	"win32-x64",
+	"darwin-arm64",
+	"darwin-x64",
+	"linux-x64",
+	"linux-arm64"
+];
+/** `soulnet-peer-<os>-<arch>` for a supported pair, else `undefined`. */
+function platformPackageName(platform = process.platform, arch = process.arch) {
+	const target = `${platform}-${arch}`;
+	return PLATFORM_PACKAGE_TARGETS.includes(target) ? `${PLATFORM_PACKAGE_PREFIX}${target}` : void 0;
+}
+/**
+* Resolve an installed package's directory from this plugin's location: first
+* from this file's URL (dsh loads lib/index.js from the profile's node_modules,
+* hoisted or symlinked), then from its realpath (pnpm's isolated virtual store
+* keeps the optional dependency next to the REAL plugin directory).
+*/
+function defaultResolvePackageDir(name) {
+	const bases = [import.meta.url];
+	try {
+		const real = realpathSync(fileURLToPath(import.meta.url));
+		const realUrl = pathToFileURL(real).href;
+		if (realUrl !== import.meta.url) bases.push(realUrl);
+	} catch {}
+	for (const base of bases) try {
+		return dirname(createRequire(base).resolve(`${name}/package.json`));
+	} catch {}
+}
+function ensureExecutable(path, platform) {
+	if (platform === "win32") return;
+	try {
+		accessSync(path, constants.X_OK);
+	} catch {
+		try {
+			chmodSync(path, 493);
+		} catch {}
+	}
+}
+/**
+* Find the `soulnet` binary (order documented at the top of this file) and say
+* where it came from. `undefined` when nothing was found (the caller reports a
+* clear error).
+*/
+function locateSoulnetBinary(explicit, env = process.env, platform = process.platform, options = {}) {
+	const names = platform === "win32" ? ["soulnet.exe", "soulnet"] : ["soulnet"];
+	if (explicit !== void 0 && explicit.trim() !== "") {
+		const candidate = explicit.trim();
+		if (isAbsolute(candidate) || candidate.includes("/") || candidate.includes("\\")) return {
+			path: candidate,
+			source: "setting"
+		};
+		for (const dir of (env["PATH"] ?? "").split(delimiter)) {
+			if (dir === "") continue;
+			const full = join(dir, candidate);
+			if (isExecutable(full)) return {
+				path: full,
+				source: "setting"
+			};
+			if (platform === "win32" && !candidate.toLowerCase().endsWith(".exe") && isExecutable(`${full}.exe`)) return {
+				path: `${full}.exe`,
+				source: "setting"
+			};
+		}
+		return {
+			path: candidate,
+			source: "setting"
+		};
+	}
+	const pkgName = platformPackageName(platform, options.arch ?? process.arch);
+	if (pkgName !== void 0) {
+		const dir = (options.resolvePackageDir ?? defaultResolvePackageDir)(pkgName);
+		if (dir !== void 0) for (const name of names) {
+			const full = join(dir, "bin", name);
+			if (isExecutable(full)) {
+				ensureExecutable(full, platform);
+				return {
+					path: full,
+					source: "platform-package"
+				};
+			}
+		}
+	}
+	for (const dir of (env["PATH"] ?? "").split(delimiter)) {
+		if (dir === "") continue;
+		for (const name of names) {
+			const full = join(dir, name);
+			if (isExecutable(full)) return {
+				path: full,
+				source: "path"
+			};
+		}
+	}
+	const here = dirname(fileURLToPath(import.meta.url));
+	for (const root of [join(here, ".."), join(here, "..", "..")]) for (const name of names) {
+		const full = join(root, "bin", name);
+		if (isExecutable(full)) return {
+			path: full,
+			source: "plugin-bin"
+		};
+	}
+}
+const fp = (s) => s;
+const mid = (s) => s;
+function toMs(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const parsed = Date.parse(value);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return Date.now();
+}
+function str(value, fallback = "") {
+	return typeof value === "string" ? value : fallback;
+}
+function shortFp(value) {
+	return value.length > 12 ? `${value.slice(0, 12)}…` : value;
+}
+function friendFromWire(w) {
+	const fingerprint = str(w.fingerprint);
+	const note = str(w.note);
+	const cardName = str(w.card?.name);
+	const name = note !== "" ? note : cardName !== "" ? cardName : shortFp(fingerprint);
+	return {
+		fp: fp(fingerprint),
+		name,
+		...note === "" ? {} : { remark: note },
+		...cardName === "" ? {} : { cardName },
+		...str(w.protocol) === "" ? {} : { protocol: str(w.protocol) },
+		unread: typeof w.unread === "number" ? w.unread : 0,
+		count: typeof w.count === "number" ? w.count : 0,
+		...w.last?.ts === void 0 ? {} : { lastTs: toMs(w.last.ts) },
+		...w.last?.body === void 0 ? {} : { lastBody: w.last.body },
+		...w.typing === true ? { typing: true } : {},
+		...w.added_at === void 0 ? {} : { addedAt: w.added_at }
+	};
+}
+function pendingFromWire(w) {
+	const peer = str(w.peer);
+	const cardName = str(w.incoming?.card?.name);
+	return {
+		id: str(w.id),
+		fp: fp(peer),
+		name: cardName !== "" ? cardName : shortFp(peer),
+		greeting: str(w.incoming?.body),
+		...w.created_at === void 0 ? {} : { createdAt: w.created_at }
+	};
+}
+function entryFromWire(w) {
+	return {
+		seq: typeof w.seq === "number" ? w.seq : 0,
+		dir: w.dir === "out" ? "out" : "in",
+		id: mid(str(w.id)),
+		body: str(w.body),
+		ts: toMs(w.ts),
+		...w.type === void 0 || w.type === "" ? {} : { type: w.type },
+		...w.auto === true ? { auto: true } : {},
+		...w.status === void 0 || w.status === "" ? {} : { status: w.status },
+		...w.artifact_name === void 0 || w.artifact_name === "" ? {} : { artifactName: w.artifact_name }
+	};
+}
+function toNetworkError(error, method) {
+	if (error instanceof NetworkError) return error;
+	if (error instanceof JsonRpcError) {
+		const code = error.code === -32099 || error.code === -32098 ? NetworkErrorCode.peerUnavailable : error.code;
+		return new NetworkError(error.message, code, error.data);
+	}
+	return new NetworkError(`${method}: ${String(error)}`, -32603);
+}
+/**
+* Create the soulnet-backed NetworkClient. The process is spawned lazily on
+* the first call or on `start()`; `dispose()` stops it.
+*/
+function createSoulnetNetworkClient(options) {
+	const log = options.logger ?? (() => {});
+	const relay = options.relay !== void 0 && options.relay.trim() !== "" ? options.relay.trim() : DEFAULT_RELAY;
+	const requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+	const backoffInitial = options.backoff?.initialMs ?? 500;
+	const backoffMax = options.backoff?.maxMs ?? 3e4;
+	const backoffFactor = options.backoff?.factor ?? 2;
+	const listeners = /* @__PURE__ */ new Set();
+	let child;
+	let endpoint;
+	let disposed = false;
+	let started = false;
+	let restarts = 0;
+	let backoffMs = backoffInitial;
+	let restartTimer;
+	let status = {
+		backend: "soulnet",
+		state: "stopped",
+		restarts: 0,
+		relay,
+		home: options.home
+	};
+	let cachedCardUri;
+	const friendNames = /* @__PURE__ */ new Map();
+	let readyWaiters = [];
+	const emit = (event) => {
+		for (const listener of listeners) try {
+			listener(event);
+		} catch (error) {
+			log("warn", `network listener failed: ${String(error)}`);
+		}
+	};
+	const setStatus = (patch) => {
+		status = {
+			...status,
+			...patch
+		};
+		emit({
+			kind: "status",
+			status
+		});
+	};
+	const clearError = () => {
+		const { lastError: _dropped, ...rest } = status;
+		status = rest;
+	};
+	const handleNotification = (method, params) => {
+		const p = typeof params === "object" && params !== null ? params : {};
+		const peer = str(p.peer);
+		switch (method) {
+			case "message.received": {
+				const m = p.message ?? {};
+				const type = str(m.type, "text");
+				const name = friendNames.get(peer) ?? shortFp(peer);
+				const body = str(m.body) !== "" ? str(m.body) : type === "app_share" ? "[app share]" : "";
+				emit({
+					kind: "message",
+					message: {
+						id: mid(str(m.id)),
+						from: fp(peer),
+						name,
+						body,
+						ts: toMs(m.ts),
+						...typeof p.seq === "number" ? { seq: p.seq } : {},
+						...m.auto === true ? { auto: true } : {},
+						...type === "text" ? {} : { type },
+						...p.artifact_path === void 0 || p.artifact_path === "" ? {} : { artifactPath: p.artifact_path },
+						...m.artifact_name === void 0 || m.artifact_name === "" ? {} : { artifactName: m.artifact_name }
+					}
+				});
+				return;
+			}
+			case "friend.request": {
+				const m = p.message ?? {};
+				const cardName = str(m.card?.name);
+				emit({
+					kind: "friend_request",
+					request: {
+						id: str(p.pending_id),
+						fp: fp(peer),
+						name: cardName !== "" ? cardName : shortFp(peer),
+						greeting: str(m.body)
+					}
+				});
+				return;
+			}
+			case "friend.accepted": {
+				const friend = friendFromWire(p.friend ?? { fingerprint: peer });
+				friendNames.set(friend.fp, friend.name);
+				emit({
+					kind: "friend_accept",
+					friend
+				});
+				return;
+			}
+			case "typing":
+				emit({
+					kind: "typing",
+					fp: fp(peer),
+					on: p.on === true
+				});
+				return;
+			case "presence.changed":
+				emit({
+					kind: "presence",
+					fp: fp(peer),
+					online: p.on === true
+				});
+				return;
+			case "mission.update":
+			case "artifact.ready":
+				log("info", `soulnet notification ${method} from ${shortFp(peer)} (not handled in M1)`);
+				return;
+			default: log("warn", `unknown soulnet notification ${method}`);
+		}
+	};
+	const failWaiters = (error) => {
+		const waiters = readyWaiters;
+		readyWaiters = [];
+		for (const w of waiters) w.reject(error);
+	};
+	const scheduleRestart = (reason) => {
+		if (disposed) return;
+		restarts += 1;
+		const delay = backoffMs;
+		backoffMs = Math.min(backoffMax, Math.round(backoffMs * backoffFactor));
+		setStatus({
+			state: "restarting",
+			restarts,
+			lastError: reason
+		});
+		log("warn", `soulnet peer died (${reason}); restart #${restarts} in ${delay} ms`);
+		restartTimer = setTimeout(() => {
+			restartTimer = void 0;
+			spawnPeer();
+		}, delay);
+		restartTimer.unref?.();
+	};
+	const spawnPeer = () => {
+		if (disposed) return;
+		const location = locateSoulnetBinary(options.peerBinary);
+		if (location === void 0) {
+			const message = `soulnet binary not found: the platform package ${platformPackageName() ?? `soulnet-peer-<os>-<arch> (none published for ${process.platform}-${process.arch})`} is not installed next to the plugin (reinstall with optional dependencies enabled), or set \`peerBinary\` in the SoulMirror network settings, put \`soulnet\` on PATH, or place it in the plugin's bin/ directory`;
+			setStatus({
+				state: "error",
+				lastError: message
+			});
+			log("error", message);
+			failWaiters(new NetworkError(message, NetworkErrorCode.peerUnavailable));
+			return;
+		}
+		const binary = location.path;
+		const args = [
+			"--home",
+			options.home,
+			"--relay",
+			relay
+		];
+		clearError();
+		setStatus({
+			state: "starting",
+			binary,
+			binarySource: location.source
+		});
+		log("info", `soulnet binary: ${binary} (${location.source})`);
+		let proc;
+		try {
+			proc = options.spawn !== void 0 ? options.spawn({
+				binary,
+				args
+			}) : spawn(binary, args, {
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				windowsHide: true,
+				env: {
+					...process.env,
+					...options.env ?? {}
+				}
+			});
+		} catch (error) {
+			scheduleRestart(`spawn failed: ${String(error)}`);
+			return;
+		}
+		child = proc;
+		if (proc.stdout === null || proc.stdin === null) {
+			proc.kill();
+			scheduleRestart("spawned process has no stdio pipes");
+			return;
+		}
+		proc.stderr?.setEncoding("utf8");
+		proc.stderr?.on("data", (chunk) => {
+			for (const line of chunk.split(/\r?\n/)) if (line.trim() !== "") log("info", `[soulnet] ${line.trim()}`);
+		});
+		const ep = new JsonRpcEndpoint(proc.stdout, proc.stdin, {
+			timeoutMs: requestTimeoutMs,
+			onNotification: (n) => {
+				handleNotification(n.method, n.params);
+			},
+			onProtocolError: (error, line) => {
+				log("warn", `soulnet protocol: ${error.message}: ${line.slice(0, 200)}`);
+			}
+		});
+		endpoint = ep;
+		let exited = false;
+		proc.on("error", (error) => {
+			if (exited) return;
+			exited = true;
+			if (endpoint === ep) endpoint = void 0;
+			ep.close(error);
+			scheduleRestart(`process error: ${error.message}`);
+		});
+		proc.on("exit", (code, signal) => {
+			if (exited) return;
+			exited = true;
+			if (endpoint === ep) endpoint = void 0;
+			if (child === proc) child = void 0;
+			ep.close();
+			if (disposed) {
+				setStatus({ state: "stopped" });
+				return;
+			}
+			scheduleRestart(`exit code=${code ?? "null"} signal=${signal ?? "none"}`);
+		});
+		const name = options.displayName?.trim() ?? "";
+		ep.request("initialize", name === "" ? {} : { name }, { timeoutMs: 15e3 }).then((result) => {
+			const r = typeof result === "object" && result !== null ? result : {};
+			if (r.protocol !== "soulnet/1") log("warn", `soulnet speaks ${String(r.protocol)}; this plugin was written for ${SOULNET_PROTOCOL}`);
+			backoffMs = backoffInitial;
+			cachedCardUri = void 0;
+			setStatus({
+				state: "ready",
+				...proc.pid === void 0 ? {} : { pid: proc.pid },
+				...r.protocol === void 0 ? {} : { protocol: r.protocol },
+				...r.version === void 0 ? {} : { version: r.version },
+				...r.home === void 0 ? {} : { home: r.home },
+				...r.relay === void 0 ? {} : { relay: r.relay }
+			});
+			log("info", `soulnet peer ready pid=${proc.pid ?? "?"} protocol=${String(r.protocol)} identity=${r.identity?.fingerprint ?? "none"}`);
+			const waiters = readyWaiters;
+			readyWaiters = [];
+			for (const w of waiters) w.resolve(ep);
+		}).catch((error) => {
+			if (exited || disposed) return;
+			log("error", `soulnet initialize failed: ${String(error)}`);
+			proc.kill();
+		});
+	};
+	const ready = (timeoutMs) => {
+		if (disposed) return Promise.reject(new NetworkError("soulnet backend is disposed", NetworkErrorCode.peerUnavailable));
+		if (endpoint !== void 0 && !endpoint.isClosed && status.state === "ready") return Promise.resolve(endpoint);
+		if (!started) start();
+		if (status.state === "error") return Promise.reject(new NetworkError(status.lastError ?? "soulnet backend unavailable", NetworkErrorCode.peerUnavailable));
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				readyWaiters = readyWaiters.filter((w) => w.resolve !== resolve);
+				reject(new NetworkError(`soulnet peer not ready within ${timeoutMs} ms (state=${status.state})`, NetworkErrorCode.peerUnavailable));
+			}, timeoutMs);
+			timer.unref?.();
+			readyWaiters.push({
+				resolve: (ep) => {
+					clearTimeout(timer);
+					resolve(ep);
+				},
+				reject: (error) => {
+					clearTimeout(timer);
+					reject(error);
+				}
+			});
+		});
+	};
+	const call = async (method, params, timeoutMs = requestTimeoutMs) => {
+		const ep = await ready(timeoutMs);
+		try {
+			return await ep.request(method, params, { timeoutMs });
+		} catch (error) {
+			throw toNetworkError(error, method);
+		}
+	};
+	const start = () => {
+		if (started || disposed) return;
+		started = true;
+		spawnPeer();
+	};
+	const identity = async () => {
+		const r = await call("identity.get");
+		if (r.identity === void 0 || r.identity === null) return void 0;
+		const cardUri = await card();
+		return {
+			fp: fp(str(r.identity.fingerprint)),
+			name: str(r.identity.name),
+			cardUri,
+			...r.identity.created_at === void 0 ? {} : { createdAt: r.identity.created_at }
+		};
+	};
+	const card = async () => {
+		if (cachedCardUri !== void 0) return cachedCardUri;
+		cachedCardUri = str((await call("card.get")).uri);
+		return cachedCardUri;
+	};
+	const rememberNames = (friends) => {
+		for (const f of friends) friendNames.set(f.fp, f.name);
+	};
+	return {
+		backend: "soulnet",
+		start,
+		status: () => status,
+		identity,
+		createIdentity: async (name) => {
+			const r = await call("identity.create", { name });
+			cachedCardUri = void 0;
+			const cardUri = await card();
+			return {
+				fp: fp(str(r.identity?.fingerprint)),
+				name: str(r.identity?.name, name),
+				cardUri
+			};
+		},
+		card,
+		parseCard: async (uri) => {
+			const r = await call("card.parse", { uri });
+			return {
+				fp: fp(str(r.fingerprint)),
+				name: str(r.card?.name),
+				uri: str(r.uri, uri)
+			};
+		},
+		friends: {
+			list: async () => {
+				const friends = ((await call("friends.list")).friends ?? []).map(friendFromWire);
+				rememberNames(friends);
+				return friends;
+			},
+			pending: async () => {
+				return ((await call("friends.pending")).pending ?? []).map(pendingFromWire);
+			},
+			add: async (cardUri, note) => {
+				const friend = friendFromWire((await call("friends.add", {
+					card_uri: cardUri,
+					...note === void 0 ? {} : { note }
+				})).friend ?? {});
+				friendNames.set(friend.fp, friend.name);
+				return friend;
+			},
+			accept: async (requestId, note) => {
+				const friend = friendFromWire((await call("friends.accept", {
+					id: requestId,
+					...note === void 0 ? {} : { note }
+				})).friend ?? {});
+				friendNames.set(friend.fp, friend.name);
+				return friend;
+			},
+			reject: async (requestId) => {
+				await call("friends.reject", { id: requestId });
+			},
+			set: async (target, patch) => {
+				const friend = friendFromWire((await call("friends.set", {
+					fp: target,
+					...patch.remark === void 0 ? {} : { note: patch.remark },
+					...patch.protocol === void 0 ? {} : { protocol: patch.protocol }
+				})).friend ?? {});
+				friendNames.set(friend.fp, friend.name);
+				return friend;
+			},
+			remove: async (target) => {
+				await call("friends.remove", { fp: target });
+				friendNames.delete(target);
+			},
+			card: async (target) => {
+				const r = await call("friends.card", { fp: target });
+				return {
+					fp: fp(str(r.fingerprint, target)),
+					name: str(r.card?.name),
+					uri: str(r.uri)
+				};
+			}
+		},
+		send: async (to, body, options) => {
+			const r = await call("message.send", {
+				to,
+				body,
+				...options?.file === void 0 ? {} : { file: options.file },
+				...options?.auto === true ? { auto: true } : {}
+			});
+			return {
+				id: mid(str(r.id)),
+				status: str(r.status, "sent"),
+				...typeof r.seq === "number" ? { seq: r.seq } : {}
+			};
+		},
+		typing: async (to, on) => {
+			await call("message.typing", {
+				to,
+				on
+			}, 1e4);
+		},
+		conversation: async (target, opts = {}) => {
+			const r = await call("conversation.get", {
+				fp: target,
+				...opts.since === void 0 ? {} : { since: opts.since },
+				...opts.limit === void 0 ? {} : { limit: opts.limit }
+			});
+			return {
+				entries: (r.entries ?? []).map(entryFromWire),
+				typing: r.typing === true
+			};
+		},
+		markRead: async (target, seq) => {
+			await call("conversation.markRead", {
+				fp: target,
+				seq
+			});
+		},
+		presence: async (fps) => {
+			return (await call("presence", { fps: [...fps] }, 15e3)).online ?? {};
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		dispose: async () => {
+			if (disposed) return;
+			disposed = true;
+			if (restartTimer !== void 0) {
+				clearTimeout(restartTimer);
+				restartTimer = void 0;
+			}
+			failWaiters(new NetworkError("soulnet backend is disposed", NetworkErrorCode.peerUnavailable));
+			const proc = child;
+			const ep = endpoint;
+			if (proc === void 0) {
+				setStatus({ state: "stopped" });
+				return;
+			}
+			const exited = new Promise((resolve) => {
+				if (proc.exitCode !== null || proc.signalCode !== null) {
+					resolve();
+					return;
+				}
+				proc.once("exit", () => {
+					resolve();
+				});
+			});
+			if (ep !== void 0 && !ep.isClosed) try {
+				await ep.request("shutdown", void 0, { timeoutMs: 2e3 });
+			} catch {}
+			const killTimer = setTimeout(() => {
+				proc.kill();
+			}, 2e3);
+			killTimer.unref?.();
+			await exited;
+			clearTimeout(killTimer);
+			ep?.close();
+			setStatus({ state: "stopped" });
+			log("info", "soulnet peer stopped");
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.2/node_modules/@deepseek-ai/cosmokit/lib/index.js
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+Binary.fromBase64;
+Binary.toBase64;
+Binary.fromHex;
+Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+function deepEqual(a, b, strict) {
+	if (a === b) return true;
+	if (!strict && isNullable(a) && isNullable(b)) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	if (!a || !b) return false;
+	function check(test, then) {
+		return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+	}
+	return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+		if (a.byteLength !== b.byteLength) return false;
+		const viewA = new Uint8Array(a);
+		const viewB = new Uint8Array(b);
+		for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+		return true;
+	}) ?? Object.keys({
+		...a,
+		...b
+	}).every((key) => deepEqual(a[key], b[key], strict));
+}
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+schemastery@3.18.1/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options = {}) {
+		return Schema.resolve(data, schema, options)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options) => new Schema(options));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options = refs[key];
+			options.sKey = getRef(options.sKey);
+			options.inner = getRef(options.inner);
+			options.list = options.list && options.list.map(getRef);
+			options.dict = options.dict && mapValues(options.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value) : value;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+const resolvers = {};
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date = new Date(value);
+		if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name, keys, format) {
+	formatters[name] = format;
+	Object.assign(Schema, { [name](...args) {
+		const schema = new Schema({ type: name });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key in args[index]) {
+						if (typeof args[index][key] !== "number") continue;
+						schema.bits[key] = args[index][key];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name === "object" || name === "dict") schema.meta.default = {};
+		else if (name === "array" || name === "tuple") schema.meta.default = [];
+		else if (name === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+//#endregion
+//#region src/settings.ts
+/**
+* The `soulmirror` user-settings namespace (dsh `ctx.settings`): what the
+* browser settings section "SoulMirror network" edits and what the network
+* plugin reads when it spawns the backend. The connection fields apply on
+* the next plugin (re)load — the peer process is spawned with them
+* (`applies: 'restart'`); the alter fields (`defaultTier`, `autoReplyPerHour`,
+* `directSend`) are read live through `ctx.soulmirrorConfig.current()`. The
+* tiers decide how the alter handles a friend's mail (P4: `draft` = the
+* alter's reply waits as a pending draft on the SoulMirror page).
+*
+* `@deepseek-ai/schemastery` is a VALUE import here on purpose: the settings
+* seam needs a real schemastery schema (callable validator + `toJSON()` for
+* the browser form). It is a vendored, dependency-free library and gets
+* inlined into lib/index.js by tsdown, so the host half still has zero
+* `@deepseek-ai/*` runtime edges into the harness instance (see ../README.md).
+*/
+const SETTINGS_NAMESPACE = "soulmirror";
+const SOULMIRROR_SETTINGS_SCHEMA = Schema.object({
+	relay: Schema.string().default(DEFAULT_RELAY).description("Relay URL (used when the identity is created)."),
+	displayName: Schema.string().default("").description("Display name for a new identity (first start only)."),
+	backend: Schema.union([Schema.const("soulnet"), Schema.const("fake")]).default("soulnet").description("soulnet = the light peer binary; fake = in-memory test backend."),
+	peerBinary: Schema.string().default("").description("Path of the soulnet binary; empty = PATH, then the plugin bin/ directory."),
+	home: Schema.string().default("").description("Data directory; empty = $SOULNET_HOME, then ~/.soulnet."),
+	defaultTier: Schema.union([
+		Schema.const("notify"),
+		Schema.const("draft"),
+		Schema.const("auto")
+	]).default(DEFAULT_REPLY_TIER).description("Default reply tier for friends: notify = mail is only shown; draft = the alter drafts a reply you review on the SoulMirror page; auto = the alter replies by itself (rate-limited)."),
+	autoReplyPerHour: Schema.number().default(20).description("Maximum automatic replies per friend per hour in the auto tier (0 disables)."),
+	directSend: Schema.boolean().default(false).description("Debug: offer \"Send as myself\" in a friend thread (bypasses the alter); off by default.")
+});
+/** Fill in defaults for a partial section (plugin config or a stored user section). */
+function resolveSettings(partial) {
+	const perHour = typeof partial?.autoReplyPerHour === "number" && Number.isFinite(partial.autoReplyPerHour) ? Math.max(0, Math.floor(partial.autoReplyPerHour)) : 20;
+	return {
+		relay: partial?.relay !== void 0 && partial.relay.trim() !== "" ? partial.relay.trim() : DEFAULT_RELAY,
+		displayName: partial?.displayName ?? "",
+		backend: partial?.backend === "fake" ? "fake" : "soulnet",
+		peerBinary: partial?.peerBinary ?? "",
+		home: partial?.home ?? "",
+		defaultTier: normalizeTier(partial?.defaultTier),
+		autoReplyPerHour: perHour,
+		directSend: partial?.directSend === true
+	};
+}
+//#endregion
+//#region src/index.ts
+const name = "soulmirror-network";
+const inject = [];
+function apply(ctx, config = {}) {
+	const log = (level, message) => {
+		ctx.logger[level](`soulmirror-network: ${message}`);
+	};
+	const entry = resolveSettings(config);
+	let effective = entry;
+	let live = entry;
+	const settingsNow = ctx.get("settings");
+	if (settingsNow !== void 0) {
+		const scope = settingsNow.register(SETTINGS_NAMESPACE, SOULMIRROR_SETTINGS_SCHEMA, {
+			base: config,
+			applies: "restart"
+		});
+		effective = resolveSettings(scope.get());
+		live = effective;
+		scope.watch(() => {
+			live = resolveSettings(scope.get());
+			log("info", `settings changed (tier=${live.defaultTier}, autoReplyPerHour=${live.autoReplyPerHour}, directSend=${String(live.directSend)} apply now; connection fields apply when the plugin reloads)`);
+		});
+	} else ctx.inject(["settings"], (sctx) => {
+		const scope = sctx.settings.register(SETTINGS_NAMESPACE, SOULMIRROR_SETTINGS_SCHEMA, {
+			base: config,
+			applies: "restart"
+		});
+		live = resolveSettings(scope.get());
+		scope.watch(() => {
+			live = resolveSettings(scope.get());
+			log("info", "settings changed; alter fields apply now, connection fields when the plugin reloads");
+		});
+	});
+	ctx.provide("soulmirrorConfig", { current: () => live });
+	const home = effective.home !== "" ? effective.home : defaultSoulnetHome();
+	let client;
+	if (effective.backend === "fake") client = createFakeNetworkClient();
+	else {
+		const peer = createSoulnetNetworkClient({
+			home,
+			relay: effective.relay,
+			displayName: effective.displayName,
+			...effective.peerBinary === "" ? {} : { peerBinary: effective.peerBinary },
+			logger: log
+		});
+		peer.start();
+		client = peer;
+	}
+	ctx.provide("soulmirrorHome", home);
+	ctx.provide("soulmirror", client);
+	ctx.effect(() => () => {
+		client.dispose().catch((error) => {
+			log("warn", `dispose failed: ${String(error)}`);
+		});
+	}, "soulmirror-network: backend process");
+	mountApi(ctx, {
+		client,
+		home,
+		settingsNamespace: SETTINGS_NAMESPACE,
+		sessions: () => ctx.get("soulmirrorSessions"),
+		settings: () => live,
+		log
+	});
+	log("info", `backend=${client.backend} home=${home} relay=${effective.relay}`);
+}
+//#endregion
+export { RELAY_FORM, SETTINGS_NAMESPACE, SOULMIRROR_PLUGIN, apply, inject, name };
+
+//# sourceMappingURL=index.js.map