@morlay/session-rdb 0.0.19 → 0.0.21-alpha.0

package/src/usage.ts

@@ -0,0 +1,191 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { SessionPersistenceRdb } from "./index.ts";
+
+export const SESSION_USAGE_PATH = "/api/session.usage";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * 时间范围的语义键：`all` 不限；`day` / `week` 是**本地自然日 / 自然周**（周一起算）；
+ * `7d` / `30d` / `90d` 是最近 N 天（滚动窗口）。
+ */
+export type UsageRangeKey = "all" | "day" | "week" | "7d" | "30d" | "90d";
+
+const ROLLING_DAYS: Record<"7d" | "30d" | "90d", number> = { "7d": 7, "30d": 30, "90d": 90 };
+
+function localDayStart(now: number): Date {
+  const start = new Date(now);
+  start.setHours(0, 0, 0, 0);
+  return start;
+}
+
+/**
+ * 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
+ * @param range - 语义键。
+ * @param now - 当前时刻。
+ * @returns 起点毫秒时间戳，或 undefined。
+ */
+export function resolveUsageSince(range: UsageRangeKey, now: number): number | undefined {
+  switch (range) {
+    case "all":
+      return undefined;
+    case "day":
+      return localDayStart(now).getTime();
+    case "week": {
+      const start = localDayStart(now);
+      // getDay(): 0 = 周日；换算成「距离本周一几天」。
+      start.setDate(start.getDate() - ((start.getDay() + 6) % 7));
+      return start.getTime();
+    }
+    default:
+      return now - ROLLING_DAYS[range] * DAY_MS;
+  }
+}
+
+function parseUsageRange(value: unknown): UsageRangeKey {
+  return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d"
+    ? value
+    : "all";
+}
+
+/** 一段用量合计（token 字段直接取事件里模型报的 usage）。 */
+export interface UsageTotals {
+  events: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  reasoningTokens: number;
+  totalTokens: number;
+}
+
+/** 一天 × 一个模型 × 是否子代理 的用量桶：总览、按天、按模型都由它折叠。 */
+export interface UsageBucket extends UsageTotals {
+  day: string;
+  provider: string | null;
+  model: string | null;
+  subagent: boolean;
+}
+
+/** 一条会话的用量行。 */
+export interface UsageSessionRow extends UsageTotals {
+  sessionId: string;
+  title: string | null;
+  subagent: boolean;
+  archived: boolean;
+}
+
+/** 后端的原始聚合结果。 */
+export interface UsageAggregate {
+  buckets: UsageBucket[];
+  sessions: UsageSessionRow[];
+}
+
+/** 一次统计请求的完整回报。 */
+export interface SessionUsageReport {
+  totals: UsageTotals;
+  subagent: UsageTotals;
+  /** 只被人类会话引用的部分（`totals − subagent`）。 */
+  human: UsageTotals;
+  buckets: UsageBucket[];
+  sessions: UsageSessionRow[];
+}
+
+function emptyTotals(): UsageTotals {
+  return {
+    events: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+  };
+}
+
+/** 折叠一组行（桶或会话行）的用量。 */
+export function sumUsage(rows: readonly UsageTotals[]): UsageTotals {
+  const totals = emptyTotals();
+  for (const row of rows) {
+    totals.events += row.events;
+    totals.inputTokens += row.inputTokens;
+    totals.outputTokens += row.outputTokens;
+    totals.cacheReadTokens += row.cacheReadTokens;
+    totals.reasoningTokens += row.reasoningTokens;
+    totals.totalTokens += row.totalTokens;
+  }
+  return totals;
+}
+
+/**
+ * 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
+ * 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
+ */
+export function registerSessionUsage(ctx: Context, persistence: SessionPersistenceRdb): void {
+  ctx.inject(["webServer", "connection"] as const, (webCtx) => {
+    const webServer = webCtx.webServer as unknown as {
+      register(route: {
+        kind: "exact";
+        path: string;
+        handler: (
+          req: import("node:http").IncomingMessage,
+          res: import("node:http").ServerResponse,
+        ) => void | Promise<void>;
+      }): () => void;
+    };
+    const connection = webCtx.get("connection") as unknown as {
+      requestRejection(request: {
+        headers: import("node:http").IncomingHttpHeaders;
+      }): number | undefined;
+    };
+    return webCtx.effect(
+      () =>
+        webServer.register({
+          kind: "exact",
+          path: SESSION_USAGE_PATH,
+          handler: async (req, res) => {
+            const rejection = connection.requestRejection(req);
+            if (rejection !== undefined) {
+              res.writeHead(rejection);
+              res.end(rejection === 401 ? "unauthorized" : "forbidden");
+              return;
+            }
+            if (req.method !== "POST") {
+              res.writeHead(405, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: "method not allowed" }));
+              return;
+            }
+            const chunks: Buffer[] = [];
+            for await (const chunk of req) chunks.push(chunk as Buffer);
+            const raw = Buffer.concat(chunks).toString("utf8");
+            let envelope: { range?: unknown } = {};
+            if (raw !== "") {
+              try {
+                envelope = JSON.parse(raw) as { range?: unknown };
+              } catch {
+                res.writeHead(400, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: "request body is not JSON" }));
+                return;
+              }
+            }
+            try {
+              const aggregate = await persistence.usageReport(
+                resolveUsageSince(parseUsageRange(envelope.range), Date.now()),
+              );
+              const totals = sumUsage(aggregate.buckets);
+              const subagent = sumUsage(aggregate.buckets.filter((bucket) => bucket.subagent));
+              const human = sumUsage(aggregate.buckets.filter((bucket) => !bucket.subagent));
+              res.writeHead(200, { "content-type": "application/json" });
+              res.end(JSON.stringify({ totals, subagent, human, ...aggregate }));
+            } catch (error: unknown) {
+              res.writeHead(500, { "content-type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  error: error instanceof Error ? error.message : "usage report failed",
+                }),
+              );
+            }
+          },
+        }),
+      `session-rdb: ${SESSION_USAGE_PATH} route`,
+    );
+  });
+}

package/dist/import-Bc2QQa5G.mjs

@@ -1,473 +0,0 @@
-import { d as rowToMeta } from "./log-DO69NQnn.mjs";
-import { randomUUID } from "node:crypto";
-import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { parseSessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
-import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
-import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline } from "@morlay/session-branch";
-import { unzipSync } from "fflate";
-//#region src/branch.ts
-function locateTurnEnd(events, atSeq, mode = "after") {
-	const ends = events.filter((event) => event.type === "turn/end").map((event) => event.seq);
-	if (atSeq === void 0) {
-		const last = ends.at(-1);
-		if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
-		return last;
-	}
-	if (mode === "before") {
-		let boundary = -1;
-		for (const seq of ends) if (seq < atSeq) boundary = seq;
-		else break;
-		return boundary;
-	}
-	const firstAfter = ends.find((seq) => seq >= atSeq);
-	if (firstAfter !== void 0) return firstAfter;
-	const lastStart = [...events].reverse().find((event) => event.type === "turn/start");
-	if (lastStart !== void 0 && lastStart.seq <= atSeq) throw new SessionBranchError(`anchor ${atSeq} lies inside an open turn`, "OPEN_TURN");
-	const last = ends.at(-1);
-	if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
-	return last;
-}
-function renumber(events, offset) {
-	return events.map((event, index) => ({
-		...event,
-		seq: offset + index
-	}));
-}
-function mintSessionId() {
-	return `session-${randomUUID()}`;
-}
-function truncateLiveSession(session, newLength) {
-	const s = session;
-	s.log.length = newLength;
-	s.eventsSnapshot = void 0;
-	s.headerFold = void 0;
-	s.headerFoldSeq = 0;
-	s.contextFold = void 0;
-	s.contextFoldSeq = 0;
-	s.derived = [];
-	s.derivedNodes = 0;
-	s.derivedGeneration = 0;
-	s.surfaceManager._state = {
-		nodes: [],
-		replaceGeneration: 0
-	};
-	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
-	s.surfaceManager._pendingPlan = void 0;
-}
-function replaceLiveSessionLog(session, events) {
-	const s = session;
-	s.log.length = 0;
-	s.log.push(...events);
-	s.eventsSnapshot = void 0;
-	s.headerFold = void 0;
-	s.headerFoldSeq = 0;
-	s.contextFold = void 0;
-	s.contextFoldSeq = 0;
-	s.derived = [];
-	s.derivedNodes = 0;
-	s.derivedGeneration = 0;
-	s.surfaceManager._state = {
-		nodes: [],
-		replaceGeneration: 0
-	};
-	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
-	s.surfaceManager._pendingPlan = void 0;
-}
-var SessionBranchRdbProvider = class {
-	persistence;
-	live;
-	name = "session-rdb";
-	constructor(persistence, live = {
-		getSession: () => void 0,
-		getAgent: () => void 0,
-		flush: async () => true
-	}) {
-		this.persistence = persistence;
-		this.live = live;
-	}
-	async readBranchPrefix(id, atSeq, mode = "after", signal) {
-		const { events } = await this.readRawEvents(id, signal);
-		const boundary = locateTurnEnd(events, atSeq, mode);
-		return {
-			seq: boundary,
-			events: events.slice(0, boundary + 1)
-		};
-	}
-	async readRawEvents(id, signal) {
-		const stored = await this.persistence.readLog(id, {}, signal);
-		if (stored === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		return {
-			meta: stored.meta,
-			events: stored.events
-		};
-	}
-	async forkFrom(sourceId, options = {}, signal) {
-		signal?.throwIfAborted();
-		const { atSeq, anchorMode = "after", seedSuffix = [], childSessionId, meta = {} } = options;
-		const source = await this.persistence.readLog(sourceId, {}, signal);
-		if (source === void 0) throw new SessionBranchError(`session "${sourceId}" not found`, "SESSION_NOT_FOUND");
-		const boundary = locateTurnEnd(source.events, atSeq, anchorMode);
-		const prefix = source.events.slice(0, boundary + 1);
-		const childId = childSessionId ?? mintSessionId();
-		const childMeta = {
-			version: SESSION_FORMAT_VERSION,
-			id: childId,
-			createdAt: meta.createdAt ?? Date.now(),
-			...meta.cwd !== void 0 ? { cwd: meta.cwd } : source.meta.cwd !== void 0 ? { cwd: source.meta.cwd } : {},
-			parentSession: sourceId,
-			isSeeded: true,
-			...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : source.meta.agentPreset !== void 0 ? { agentPreset: source.meta.agentPreset } : {},
-			...meta.origin !== void 0 ? { origin: meta.origin } : {},
-			...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {}
-		};
-		const seed = [...renumber(prefix, 0), ...renumber(seedSuffix, prefix.length)];
-		const internals = this.persistence.internals();
-		const sourceRows = await internals.backend.getEventRows(sourceId);
-		const sourceEventIds = new Map(sourceRows.map((row) => [row.fSequence, row.fEventId]));
-		const reuse = /* @__PURE__ */ new Map();
-		for (const event of prefix) {
-			const eventId = sourceEventIds.get(event.seq);
-			if (eventId !== void 0) reuse.set(event.seq, eventId);
-		}
-		internals.registerReuseEventIds(childId, reuse);
-		const handle = await this.persistence.create(childMeta, { inheritedEventCount: SessionLogOffset(prefix.length) });
-		try {
-			if (seed.length > 0) await handle.append(seed);
-		} finally {
-			await handle.close();
-		}
-		return childId;
-	}
-	async rewind(id, toBoundary, signal) {
-		signal?.throwIfAborted();
-		if (!Number.isSafeInteger(toBoundary) || toBoundary < -1) throw new SessionBranchError(`rewind boundary must be a non-negative safe integer, got ${toBoundary}`, "INVALID_BOUNDARY");
-		const live = this.live.getSession(id);
-		if (live !== void 0) await this.live.flush(live);
-		const raw = live === void 0 ? await this.persistence.readLog(id, {}, signal) : void 0;
-		if (live === void 0 && raw === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		const inspection = live === void 0 ? void 0 : await this.persistence.internals().inspect(id, signal);
-		const events = live === void 0 ? raw.events : inspection.events;
-		const meta = live === void 0 ? raw.meta : inspection.meta;
-		const boundaryEvent = events[toBoundary];
-		if (toBoundary === -1) {} else if (boundaryEvent === void 0) throw new SessionBranchError(`rewind boundary ${toBoundary} does not exist in session "${id}"`, "INVALID_BOUNDARY");
-		else if (boundaryEvent.type !== "turn/end" && boundaryEvent.type !== "user/message") throw new SessionBranchError(`rewind boundary ${toBoundary} is not a turn/end or user/message (${boundaryEvent.type})`, "INVALID_BOUNDARY");
-		const rawKeepLength = toBoundary === -1 ? 0 : boundaryEvent.type === "turn/end" ? toBoundary + 1 : toBoundary;
-		const kept = balanceRewindPrefix(events.slice(0, rawKeepLength));
-		const keepLength = kept.length;
-		const internals = this.persistence.internals();
-		const denseBoundary = keepLength - 1;
-		const newSeedLength = await internals.backend.transaction(async (tx) => {
-			signal?.throwIfAborted();
-			const head = await tx.getHead(id);
-			if (denseBoundary > head.fHeadSequence) throw new SessionBranchError(`rewind boundary ${toBoundary} is beyond the stored head ${head.fHeadSequence}`, "INVALID_BOUNDARY");
-			if (denseBoundary < head.fHeadSequence) {
-				await tx.deleteBridgeTail(id, denseBoundary + 1);
-				const prev = denseBoundary === -1 ? void 0 : await tx.getPrevBridge(id, denseBoundary);
-				if (prev === void 0) await tx.updateHead(id, "", -1);
-				else await tx.updateHead(id, prev.fEventId, prev.fSequence);
-			}
-			const storedSeedLength = await tx.getSeedLength(id);
-			let shrunk = storedSeedLength;
-			if (storedSeedLength !== null && storedSeedLength > denseBoundary + 1) {
-				await tx.updateSeedLength(id, denseBoundary + 1);
-				shrunk = denseBoundary + 1;
-			}
-			await tx.refreshTitle(id);
-			await tx.bumpRevision(id);
-			return shrunk;
-		});
-		internals.writeGuard.confirmHead(id, denseBoundary);
-		if (live !== void 0) {
-			truncateLiveSession(live, keepLength);
-			this.live.resetProjections?.(live);
-			const agent = this.live.getAgent(id);
-			if (agent !== void 0) {
-				agent.requestHeaderLogged = false;
-				const lastTurn = live.snapshotEvents().findLast((e) => e.type === "turn/start")?.data.turn ?? 0;
-				const phase = agent.phase;
-				if (phase !== void 0) phase.lastTurn = lastTurn;
-			}
-			const handle = this.persistence.tracker.writerOf(id);
-			if (handle !== void 0) handle.resetAfterRewind(keepLength, newSeedLength === null ? void 0 : newSeedLength);
-			agent?.inbox?.clear();
-			await this.live.flush(live);
-			await this.refreshProjectionCache(live);
-		} else await this.refreshProjectionCache({
-			id,
-			header: meta,
-			inheritedEventCount: SessionLogOffset(raw.inheritedEventCount),
-			snapshotEvents: () => kept
-		});
-		const row = await internals.backend.getSession(id);
-		if (row === void 0) return {
-			header: {
-				version: SESSION_FORMAT_VERSION,
-				id,
-				createdAt: meta.createdAt,
-				...meta.cwd !== void 0 ? { cwd: meta.cwd } : {},
-				...meta.parentSession !== void 0 ? { parentSession: meta.parentSession } : {},
-				isSeeded: meta.isSeeded,
-				...meta.origin !== void 0 ? { origin: meta.origin } : {},
-				...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {},
-				...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : {}
-			},
-			revision: await internals.readStoredRevision(id) ?? await this.persistence.readStoredRevision(id)
-		};
-		return {
-			header: rowToMeta(row),
-			revision: await internals.readStoredRevision(id)
-		};
-	}
-	/**
-	* 让持久化投影检查点跟随截断后的 log（见 {@link LiveSessionHooks.refreshProjectionCache}）。
-	* 缓存是派生数据：刷新失败只让缓存多滞后一轮，不能让 rewind 失败。
-	*/
-	async refreshProjectionCache(session) {
-		if (this.live.refreshProjectionCache === void 0) return;
-		try {
-			await this.live.refreshProjectionCache(session);
-		} catch {}
-	}
-};
-var SessionBranchRdb = class extends SessionBranch {
-	static inject = ["sessionPersistence", "sessions"];
-	constructor(ctx) {
-		super(ctx);
-	}
-	provider = new SessionBranchRdbProvider(this.ctx.sessionPersistence, {
-		getSession: (id) => this.ctx.sessions.get(id),
-		getAgent: (id) => {
-			return this.ctx.get("agents")?.get(id);
-		},
-		flush: (session) => this.ctx.sessions.flush(session),
-		resetProjections: (session) => {
-			const registry = this.ctx.get("sessionProjections");
-			if (registry?.registrations === void 0) return;
-			for (const registration of registry.registrations.values()) registration.cells.delete(session);
-		},
-		refreshProjectionCache: async (session) => {
-			const cache = this.ctx.get("sessionProjectionCache");
-			if (cache === void 0) return;
-			try {
-				await cache.write(session);
-			} catch (error) {
-				this.ctx.logger.warn(`session-rdb: projection cache refresh after rewind for "${session.id}" failed (cache stays stale): ${String(error)}`);
-			}
-		}
-	});
-	readBranchPrefix(id, atSeq, mode, signal) {
-		return this.provider.readBranchPrefix(id, atSeq, mode, signal);
-	}
-	readRawEvents(id, signal) {
-		return this.provider.readRawEvents(id, signal);
-	}
-	forkFrom(sourceId, options, signal) {
-		return this.provider.forkFrom(sourceId, options, signal);
-	}
-	rewind(id, toBoundary, signal) {
-		return this.provider.rewind(id, toBoundary, signal);
-	}
-	async timeline(sessionId, signal) {
-		const persistence = this.ctx.sessionPersistence;
-		const snapshots = await persistence.listSnapshots(signal);
-		const readOwnEvents = async (id, fromSeq, s) => {
-			const live = this.ctx.sessions.get(id);
-			if (live !== void 0) return live.snapshotEvents().slice(fromSeq);
-			return (await persistence.internals().readFrom(id, fromSeq, s)).events;
-		};
-		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
-	}
-};
-//#endregion
-//#region src/import.ts
-/** 当前世代产物的文件名（读入侧接受任意 canonical 世代名，见 parseImportZip）。 */
-const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
-const SESSION_IMPORT_PATH = "/api/session.import";
-const MAX_IMPORT_ZIP_BYTES = 67108864;
-function parseJsonlArtifact(content) {
-	const lines = content.split("\n");
-	if (lines.length === 0 || lines[0] === "") throw new Error("imported session log is empty");
-	let header;
-	try {
-		header = JSON.parse(lines[0]);
-	} catch {
-		throw new Error("imported session log has an unparsable header line");
-	}
-	let restore;
-	try {
-		restore = sessionFormatCatalog.createRestore(header, {
-			recovery: "strict",
-			validation: "transformed"
-		});
-	} catch (error) {
-		throw new Error(`imported session log has an invalid header line: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	for (let i = 1; i < lines.length; i++) {
-		const line = lines[i];
-		if (line === void 0 || line === "") continue;
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			throw new Error(`imported session log has an unparsable event line at ${i}`);
-		}
-		try {
-			restore.decodeRow(parsed);
-		} catch (error) {
-			throw new Error(`imported session log has an invalid event line at ${i}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	let artifact;
-	try {
-		artifact = restore.finish();
-	} catch (error) {
-		throw new Error(`imported session log is incomplete: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const meta = artifact.header;
-	const events = artifact.events;
-	for (let i = 0; i < events.length; i++) if (events[i].seq !== i) throw new Error(`imported session log seq gap at ${i} (got ${events[i].seq}); import requires a dense log`);
-	const inheritedEventCount = Math.min(artifact.inheritedEventCount, events.length);
-	return {
-		meta: {
-			version: SESSION_FORMAT_VERSION,
-			id: meta.id,
-			createdAt: meta.createdAt,
-			...meta.cwd === void 0 ? {} : { cwd: meta.cwd },
-			...meta.parentSession === void 0 ? {} : { parentSession: meta.parentSession },
-			isSeeded: meta.isSeeded,
-			...meta.origin === void 0 ? {} : { origin: meta.origin },
-			...meta.delegationDepth === void 0 ? {} : { delegationDepth: meta.delegationDepth },
-			...meta.agentPreset === void 0 ? {} : { agentPreset: meta.agentPreset }
-		},
-		inheritedEventCount: SessionLogOffset(inheritedEventCount),
-		events
-	};
-}
-function parseImportZip(zip) {
-	let entries;
-	try {
-		entries = unzipSync(zip);
-	} catch {
-		throw new Error("imported zip is not a valid ZIP archive");
-	}
-	const artifact = Object.entries(entries).find(([name]) => parseSessionFormatLogFilename(name) !== void 0);
-	if (artifact === void 0) throw new Error(`imported zip has no session log artifact (expected ${SESSION_LOG_ARTIFACT_FILENAME} or a canonical session.vN.jsonl)`);
-	return parseJsonlArtifact(new TextDecoder().decode(artifact[1]));
-}
-async function stopAgentLoop(ctx, sessionId) {
-	const agent = ctx.get("agents")?.get(sessionId);
-	if (agent === void 0) return;
-	agent.cancel?.({ kind: "user" }, { keepInbox: true });
-	await agent.whenIdle();
-}
-async function persistImport(persistence, branch, imported, targetId, sessions, stopLoop) {
-	const id = targetId ?? `session-${randomUUID()}`;
-	if (targetId !== void 0) {
-		if (branch === void 0) throw new Error("sessionBranch service is unavailable");
-		if (stopLoop !== void 0) await stopLoop(targetId);
-		await branch.rewind(targetId, -1);
-		const liveHandle = persistence.tracker.writerOf(targetId);
-		if (liveHandle !== void 0) {
-			if (imported.events.length > 0) await liveHandle.append(imported.events);
-		} else {
-			const handle = await persistence.open(targetId, "write");
-			try {
-				if (imported.events.length > 0) await handle.append(imported.events);
-			} finally {
-				await handle.close();
-			}
-		}
-	} else {
-		const handle = await persistence.create({
-			...imported.meta,
-			id
-		}, { inheritedEventCount: imported.inheritedEventCount });
-		if (imported.events.length > 0) await handle.append(imported.events);
-		await handle.close();
-	}
-	if (targetId !== void 0) {
-		const live = sessions?.get(targetId);
-		if (live !== void 0) replaceLiveSessionLog(live, imported.events);
-	}
-	return id;
-}
-function registerSessionImport(ctx, persistence) {
-	ctx.inject(["webServer", "connection"], (webCtx) => {
-		const webServer = webCtx.webServer;
-		const connection = webCtx.get("connection");
-		return webCtx.effect(() => webServer.register({
-			kind: "exact",
-			path: SESSION_IMPORT_PATH,
-			handler: async (req, res) => {
-				const rejection = connection.requestRejection(req);
-				if (rejection !== void 0) {
-					res.writeHead(rejection);
-					res.end(rejection === 401 ? "unauthorized" : "forbidden");
-					return;
-				}
-				const chunks = [];
-				for await (const chunk of req) chunks.push(chunk);
-				const body = Buffer.concat(chunks);
-				let envelope;
-				try {
-					envelope = JSON.parse(body.toString("utf8"));
-				} catch {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "request body is not JSON" }));
-					return;
-				}
-				if (typeof envelope.zip !== "string" || envelope.zip === "") {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "missing zip field" }));
-					return;
-				}
-				if (envelope.sessionId !== void 0 && (typeof envelope.sessionId !== "string" || envelope.sessionId === "")) {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "sessionId must be a non-empty string" }));
-					return;
-				}
-				let zip;
-				try {
-					zip = Buffer.from(envelope.zip, "base64");
-				} catch {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "zip field is not valid base64" }));
-					return;
-				}
-				if (zip.byteLength > MAX_IMPORT_ZIP_BYTES) {
-					res.writeHead(413, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "imported zip exceeds the size limit" }));
-					return;
-				}
-				let imported;
-				try {
-					imported = parseImportZip(zip);
-				} catch (error) {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "imported zip is invalid" }));
-					return;
-				}
-				const targetId = typeof envelope.sessionId === "string" ? envelope.sessionId : void 0;
-				const branch = webCtx.get("sessionBranch");
-				try {
-					const sessions = webCtx.get("sessions");
-					const id = await persistImport(persistence, branch, imported, targetId, sessions, (sessionId) => stopAgentLoop(webCtx, sessionId));
-					res.writeHead(200, { "content-type": "application/json" });
-					res.end(JSON.stringify({ sessionId: id }));
-				} catch (error) {
-					const message = error instanceof Error ? error.message : String(error);
-					if (targetId !== void 0 && /not found/i.test(message)) {
-						res.writeHead(404, { "content-type": "application/json" });
-						res.end(JSON.stringify({ error: `session "${targetId}" not found` }));
-						return;
-					}
-					res.writeHead(500, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "import failed" }));
-					return;
-				}
-			}
-		}), `session-rdb: ${SESSION_IMPORT_PATH} route`);
-	});
-}
-//#endregion
-export { persistImport as a, SessionBranchRdbProvider as c, parseJsonlArtifact as i, locateTurnEnd as l, SESSION_LOG_ARTIFACT_FILENAME as n, registerSessionImport as o, parseImportZip as r, SessionBranchRdb as s, SESSION_IMPORT_PATH as t };