@morlay/session-rdb 0.1.9 → 0.1.10-alpha.2

package/dist/deletion-ODZFcbZm.mjs

@@ -1,2218 +0,0 @@
-import { a as SESSION_ROWS_PATH, t as SESSION_DELETE_PATH } from "./routes-DGBlBE_I.mjs";
-import { COUNTED_EVENT_TYPES, addActivityCount, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey, registerSessionUsage } from "./usage.mjs";
-import { S as usageRowOf, _ as sessionConflictRow, b as titleOfEventData, g as sealOwnEvents, h as scanRows, m as rowToMeta, r as needsShapeAdoption, u as repairReadView, v as sessionInsertRow, x as toJsonlArtifact } from "./log-DYxdjJ-l.mjs";
-import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-DbFW3rJX.mjs";
-import { registerSessionImport } from "./import.mjs";
-import { E as WriteGuard, T as toPostgresSchema, a as EVENT_ENCODING, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, r as createStorageRepository, t as SqliteBackend, w as postgresTableDefs } from "./sqlite-DjOnMRh2.mjs";
-import { registerSessionExport } from "./export.mjs";
-import { registerSessionGc } from "./gc.mjs";
-import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { randomUUID } from "node:crypto";
-import { sessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
-import { balanceRewindPrefix } from "@morlay/session-branch";
-import z from "@deepseek-ai/schemastery";
-import { Pool } from "pg";
-import { drizzle } from "drizzle-orm/node-postgres";
-import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionHandleClosedError, SessionPersistence, SessionPersistenceNotFoundError, SessionPersistenceRevision, SessionReadOnlyError, assertContiguous, assertVersion, materializeAppendBatch, materializeCreateHeader, validateStoredEvents } from "@deepseek-ai/dsh-session-persistence";
-import { and, desc, eq, gte, inArray, lt, notInArray, sql } from "drizzle-orm";
-import { readdir } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import { migrate } from "drizzle-orm/node-postgres/migrator";
-import { SessionQueryEngine, SessionQueryError } from "@deepseek-ai/dsh-session-query";
-import { StorageError, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
-import { Service } from "@deepseek-ai/cordis";
-//#region src/postgres.ts
-const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
-const pgWriteQueues = /* @__PURE__ */ new Map();
-const REFRESH_FLAG_CHUNK = 400;
-function enqueuePgWrite(key, fn) {
-	const run = (pgWriteQueues.get(key) ?? Promise.resolve()).then(fn);
-	pgWriteQueues.set(key, run.then(() => void 0, () => void 0));
-	return run;
-}
-function text(value) {
-	return typeof value === "string" ? value : null;
-}
-function numeric(value) {
-	const parsed = typeof value === "number" ? value : Number(value ?? 0);
-	return Number.isFinite(parsed) ? parsed : 0;
-}
-function tokenTotalsOf(row) {
-	return {
-		inputTokens: numeric(row["input_tokens"]),
-		outputTokens: numeric(row["output_tokens"]),
-		cacheReadTokens: numeric(row["cache_read_tokens"]),
-		reasoningTokens: numeric(row["reasoning_tokens"]),
-		totalTokens: numeric(row["total_tokens"])
-	};
-}
-function emptyActivity() {
-	return {
-		turns: 0,
-		steps: 0,
-		userInputs: 0,
-		toolCalls: 0
-	};
-}
-function activityTotalsOf(row) {
-	return {
-		turns: numeric(row["turns"]),
-		steps: numeric(row["steps"]),
-		userInputs: numeric(row["user_inputs"]),
-		toolCalls: numeric(row["tool_calls"])
-	};
-}
-const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
-var PostgresBackend = class PostgresBackend {
-	db;
-	options;
-	kind = "postgres";
-	storeIdentity;
-	tables;
-	storage;
-	opened;
-	resolveOpened;
-	rejectOpened;
-	txOverride;
-	constructor(db, options) {
-		this.db = db;
-		this.options = options;
-		this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
-		this.opened = new Promise((resolve, reject) => {
-			this.resolveOpened = resolve;
-			this.rejectOpened = reject;
-		});
-		this.opened.catch(() => {});
-		const writeQueueKey = options.identityBase;
-		this.storage = createStorageRepository({
-			db: () => this.opened.then(() => this.txOverride ?? this.db),
-			writeAtomically: (fn) => enqueuePgWrite(writeQueueKey, () => this.db.transaction(async (tx) => {
-				const previous = this.txOverride;
-				this.txOverride = tx;
-				try {
-					return await fn();
-				} finally {
-					this.txOverride = previous;
-				}
-			}, { isolationLevel: "serializable" })),
-			tables: this.tables
-		});
-	}
-	async open() {
-		try {
-			await this.doOpen();
-			this.resolveOpened();
-		} catch (error) {
-			this.rejectOpened(error);
-			throw error;
-		}
-	}
-	async doOpen() {
-		const schema = this.options.schema ?? "public";
-		const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
-		if ((await this.db.execute(sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`)).rows[0]?.exists === true) {
-			if (await this.readMeta(this.db, "schema_version") === "2") await this.baselineV2();
-		}
-		await migrate(this.db, { migrationsFolder: postgresMigrationsDir });
-		await this.backfillUsageTables();
-		const storeId = await this.db.transaction(async (tx) => {
-			await tx.insert(this.tables["t_persistence_state"]).values({
-				fSingleton: 1,
-				fStoreId: randomUUID()
-			}).onConflictDoNothing().execute();
-			const id = (await tx.select({ fStoreId: this.tables["t_persistence_state"].fStoreId }).from(this.tables["t_persistence_state"]).where(eq(this.tables["t_persistence_state"].fSingleton, 1)).execute())[0]?.fStoreId;
-			if (id === void 0 || id.length === 0) throw new Error("session database has no valid store identity");
-			return id;
-		});
-		this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
-	}
-	async baselineV2() {
-		const dir = (await readdir(postgresMigrationsDir)).find((name) => name.endsWith("_v2_initial"));
-		if (dir === void 0) throw new Error("missing v2 baseline migration in drizzle/postgres");
-		await this.db.execute(sql`
-      CREATE SCHEMA IF NOT EXISTS drizzle
-    `);
-		await this.db.execute(sql`
-      CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
-        id SERIAL PRIMARY KEY,
-        hash text NOT NULL,
-        created_at bigint,
-        name text,
-        applied_at timestamp with time zone DEFAULT now()
-      )
-    `);
-		await this.db.execute(sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at, name) VALUES ('baseline', 0, ${dir})`);
-	}
-	async close() {
-		await this.options.close();
-	}
-	async getSession(id) {
-		return (await this.db.select().from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
-	}
-	async getEventRows(id, fromSequence) {
-		return (fromSequence === void 0 ? this.eventRows(this.db).where(eq(this.tables["t_session_events"].fSessionId, id)) : this.eventRows(this.db).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence)))).orderBy(this.tables["t_session_events"].fSequence).execute();
-	}
-	async getEventTypeAt(id, sequence) {
-		const table = this.tables["t_session_events"];
-		return (await this.db.select({ fType: this.tables["t_events"].fType }).from(table).innerJoin(this.tables["t_events"], eq(table.fEventId, this.tables["t_events"].fEventId)).where(and(eq(table.fSessionId, id), eq(table.fSequence, sequence))).limit(1).execute())[0]?.fType;
-	}
-	async getEventTypesBefore(id, beforeSequence, limit) {
-		const table = this.tables["t_session_events"];
-		return await this.db.select({
-			fSequence: table.fSequence,
-			fType: this.tables["t_events"].fType
-		}).from(table).innerJoin(this.tables["t_events"], eq(table.fEventId, this.tables["t_events"].fEventId)).where(and(eq(table.fSessionId, id), lt(table.fSequence, beforeSequence))).orderBy(desc(table.fSequence)).limit(limit).execute();
-	}
-	async listSessions() {
-		return this.db.select().from(this.tables["t_sessions"]).execute();
-	}
-	async transaction(fn) {
-		return this.db.transaction(async (tx) => fn(this.txFor(tx)));
-	}
-	txFor(tx) {
-		return {
-			upsertSession: (storage, incarnation) => this.upsertSession(tx, storage, incarnation),
-			getHead: (id) => this.getHead(tx, id),
-			getSeedLength: (id) => this.getSeedLength(tx, id),
-			updateSeedLength: (id, seedLength) => this.updateSeedLength(tx, id, seedLength),
-			insertEvents: (events, usageRows) => this.insertEvents(tx, events, usageRows),
-			insertBridges: (rows) => this.insertBridges(tx, rows),
-			updateHead: (id, headEventId, headSequence) => this.updateHead(tx, id, headEventId, headSequence),
-			bumpRevision: (id, lastEventAt) => this.bumpRevision(tx, id, lastEventAt),
-			refreshTitle: (id) => this.refreshTitle(tx, id),
-			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
-			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
-			deleteSession: (id) => this.deleteSession(tx, id),
-			deleteSessions: (ids) => this.deleteSessions(tx, ids)
-		};
-	}
-	async readMeta(exec, key) {
-		return (await exec.select({ fValue: this.tables["t_schema_meta"].fValue }).from(this.tables["t_schema_meta"]).where(eq(this.tables["t_schema_meta"].fKey, key)).execute())[0]?.fValue;
-	}
-	async upsertSession(exec, storage, incarnation) {
-		await exec.insert(this.tables["t_sessions"]).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
-			target: this.tables["t_sessions"].fSessionId,
-			set: sessionConflictRow(storage)
-		}).execute();
-	}
-	async getHead(exec, id) {
-		const head = (await exec.select({
-			fHeadEventId: this.tables["t_sessions"].fHeadEventId,
-			fHeadSequence: this.tables["t_sessions"].fHeadSequence
-		}).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
-		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
-		return head;
-	}
-	async getSeedLength(exec, id) {
-		const row = (await exec.select({ fSeedLength: this.tables["t_sessions"].fSeedLength }).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
-		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
-		return row.fSeedLength;
-	}
-	async updateSeedLength(exec, id, seedLength) {
-		await exec.update(this.tables["t_sessions"]).set({ fSeedLength: seedLength }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	static INSERT_BATCH_ROWS = 1e3;
-	async insertEvents(exec, events, usageRows) {
-		if (events.length === 0) return;
-		for (let i = 0; i < events.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_events"]).values(events.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).execute();
-		if (usageRows.length > 0) for (let i = 0; i < usageRows.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_event_usage"]).values(usageRows.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).onConflictDoNothing().execute();
-	}
-	async insertBridges(exec, rows) {
-		if (rows.length === 0) return;
-		for (let i = 0; i < rows.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_session_events"]).values(rows.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).execute();
-	}
-	async updateHead(exec, id, headEventId, headSequence) {
-		await exec.update(this.tables["t_sessions"]).set({
-			fHeadEventId: headEventId,
-			fHeadSequence: headSequence
-		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	async bumpRevision(exec, id, lastEventAt) {
-		const sessions = this.tables["t_sessions"];
-		await exec.update(sessions).set({
-			fRevision: sql`${sessions.fRevision} + 1`,
-			...lastEventAt === void 0 ? {} : { fLastEventAt: sql`GREATEST(COALESCE(${sessions.fLastEventAt}, 0), ${lastEventAt})` }
-		}).where(eq(sessions.fSessionId, id)).execute();
-	}
-	async refreshTitle(exec, id) {
-		const bridges = this.tables["t_session_events"];
-		const entities = this.tables["t_events"];
-		const row = (await exec.select({
-			fSequence: bridges.fSequence,
-			fData: entities.fData
-		}).from(bridges).innerJoin(entities, eq(entities.fEventId, bridges.fEventId)).where(and(eq(bridges.fSessionId, id), eq(entities.fType, "session/title"))).orderBy(desc(bridges.fSequence)).limit(1).execute())[0];
-		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
-		await exec.update(this.tables["t_sessions"]).set({
-			fTitle: title ?? null,
-			fTitleSeq: title === void 0 ? null : row.fSequence
-		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-	}
-	async deleteBridgeTail(exec, id, fromSequence) {
-		const table = this.tables["t_session_events"];
-		return (await exec.execute(sql`
-      DELETE FROM ${table} WHERE f_session_id = ${id} AND f_sequence >= ${fromSequence}
-      RETURNING f_event_id
-    `)).rows.map((row) => row.f_event_id);
-	}
-	async deleteSession(exec, id) {
-		const result = await exec.execute(sql`
-      DELETE FROM ${this.tables["t_session_events"]} WHERE f_session_id = ${id} RETURNING f_event_id
-    `);
-		await exec.delete(this.tables["t_workspace_sessions"]).where(eq(this.tables["t_workspace_sessions"].fSessionId, id)).execute();
-		await exec.delete(this.tables["t_session_projcache_row"]).where(eq(this.tables["t_session_projcache_row"].fSessionId, id)).execute();
-		await exec.delete(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
-		return result.rows.map((row) => row.f_event_id);
-	}
-	async collectOrphans() {
-		const tEvents = this.tables["t_events"];
-		const tEventUsage = this.tables["t_event_usage"];
-		const tSessionEvents = this.tables["t_session_events"];
-		const result = await this.db.delete(tEvents).where(notInArray(tEvents.fEventId, this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents))).execute();
-		await this.db.delete(tEventUsage).where(notInArray(tEventUsage.fEventId, this.db.select({ fEventId: tEvents.fEventId }).from(tEvents))).execute();
-		return result.rowCount ?? 0;
-	}
-	async listOrphanSubagentSessions() {
-		const tSessions = this.tables["t_sessions"];
-		return (await this.db.execute(sql`
-      SELECT s.f_session_id AS id FROM ${tSessions} AS s
-      WHERE s.f_origin = 'subagent'
-        AND (s.f_parent_session IS NULL
-             OR s.f_parent_session NOT IN (SELECT p.f_session_id FROM ${tSessions} AS p))
-    `)).rows.map((row) => row.id);
-	}
-	async deleteSessions(exec, ids) {
-		if (ids.length === 0) return {
-			deleted: 0,
-			eventIds: []
-		};
-		const removed = await exec.execute(sql`
-      DELETE FROM ${this.tables["t_session_events"]}
-       WHERE f_session_id IN (${sql.join(ids.map((id) => sql`${id}`), sql`, `)})
-      RETURNING f_event_id
-    `);
-		await exec.delete(this.tables["t_workspace_sessions"]).where(inArray(this.tables["t_workspace_sessions"].fSessionId, ids)).execute();
-		await exec.delete(this.tables["t_session_projcache_row"]).where(inArray(this.tables["t_session_projcache_row"].fSessionId, ids)).execute();
-		const result = await exec.delete(this.tables["t_sessions"]).where(inArray(this.tables["t_sessions"].fSessionId, ids)).execute();
-		return {
-			deleted: Number(result.rowCount ?? 0),
-			eventIds: removed.rows.map((row) => row.f_event_id)
-		};
-	}
-	async vacuum() {
-		await this.db.execute(sql`VACUUM ANALYZE`);
-	}
-	async backfillUsageTables() {
-		await this.backfillEventUsage();
-		await this.backfillSessionUsage();
-		await this.backfillSessionCounts();
-	}
-	async tableIsEmpty(table) {
-		const existing = await this.db.execute(sql.raw(`SELECT count(*) AS n FROM ${table}`));
-		return Number(existing.rows[0]?.["n"] ?? 0) === 0;
-	}
-	async backfillEventUsage() {
-		if (!await this.tableIsEmpty(this.qualifiedTable("t_event_usage"))) return;
-		const tEventUsage = this.tables["t_event_usage"];
-		const tEvents = this.tables["t_events"];
-		const tSessionEvents = this.tables["t_session_events"];
-		const tSessions = this.tables["t_sessions"];
-		await this.db.execute(sql`
-      INSERT INTO ${tEventUsage} (
-        f_event_id, f_created_at, f_day, f_provider, f_model, f_referenced, f_subagent,
-        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-      SELECT e.f_event_id, e.f_created_at,
-             to_char(to_timestamp(e.f_created_at / 1000.0), 'YYYY-MM-DD'),
-             coalesce(e.f_data::json #>> '{data,message,source,provider}',
-                      e.f_data::json #>> '{message,source,provider}'),
-             coalesce(e.f_data::json #>> '{data,message,source,model}',
-                      e.f_data::json #>> '{message,source,model}'),
-             (EXISTS (SELECT 1 FROM ${tSessionEvents} rb
-                       WHERE rb.f_event_id = e.f_event_id))::int,
-             (EXISTS (SELECT 1 FROM ${tSessionEvents} sb
-                        JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
-                       WHERE sb.f_event_id = e.f_event_id AND ss.f_origin = 'subagent'))::int,
-             coalesce((e.f_data::json #>> '{data,usage,inputTokens}')::integer,
-                      (e.f_data::json #>> '{usage,inputTokens}')::integer, 0),
-             coalesce((e.f_data::json #>> '{data,usage,outputTokens}')::integer,
-                      (e.f_data::json #>> '{usage,outputTokens}')::integer, 0),
-             coalesce((e.f_data::json #>> '{data,usage,cacheReadTokens}')::integer,
-                      (e.f_data::json #>> '{usage,cacheReadTokens}')::integer, 0),
-             coalesce((e.f_data::json #>> '{data,usage,reasoningTokens}')::integer,
-                      (e.f_data::json #>> '{usage,reasoningTokens}')::integer, 0),
-             coalesce((e.f_data::json #>> '{data,usage,totalTokens}')::integer,
-                      (e.f_data::json #>> '{usage,totalTokens}')::integer, 0)
-        FROM ${tEvents} e
-       WHERE e.f_type = 'assistant/message'
-         AND (e.f_data::json #> '{data,usage}' IS NOT NULL
-              OR e.f_data::json #> '{usage}' IS NOT NULL)
-      ON CONFLICT DO NOTHING
-    `);
-	}
-	async backfillSessionUsage() {
-		if (!await this.tableIsEmpty(this.qualifiedTable("t_session_usage"))) return;
-		const tSessionUsage = this.tables["t_session_usage"];
-		const tSessionEvents = this.tables["t_session_events"];
-		const tEventUsage = this.tables["t_event_usage"];
-		await this.db.execute(sql`
-      INSERT INTO ${tSessionUsage} (
-        f_session_id, f_day, f_provider, f_model,
-        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-      SELECT b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, ''),
-             sum(u.f_input_tokens), sum(u.f_output_tokens), sum(u.f_cache_read_tokens),
-             sum(u.f_reasoning_tokens), sum(u.f_total_tokens)
-        FROM ${tSessionEvents} b
-        JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
-       GROUP BY 1, 2, 3, 4
-      ON CONFLICT DO NOTHING
-    `);
-	}
-	async backfillSessionCounts() {
-		if (!await this.tableIsEmpty(this.qualifiedTable("t_session_counts"))) return;
-		const tSessionCounts = this.tables["t_session_counts"];
-		const tSessionEvents = this.tables["t_session_events"];
-		const tEvents = this.tables["t_events"];
-		await this.db.execute(sql`
-      INSERT INTO ${tSessionCounts} (
-        f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
-      SELECT b.f_session_id,
-             to_char(to_timestamp(e.f_created_at / 1000.0), 'YYYY-MM-DD'),
-             sum(CASE WHEN e.f_type = 'turn/start' THEN 1 ELSE 0 END),
-             sum(CASE WHEN e.f_type = 'step/start' THEN 1 ELSE 0 END),
-             sum(CASE WHEN e.f_type = 'user/message' THEN 1 ELSE 0 END),
-             sum(CASE WHEN e.f_type = 'tool/call' THEN 1 ELSE 0 END)
-        FROM ${tSessionEvents} b
-        JOIN ${tEvents} e ON e.f_event_id = b.f_event_id
-       WHERE e.f_type IN (${sql.raw(COUNTED_EVENT_TYPE_SQL)})
-       GROUP BY 1, 2
-      ON CONFLICT DO NOTHING
-    `);
-	}
-	async listSessionRows(query = {}) {
-		const needle = query.query?.trim().toLowerCase() ?? "";
-		const like = `%${needle}%`;
-		const includeSubagents = query.includeSubagents === true;
-		const limit = query.limit ?? 20;
-		const offset = query.offset ?? 0;
-		const tSessions = this.tables["t_sessions"];
-		const tWorkspaces = this.tables["t_workspaces"];
-		const tWorkspaceSessions = this.tables["t_workspace_sessions"];
-		const workspaceTitle = sql`(SELECT w.f_title FROM ${tWorkspaceSessions} b
-                                     JOIN ${tWorkspaces} w ON w.f_workspace_id = b.f_workspace_id
-                                    WHERE b.f_session_id = s.f_session_id
-                                    ORDER BY b.f_position LIMIT 1)`;
-		const where = sql`WHERE (${needle} = ''
-                          OR lower(COALESCE(s.f_title, '')) LIKE ${like}
-                          OR lower(COALESCE(${workspaceTitle}, '')) LIKE ${like})
-                        AND (${includeSubagents} OR s.f_origin IS DISTINCT FROM 'subagent')`;
-		const rows = await this.db.execute(sql`
-      SELECT s.f_session_id AS session_id,
-             s.f_title AS title,
-             s.f_origin AS origin,
-             s.f_cwd AS cwd,
-             s.f_created_at AS created_at,
-             (s.f_archived_at IS NOT NULL) AS archived,
-             COALESCE(s.f_last_event_at, s.f_created_at) AS updated_at,
-             ${workspaceTitle} AS workspace
-        FROM ${tSessions} s
-        ${where}
-       ORDER BY updated_at DESC, s.f_session_id
-       LIMIT ${limit} OFFSET ${offset}
-    `);
-		const counted = await this.db.execute(sql`
-      SELECT count(*) AS n FROM ${tSessions} s ${where}
-    `);
-		return {
-			items: rows.rows.map((row) => ({
-				sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
-				title: typeof row["title"] === "string" ? row["title"] : null,
-				origin: typeof row["origin"] === "string" ? row["origin"] : null,
-				cwd: typeof row["cwd"] === "string" ? row["cwd"] : null,
-				createdAt: numeric(row["created_at"]),
-				updatedAt: numeric(row["updated_at"]),
-				archived: row["archived"] === true,
-				subagent: row["origin"] === "subagent",
-				workspace: typeof row["workspace"] === "string" ? row["workspace"] : null
-			})),
-			total: numeric(counted.rows[0]?.["n"] ?? 0)
-		};
-	}
-	async usageReport(sinceMs) {
-		const usageSince = sinceMs === void 0 ? sql`` : sql` AND f_created_at >= ${sinceMs}`;
-		const dayFilter = (column) => sinceMs === void 0 ? sql`` : sql` AND ${sql.raw(column)} >= ${localDayKey(sinceMs)}`;
-		const tEventUsage = this.tables["t_event_usage"];
-		const tSessionUsage = this.tables["t_session_usage"];
-		const tSessionCounts = this.tables["t_session_counts"];
-		const tSessions = this.tables["t_sessions"];
-		const tokenColumns = (alias) => sql.raw(`sum(${alias}.f_input_tokens) AS input_tokens,
-                sum(${alias}.f_output_tokens) AS output_tokens,
-                sum(${alias}.f_cache_read_tokens) AS cache_read_tokens,
-                sum(${alias}.f_reasoning_tokens) AS reasoning_tokens,
-                sum(${alias}.f_total_tokens) AS total_tokens`);
-		const buckets = await this.db.execute(sql`
-      SELECT a.f_day AS day,
-             a.f_provider AS provider,
-             a.f_model AS model,
-             (a.f_subagent = 1) AS subagent,
-             ${tokenColumns("a")}
-        FROM ${tEventUsage} a
-       WHERE a.f_referenced = 1${usageSince}
-       GROUP BY 1, 2, 3, 4
-    `);
-		const tokenScope = await this.db.execute(sql`
-      SELECT (a.f_subagent = 1) AS subagent,
-             ${tokenColumns("a")}
-        FROM ${tEventUsage} a
-       WHERE a.f_referenced = 1${usageSince}
-       GROUP BY 1
-    `);
-		const activityScope = await this.db.execute(sql`
-      SELECT (s.f_origin = 'subagent') AS subagent,
-             sum(c.f_turns) AS turns,
-             sum(c.f_steps) AS steps,
-             sum(c.f_user_inputs) AS user_inputs,
-             sum(c.f_tool_calls) AS tool_calls
-        FROM ${tSessionCounts} c
-        JOIN ${tSessions} s ON s.f_session_id = c.f_session_id
-       WHERE EXISTS (SELECT 1 FROM ${tSessionUsage} ub WHERE ub.f_session_id = c.f_session_id)${dayFilter("c.f_day")}
-       GROUP BY 1
-    `);
-		const tokenSessions = await this.db.execute(sql`
-      SELECT u.f_session_id AS session_id,
-             s.f_title AS title,
-             (s.f_origin = 'subagent') AS subagent,
-             (s.f_archived_at IS NOT NULL) AS archived,
-             ${tokenColumns("u")}
-        FROM ${tSessionUsage} u
-        JOIN ${tSessions} s ON s.f_session_id = u.f_session_id
-       WHERE 1 = 1${dayFilter("u.f_day")}
-       GROUP BY u.f_session_id, s.f_title, s.f_origin, s.f_archived_at
-    `);
-		const activitySessions = await this.db.execute(sql`
-      SELECT c.f_session_id AS session_id,
-             sum(c.f_turns) AS turns,
-             sum(c.f_steps) AS steps,
-             sum(c.f_user_inputs) AS user_inputs,
-             sum(c.f_tool_calls) AS tool_calls
-        FROM ${tSessionCounts} c
-       WHERE 1 = 1${dayFilter("c.f_day")}
-       GROUP BY c.f_session_id
-    `);
-		const human = emptyTotals();
-		const subagent = emptyTotals();
-		for (const row of tokenScope.rows) addTokenTotals(row["subagent"] === true ? subagent : human, tokenTotalsOf(row));
-		for (const row of activityScope.rows) addActivityTotals(row["subagent"] === true ? subagent : human, activityTotalsOf(row));
-		const totals = addTotals(addTotals(emptyTotals(), human), subagent);
-		const activityBySession = /* @__PURE__ */ new Map();
-		for (const row of activitySessions.rows) activityBySession.set(String(row["session_id"]), activityTotalsOf(row));
-		return {
-			totals,
-			subagent,
-			human,
-			buckets: buckets.rows.map((row) => ({
-				day: String(row["day"]),
-				provider: text(row["provider"]),
-				model: text(row["model"]),
-				subagent: row["subagent"] === true,
-				...tokenTotalsOf(row)
-			})),
-			sessions: tokenSessions.rows.map((row) => ({
-				sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
-				title: text(row["title"]),
-				subagent: row["subagent"] === true,
-				archived: row["archived"] === true,
-				...tokenTotalsOf(row),
-				...activityBySession.get(String(row["session_id"])) ?? emptyActivity()
-			}))
-		};
-	}
-	qualifiedTable(name) {
-		const schema = this.options.schema ?? "public";
-		return schema === "public" ? name : `"${schema}".${name}`;
-	}
-	async incrementSessionUsage(id, buckets) {
-		if (buckets.length === 0) return;
-		const tSessionUsage = this.tables["t_session_usage"];
-		for (const bucket of buckets) await this.db.execute(sql`
-        INSERT INTO ${tSessionUsage} (
-          f_session_id, f_day, f_provider, f_model,
-          f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-        VALUES (${id}, ${bucket.day}, ${bucket.provider ?? ""}, ${bucket.model ?? ""},
-                ${bucket.inputTokens}, ${bucket.outputTokens}, ${bucket.cacheReadTokens},
-                ${bucket.reasoningTokens}, ${bucket.totalTokens})
-        ON CONFLICT (f_session_id, f_day, f_provider, f_model) DO UPDATE SET
-          f_input_tokens = ${tSessionUsage}.f_input_tokens + EXCLUDED.f_input_tokens,
-          f_output_tokens = ${tSessionUsage}.f_output_tokens + EXCLUDED.f_output_tokens,
-          f_cache_read_tokens = ${tSessionUsage}.f_cache_read_tokens + EXCLUDED.f_cache_read_tokens,
-          f_reasoning_tokens = ${tSessionUsage}.f_reasoning_tokens + EXCLUDED.f_reasoning_tokens,
-          f_total_tokens = ${tSessionUsage}.f_total_tokens + EXCLUDED.f_total_tokens
-      `);
-	}
-	async incrementSessionCounts(id, buckets) {
-		if (buckets.length === 0) return;
-		const tSessionCounts = this.tables["t_session_counts"];
-		for (const bucket of buckets) await this.db.execute(sql`
-        INSERT INTO ${tSessionCounts} (
-          f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
-        VALUES (${id}, ${bucket.day}, ${bucket.turns}, ${bucket.steps},
-                ${bucket.userInputs}, ${bucket.toolCalls})
-        ON CONFLICT (f_session_id, f_day) DO UPDATE SET
-          f_turns = ${tSessionCounts}.f_turns + EXCLUDED.f_turns,
-          f_steps = ${tSessionCounts}.f_steps + EXCLUDED.f_steps,
-          f_user_inputs = ${tSessionCounts}.f_user_inputs + EXCLUDED.f_user_inputs,
-          f_tool_calls = ${tSessionCounts}.f_tool_calls + EXCLUDED.f_tool_calls
-      `);
-	}
-	async rebuildSessionStats(id) {
-		const tSessionUsage = this.tables["t_session_usage"];
-		const tSessionCounts = this.tables["t_session_counts"];
-		const tSessionEvents = this.tables["t_session_events"];
-		const tEventUsage = this.tables["t_event_usage"];
-		const tEvents = this.tables["t_events"];
-		await this.db.execute(sql`DELETE FROM ${tSessionUsage} WHERE f_session_id = ${id}`);
-		await this.db.execute(sql`
-      INSERT INTO ${tSessionUsage} (
-        f_session_id, f_day, f_provider, f_model,
-        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-      SELECT b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, ''),
-             sum(u.f_input_tokens), sum(u.f_output_tokens), sum(u.f_cache_read_tokens),
-             sum(u.f_reasoning_tokens), sum(u.f_total_tokens)
-        FROM ${tSessionEvents} b
-        JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
-       WHERE b.f_session_id = ${id}
-       GROUP BY 1, 2, 3, 4
-    `);
-		await this.db.execute(sql`DELETE FROM ${tSessionCounts} WHERE f_session_id = ${id}`);
-		await this.db.execute(sql`
-      INSERT INTO ${tSessionCounts} (
-        f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
-      SELECT b.f_session_id,
-             to_char(to_timestamp(e.f_created_at / 1000.0), 'YYYY-MM-DD'),
-             sum(CASE WHEN e.f_type = 'turn/start' THEN 1 ELSE 0 END),
-             sum(CASE WHEN e.f_type = 'step/start' THEN 1 ELSE 0 END),
-             sum(CASE WHEN e.f_type = 'user/message' THEN 1 ELSE 0 END),
-             sum(CASE WHEN e.f_type = 'tool/call' THEN 1 ELSE 0 END)
-        FROM ${tSessionEvents} b
-        JOIN ${tEvents} e ON e.f_event_id = b.f_event_id
-       WHERE b.f_session_id = ${id} AND e.f_type IN (${sql.raw(COUNTED_EVENT_TYPE_SQL)})
-       GROUP BY 1, 2
-    `);
-	}
-	async refreshEventUsageFlags(eventIds) {
-		const tEventUsage = this.tables["t_event_usage"];
-		const tSessionEvents = this.tables["t_session_events"];
-		const tSessions = this.tables["t_sessions"];
-		for (let at = 0; at < eventIds.length; at += REFRESH_FLAG_CHUNK) {
-			const chunk = eventIds.slice(at, at + REFRESH_FLAG_CHUNK);
-			await this.db.execute(sql`
-        UPDATE ${tEventUsage} SET
-          f_referenced = (EXISTS (SELECT 1 FROM ${tSessionEvents} rb
-                                   WHERE rb.f_event_id = ${tEventUsage}.f_event_id))::int,
-          f_subagent = (EXISTS (SELECT 1 FROM ${tSessionEvents} sb
-                                  JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
-                                 WHERE sb.f_event_id = ${tEventUsage}.f_event_id
-                                   AND ss.f_origin = 'subagent'))::int
-         WHERE f_event_id IN (${sql.join(chunk.map((id) => sql`${id}`), sql`, `)})
-      `);
-		}
-	}
-	async deleteSessionStats(id) {
-		await this.db.execute(sql`DELETE FROM ${this.tables["t_session_usage"]} WHERE f_session_id = ${id}`);
-		await this.db.execute(sql`DELETE FROM ${this.tables["t_session_counts"]} WHERE f_session_id = ${id}`);
-	}
-	async getPrevBridge(exec, id, sequence) {
-		return (await exec.select({
-			fEventId: this.tables["t_session_events"].fEventId,
-			fSequence: this.tables["t_session_events"].fSequence
-		}).from(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), eq(this.tables["t_session_events"].fSequence, sequence))).execute())[0];
-	}
-	eventRows(exec) {
-		return exec.select({
-			fEventId: this.tables["t_session_events"].fEventId,
-			fSequence: this.tables["t_session_events"].fSequence,
-			fType: this.tables["t_events"].fType,
-			fKind: this.tables["t_events"].fKind,
-			fRole: this.tables["t_events"].fRole,
-			fName: this.tables["t_events"].fName,
-			fActionId: this.tables["t_events"].fActionId,
-			fCreatedAt: this.tables["t_events"].fCreatedAt,
-			fData: this.tables["t_events"].fData,
-			fSurfaceOp: this.tables["t_session_events"].fSurfaceOp
-		}).from(this.tables["t_session_events"]).innerJoin(this.tables["t_events"], eq(this.tables["t_session_events"].fEventId, this.tables["t_events"].fEventId));
-	}
-};
-//#endregion
-//#region src/rows.ts
-const MAX_PAGE_SIZE = 200;
-const DEFAULT_PAGE_SIZE = 20;
-function registerSessionRows(ctx, backend) {
-	ctx.inject(["webServer", "connection"], (webCtx) => {
-		const webServer = webCtx.webServer;
-		const connection = webCtx.get("connection");
-		return webCtx.effect(() => webServer.register({
-			kind: "exact",
-			path: SESSION_ROWS_PATH,
-			handler: async (req, res) => {
-				const rejection = connection.requestRejection(req);
-				if (rejection !== void 0) {
-					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 = [];
-				for await (const chunk of req) chunks.push(chunk);
-				const raw = Buffer.concat(chunks).toString("utf8");
-				let envelope = {};
-				if (raw !== "") try {
-					envelope = JSON.parse(raw);
-				} catch {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "request body is not JSON" }));
-					return;
-				}
-				const page = Number.isSafeInteger(envelope.page) && (envelope.page ?? 0) > 0 ? envelope.page : 1;
-				const requested = envelope.pageSize;
-				const pageSize = Number.isSafeInteger(requested) && (requested ?? 0) > 0 ? Math.min(requested, MAX_PAGE_SIZE) : DEFAULT_PAGE_SIZE;
-				try {
-					const { items, total } = await backend.listSessionRows({
-						...envelope.query === void 0 ? {} : { query: envelope.query },
-						...envelope.includeSubagents === void 0 ? {} : { includeSubagents: envelope.includeSubagents },
-						limit: pageSize,
-						offset: (page - 1) * pageSize
-					});
-					res.writeHead(200, { "content-type": "application/json" });
-					res.end(JSON.stringify({
-						items,
-						total,
-						page,
-						pageSize
-					}));
-				} catch (error) {
-					res.writeHead(500, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "session rows failed" }));
-				}
-			}
-		}), "session-rdb: session rows route");
-	});
-}
-//#endregion
-//#region src/session-query.ts
-var SessionQueryRdb = class extends SessionQueryEngine {
-	constructor(ctx, config = {}) {
-		super(ctx, config);
-	}
-	async listSessions(signal) {
-		const records = await super.listSessions(signal);
-		const archived = this.archivedSessionIds();
-		if (archived.size === 0) return records;
-		return records.filter((record) => !archived.has(String(record.header.id)));
-	}
-	archivedSessionIds() {
-		const registry = this.ctx.get("workspaceRegistry");
-		return new Set(registry?.archivedSessionIds ?? []);
-	}
-	async searchSessions() {
-		throw searchDisabled();
-	}
-	async searchEvents() {
-		throw searchDisabled();
-	}
-};
-function searchDisabled() {
-	return new SessionQueryError("session search is disabled: this deployment serves session queries from the rdb backend without a full-text index", "SESSION_QUERY_SEARCH_DISABLED");
-}
-//#endregion
-//#region src/storage-takeover/projection-cache.ts
-const SESSION_PROJECTION_CACHE_SERVICE = "sessionProjectionCache";
-const PREDECESSOR_TITLE_KEY = "title";
-var SessionProjectionCacheRdb = class extends Service {
-	static inject = ["sessionProjections", "sessions"];
-	records = /* @__PURE__ */ new Map();
-	dirty = /* @__PURE__ */ new Map();
-	directReads;
-	config;
-	repository;
-	ready;
-	constructor(ctx, options) {
-		super(ctx, SESSION_PROJECTION_CACHE_SERVICE);
-		this.config = options;
-		this.repository = options.repository;
-		this.ready = options.ready;
-		this.directReads = options.repository.readProjcacheDirect !== void 0;
-	}
-	async [Service.init]() {
-		this.installWritePath();
-		await this.ready;
-		const pruned = await this.repository.pruneStaleProjcache();
-		if (pruned > 0) this.ctx.logger.info(`session projection cache: pruned stale snapshot(s) for ${String(pruned)} session(s)`);
-		if (!this.directReads) for (const entry of await this.repository.loadProjcache()) this.records.set(entry.sessionId, entry);
-	}
-	lookup(id) {
-		if (this.directReads) return this.repository.readProjcacheDirect?.(id);
-		return this.records.get(id);
-	}
-	recordFor(id, expected) {
-		const record = this.lookup(id);
-		if (record === void 0) return void 0;
-		return identityMatches(record.identity, expected) ? record : void 0;
-	}
-	cachedSnapshot(meta, keys) {
-		const record = this.recordForLifecycle(meta);
-		const snapshot = record === void 0 ? void 0 : this.viewRecord(record, keys);
-		return this.withDirectTitle(meta.id, keys, snapshot);
-	}
-	recordForLifecycle(meta) {
-		const record = this.lookup(meta.id);
-		return record === void 0 || !identityMatches(record.identity, lifecycleIdentityOf(meta)) ? void 0 : record;
-	}
-	withDirectTitle(id, keys, snapshot) {
-		if (keys !== void 0 && !keys.includes(PREDECESSOR_TITLE_KEY)) return snapshot;
-		if (snapshot?.values[PREDECESSOR_TITLE_KEY] !== void 0) return snapshot;
-		const direct = this.repository.readSessionTitleDirect?.(id);
-		if (direct === void 0) return snapshot;
-		const values = {
-			...snapshot?.values,
-			[PREDECESSOR_TITLE_KEY]: direct.title
-		};
-		return {
-			asOfSeq: snapshot === void 0 ? direct.seq : Math.min(snapshot.asOfSeq, direct.seq),
-			values
-		};
-	}
-	cachedPredecessorTitle(meta) {
-		const record = this.lookup(meta.id);
-		if (record === void 0 || !predecessorIdentityMatches(record.identity, lifecycleIdentityOf(meta))) return;
-		return this.viewRecord(record, [PREDECESSOR_TITLE_KEY]);
-	}
-	viewRecord(record, keys) {
-		const values = this.ctx.sessionProjections.viewCheckpoint(record.rows, keys);
-		const servedKeys = Object.keys(values);
-		if (servedKeys.length === 0) return void 0;
-		const firstKey = servedKeys[0];
-		let asOfSeq = record.rows[firstKey].seq;
-		for (const key of servedKeys.slice(1)) {
-			const row = record.rows[key];
-			if (row.seq < asOfSeq) asOfSeq = row.seq;
-		}
-		return {
-			asOfSeq,
-			values
-		};
-	}
-	hydratePrepared(session, events) {
-		const record = this.recordFor(session.id, identityOf(session.header, session.inheritedEventCount));
-		if (record === void 0) return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
-		try {
-			return this.ctx.sessionProjections.hydrate(session, record.rows, events, SessionLogOffset(0));
-		} catch {
-			return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
-		}
-	}
-	async write(session) {
-		const rows = this.ctx.sessionProjections.checkpoint(session);
-		this.markClean(session);
-		if (this.ctx.sessions.get(session.id) === session) await this.ctx.sessions.flush(session);
-		await this.put(session.id, identityOf(session.header, session.inheritedEventCount), rows);
-	}
-	async truncateTo(meta, inheritedEventCount, headSeq) {
-		const identity = identityOf(meta, inheritedEventCount);
-		const record = this.recordFor(meta.id, identity);
-		if (record === void 0) return;
-		const rows = Object.fromEntries(Object.entries(record.rows).filter(([, row]) => row.seq <= headSeq));
-		await this.put(meta.id, identity, rows);
-	}
-	coldSnapshot(meta, inheritedEventCount, events) {
-		const identity = identityOf(meta, inheritedEventCount);
-		const restored = this.ctx.sessionProjections.restore(this.recordFor(meta.id, identity)?.rows ?? {}, events, SessionLogOffset(0), meta, inheritedEventCount);
-		this.put(meta.id, identity, restored.checkpoint).catch((error) => {
-			this.ctx.logger.warn(`session projection cache: cold-read write-back for "${meta.id}" failed (cache stays stale): ${String(error)}`);
-		});
-		return restored.snapshot;
-	}
-	installWritePath() {
-		this.ctx.on("session/event", (session, event) => {
-			if (event.type === "turn/end") {
-				this.flushSoft(session, "turn/end");
-				return;
-			}
-			const state = this.dirty.get(session) ?? {
-				pending: 0,
-				timer: void 0
-			};
-			this.dirty.set(session, state);
-			state.pending += 1;
-			if (state.pending >= this.config.writeEveryEvents) {
-				this.flushSoft(session, "count threshold");
-				return;
-			}
-			state.timer ??= setTimeout(() => {
-				this.flushSoft(session, "interval");
-			}, this.config.writeIntervalMs);
-		});
-		this.ctx.on("session/created", (session) => {
-			this.flushSoft(session, "create");
-		});
-		this.ctx.on("session/disposed", (session) => {
-			this.flushSoft(session, "detach");
-			this.markClean(session);
-			this.dirty.delete(session);
-		});
-		this.ctx.effect(() => () => {
-			for (const state of this.dirty.values()) if (state.timer !== void 0) clearTimeout(state.timer);
-			this.dirty.clear();
-		}, "sessionProjectionCacheRdb.timers");
-	}
-	async flushSoft(session, trigger) {
-		try {
-			await this.write(session);
-		} catch (error) {
-			this.ctx.logger.warn(`session projection cache: ${trigger} write for "${session.id}" failed (cache stays stale): ${String(error)}`);
-		}
-	}
-	markClean(session) {
-		const state = this.dirty.get(session);
-		if (state === void 0) return;
-		state.pending = 0;
-		if (state.timer !== void 0) {
-			clearTimeout(state.timer);
-			state.timer = void 0;
-		}
-	}
-	async put(id, identity, rows) {
-		const detached = detachJson(rows);
-		await this.repository.putProjcache(id, detached);
-		if (!this.directReads) this.records.set(id, {
-			sessionId: id,
-			identity,
-			rows: detached
-		});
-	}
-};
-function detachJson(rows) {
-	let text;
-	try {
-		text = JSON.stringify(rows);
-	} catch (error) {
-		throw new TypeError(`projection checkpoint is not losslessly JSON-serializable: ${String(error)}`, { cause: error });
-	}
-	if (text === void 0) throw new TypeError("projection checkpoint is not losslessly JSON-serializable");
-	return JSON.parse(text);
-}
-function lifecycleIdentityOf(header) {
-	return {
-		formatVersion: header.version,
-		createdAt: header.createdAt,
-		...header.cwd === void 0 ? {} : { cwd: header.cwd },
-		isSeeded: header.isSeeded
-	};
-}
-function identityOf(header, inheritedEventCount) {
-	const cut = SessionLogOffset(inheritedEventCount);
-	if (!header.isSeeded && cut !== 0) throw new Error("unseeded projection-cache identity inherited event count must be 0");
-	return {
-		formatVersion: header.version,
-		createdAt: header.createdAt,
-		...header.cwd === void 0 ? {} : { cwd: header.cwd },
-		isSeeded: header.isSeeded,
-		inheritedEventCount: cut
-	};
-}
-function identityMatches(stored, expected) {
-	return stored.formatVersion === expected.formatVersion && lifecycleIdentityMatches(stored, expected);
-}
-function predecessorIdentityMatches(stored, expected) {
-	return (stored.formatVersion === void 0 || stored.formatVersion < expected.formatVersion) && lifecycleIdentityMatches(stored, expected);
-}
-function lifecycleIdentityMatches(stored, expected) {
-	return stored.createdAt === expected.createdAt && stored.cwd === expected.cwd && (stored.isSeeded ?? false) === expected.isSeeded;
-}
-//#endregion
-//#region src/storage-takeover/storage-backend.ts
-const WORKSPACE_UNIT = "workspace";
-const WORKSPACE_TABLE = "workspaces";
-const SCHEDULE_UNIT = "schedule";
-const SCHEDULE_TABLE = "tasks";
-var RdbStorageBackend = class {
-	repository;
-	kv = { open: (descriptor) => this.openUnit(descriptor) };
-	open = /* @__PURE__ */ new Map();
-	closed = false;
-	constructor(repository) {
-		this.repository = repository;
-	}
-	async openUnit(descriptor) {
-		if (this.closed) throw new StorageError("closed", "rdb storage backend is closed");
-		if (descriptor.layout !== void 0 && descriptor.layout !== "single") throw new Error(`rdb storage backend serves only the 'single' layout (domain '${descriptor.name}' declares '${descriptor.layout}')`);
-		if (this.open.has(descriptor.name)) throw new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`);
-		const unit = this.unitFor(descriptor);
-		this.open.set(descriptor.name, unit);
-		try {
-			const stored = await this.repository.readUnitVersion(descriptor.name);
-			if (stored === void 0) await this.repository.insertUnitVersion(descriptor.name, descriptor.version);
-			else if (stored !== descriptor.version) throw new StorageError("version-mismatch", `kv unit '${descriptor.name}' is stamped version ${stored} on the medium, incompatible with descriptor version ${descriptor.version}`);
-		} catch (error) {
-			this.open.delete(descriptor.name);
-			throw error;
-		}
-		unit.onClose(() => {
-			this.open.delete(descriptor.name);
-		});
-		return unit;
-	}
-	unitFor(descriptor) {
-		if (descriptor.name === WORKSPACE_UNIT) {
-			if (!descriptor.tables.includes(WORKSPACE_TABLE) || descriptor.hasGlobal !== true) throw new Error(`rdb storage backend expects the '${WORKSPACE_UNIT}' domain shape (table '${WORKSPACE_TABLE}' plus a global slot)`);
-			return new WorkspaceKvUnit(this.repository, descriptor);
-		}
-		if (descriptor.name === SCHEDULE_UNIT) {
-			if (!descriptor.tables.includes(SCHEDULE_TABLE) || descriptor.hasGlobal !== false) throw new Error(`rdb storage backend expects the '${SCHEDULE_UNIT}' domain shape (table '${SCHEDULE_TABLE}' without a global slot)`);
-			return new ScheduleKvUnit(this.repository, descriptor);
-		}
-		throw new Error(`rdb storage backend serves only the '${WORKSPACE_UNIT}' and '${SCHEDULE_UNIT}' domains (requested '${descriptor.name}')`);
-	}
-	async close() {
-		this.closed = true;
-		const units = [...this.open.values()];
-		this.open.clear();
-		await Promise.all(units.map((unit) => unit.close()));
-	}
-};
-var TrackedKvUnit = class {
-	repository;
-	descriptor;
-	closed = false;
-	inflight = /* @__PURE__ */ new Set();
-	onClosed;
-	constructor(repository, descriptor) {
-		this.repository = repository;
-		this.descriptor = descriptor;
-	}
-	onClose(release) {
-		this.onClosed = release;
-	}
-	async close() {
-		if (this.closed) return;
-		this.closed = true;
-		while (this.inflight.size > 0) await Promise.allSettled(this.inflight);
-		this.onClosed?.();
-	}
-	async track(operation) {
-		const settled = operation.then(() => void 0, () => void 0);
-		this.inflight.add(settled);
-		try {
-			await operation;
-		} finally {
-			this.inflight.delete(settled);
-		}
-	}
-	assertOpen() {
-		if (this.closed) throw new StorageError("closed", `kv unit '${this.descriptor.name}' is closed`);
-	}
-	assertTable(table) {
-		if (!this.tables.includes(table)) throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
-	}
-};
-var WorkspaceKvUnit = class extends TrackedKvUnit {
-	tables = [WORKSPACE_TABLE];
-	async loadAll() {
-		this.assertOpen();
-		const records = Object.create(null);
-		for (const { id, record } of await this.repository.listWorkspaces()) records[id] = record;
-		const state = await this.repository.readWorkspaceState();
-		return {
-			tables: { [WORKSPACE_TABLE]: records },
-			global: state
-		};
-	}
-	async putRecord(table, key, value) {
-		this.assertOpen();
-		this.assertTable(table);
-		await this.track(this.repository.putWorkspace(key, workspaceRecordOf(value)));
-	}
-	async deleteRecord(table, key) {
-		this.assertOpen();
-		this.assertTable(table);
-		await this.track(this.repository.deleteWorkspace(key));
-	}
-	async setGlobal(value) {
-		this.assertOpen();
-		await this.track(this.repository.writeWorkspaceState(workspaceStateOf(value)));
-	}
-};
-var ScheduleKvUnit = class extends TrackedKvUnit {
-	tables = [SCHEDULE_TABLE];
-	async loadAll() {
-		this.assertOpen();
-		const records = Object.create(null);
-		for (const { id, task } of await this.repository.listScheduleTasks()) records[id] = task;
-		return {
-			tables: { [SCHEDULE_TABLE]: records },
-			global: null
-		};
-	}
-	async putRecord(table, key, value) {
-		this.assertOpen();
-		this.assertTable(table);
-		await this.track(this.repository.putScheduleTask(key, scheduleTaskOf(value)));
-	}
-	async deleteRecord(table, key) {
-		this.assertOpen();
-		this.assertTable(table);
-		await this.track(this.repository.deleteScheduleTask(key));
-	}
-	setGlobal(_value) {
-		throw new Error(`unit '${this.descriptor.name}' declares no global slot`);
-	}
-};
-function workspaceRecordOf(value) {
-	const record = value;
-	if (typeof record !== "object" || record === null || typeof record.path !== "string" || typeof record.title !== "string" || !Array.isArray(record.sessionIds) || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string") throw new TypeError("workspace record does not match the stored shape");
-	return {
-		path: record.path,
-		title: record.title,
-		sessionIds: record.sessionIds.map((id) => id),
-		createdAt: record.createdAt,
-		updatedAt: record.updatedAt
-	};
-}
-function workspaceStateOf(value) {
-	const state = value;
-	if (typeof state !== "object" || state === null || typeof state.initialized !== "boolean" || !Array.isArray(state.workspaceIds) || !Array.isArray(state.archivedSessionIds) || !Array.isArray(state.pinnedSessionIds)) throw new TypeError("workspace registry state does not match the stored shape");
-	return {
-		initialized: state.initialized,
-		workspaceIds: state.workspaceIds.map((id) => id),
-		archivedSessionIds: state.archivedSessionIds.map((id) => id),
-		pinnedSessionIds: state.pinnedSessionIds.map((id) => id),
-		...state.pendingMutation === void 0 ? {} : { pendingMutation: state.pendingMutation }
-	};
-}
-function scheduleTaskOf(value) {
-	const task = value;
-	if (typeof task !== "object" || task === null || typeof task.sessionId !== "string" || typeof task.record !== "object" || task.record === null) throw new TypeError("schedule task does not match the stored shape");
-	return task;
-}
-//#endregion
-//#region src/storage-takeover/index.ts
-function installStorageTakeover(ctx, options) {
-	ctx.inject(["storage"], (storageCtx) => {
-		const backend = new RdbStorageBackend(options.repository);
-		storageCtx.effect(() => {
-			const unregister = storageCtx.storage.backend.register("rdb", backend);
-			return async () => {
-				unregister();
-				await backend.close();
-			};
-		}, "session-rdb.storageBackend");
-		storageCtx.provide(storageBackendServiceKey("rdb"), backend);
-	});
-	ctx.plugin(SessionProjectionCacheRdb, {
-		...options.projectionCache,
-		repository: options.repository,
-		ready: options.ready
-	});
-}
-//#endregion
-//#region src/index.ts
-function maxEventTime(events) {
-	let max;
-	for (const event of events) {
-		const time = event.time;
-		if (typeof time !== "number") continue;
-		if (max === void 0 || time > max) max = time;
-	}
-	return max;
-}
-const DEFAULT_PROJECTION_WRITE_EVERY_EVENTS = 200;
-const DEFAULT_PROJECTION_WRITE_INTERVAL_MS = 5e3;
-var SessionDeletionError = class extends Error {
-	code;
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "SessionDeletionError";
-	}
-};
-var RdbBackendTracker = class {
-	name;
-	writers = /* @__PURE__ */ new Map();
-	pending = /* @__PURE__ */ new Map();
-	openHandles = /* @__PURE__ */ new Set();
-	counter = 0;
-	constructor(name) {
-		this.name = name;
-	}
-	registerCreated(header, inheritedEventCount) {
-		if (this.writers.has(header.id)) throw new SessionAlreadyExistsError(header.id);
-		this.writers.set(header.id, null);
-		this.pending.set(header.id, {
-			header,
-			revision: SessionPersistenceRevision(`memory:${this.name}:${++this.counter}`),
-			inheritedEventCount,
-			cursor: 0,
-			everAppended: false
-		});
-	}
-	updatePending(id, cursor, everAppended) {
-		const entry = this.pending.get(id);
-		if (entry === void 0) return;
-		this.pending.set(id, {
-			...entry,
-			cursor,
-			everAppended
-		});
-	}
-	claimWrite(id) {
-		if (this.writers.has(id)) throw new SessionAlreadyOwnedError(id);
-		this.writers.set(id, null);
-	}
-	releaseClaim(id) {
-		this.writers.delete(id);
-	}
-	pendingOf(id) {
-		return this.pending.get(id);
-	}
-	hasPending(id) {
-		return this.pending.has(id);
-	}
-	pendingEntries() {
-		return this.pending.entries();
-	}
-	materialized(id) {
-		this.pending.delete(id);
-	}
-	adopt(handle) {
-		this.openHandles.add(handle);
-		if (handle.access === "write") this.writers.set(handle.id, handle);
-		return handle;
-	}
-	release(handle, materialized) {
-		this.openHandles.delete(handle);
-		if (handle.access !== "write") return;
-		this.writers.delete(handle.id);
-		if (!materialized) this.pending.delete(handle.id);
-	}
-	writerOf(id) {
-		const writer = this.writers.get(id);
-		return writer === null ? void 0 : writer;
-	}
-	hasOpenHandle(id) {
-		for (const handle of this.openHandles) if (handle.id === id) return true;
-		return false;
-	}
-	async flushAll() {
-		const errors = [];
-		for (const writer of this.writers.values()) {
-			if (writer === null) continue;
-			try {
-				await writer.drainLive();
-				await writer.flush();
-			} catch (error) {
-				if (error instanceof SessionHandleClosedError) continue;
-				errors.push(error);
-			}
-		}
-		if (errors.length > 0) throw new AggregateError(errors, `${this.name} flush failed`);
-	}
-	async closeAll() {
-		const errors = [];
-		for (const handle of this.openHandles) try {
-			await handle.close();
-		} catch (error) {
-			errors.push(error);
-		}
-		if (errors.length > 0) throw new AggregateError(errors, `${this.name} dispose failed`);
-	}
-};
-var RdbSessionHandle = class RdbSessionHandle {
-	persistence;
-	id;
-	header;
-	access;
-	state;
-	chain = Promise.resolve();
-	closing;
-	cursor;
-	materialized;
-	buffered = [];
-	batchTimer;
-	drainPaused = false;
-	draining;
-	tornTruncateTo;
-	everAppended = false;
-	constructor(persistence, id, header, access, state) {
-		this.persistence = persistence;
-		this.id = id;
-		this.header = header;
-		this.access = access;
-		this.state = state;
-		this.cursor = state.cursor;
-		this.materialized = state.materialized;
-		this.tornTruncateTo = state.tornTruncateTo;
-	}
-	get inheritedEventCount() {
-		return this.state.inheritedEventCount;
-	}
-	get cursorValue() {
-		return this.cursor;
-	}
-	async read(offset = 0, length = Number.MAX_SAFE_INTEGER, options) {
-		this.assertOpen("read");
-		if (!Number.isSafeInteger(offset) || offset < 0) throw new TypeError(`read offset must be a non-negative safe integer, got ${String(offset)}`);
-		if (!Number.isSafeInteger(length) || length < 0) throw new TypeError(`read length must be a non-negative safe integer, got ${String(length)}`);
-		options?.signal?.throwIfAborted();
-		const log = await this.persistence.readLog(this.id, {}, options?.signal);
-		if (log === void 0) {
-			if (this.persistence.tracker.hasPending(this.id)) return {
-				eventState: "detached",
-				events: []
-			};
-			throw new SessionPersistenceNotFoundError(this.id);
-		}
-		repairReadView(log.events);
-		return {
-			eventState: "detached",
-			events: log.events.slice(offset, offset + length)
-		};
-	}
-	async append(events, options) {
-		this.assertOpen("append");
-		const batch = materializeAppendBatch(events);
-		return this.run("append", async () => {
-			options?.signal?.throwIfAborted();
-			if (this.access !== "write") throw new SessionReadOnlyError(this.id, "append");
-			if (batch.length === 0) return;
-			this.everAppended = true;
-			assertContiguous(this.id, batch, this.cursor);
-			await this.persistence.appendBatch(this.header, this.state.inheritedEventCount, batch, this.tornTruncateTo);
-			this.tornTruncateTo = void 0;
-			this.cursor += batch.length;
-			this.materialized = true;
-			this.persistence.tracker.updatePending(this.id, this.cursor, true);
-		});
-	}
-	async flush(options) {
-		return this.run("flush", async () => {
-			options?.signal?.throwIfAborted();
-			if (this.access !== "write") throw new SessionReadOnlyError(this.id, "flush");
-			if (this.materialized) return;
-			await this.persistence.materializeEmpty(this.header, this.state.inheritedEventCount);
-			this.materialized = true;
-		});
-	}
-	close() {
-		return this.closing ??= (async () => {
-			let drainFailure;
-			for (;;) {
-				try {
-					await this.drainLive();
-				} catch (error) {
-					drainFailure = error;
-					break;
-				}
-				await this.chain;
-				if (this.buffered.length === 0) break;
-			}
-			await this.chain;
-			const failures = [];
-			if (drainFailure !== void 0) failures.push(drainFailure instanceof Error ? drainFailure : new Error(JSON.stringify(drainFailure)));
-			this.persistence.tracker.release(this, this.materialized || this.everAppended);
-			if (failures.length > 1) throw new AggregateError(failures, `session "${this.id}": close failed to drain`);
-			if (failures[0] !== void 0) throw failures[0];
-		})();
-	}
-	[Symbol.asyncDispose]() {
-		return this.close();
-	}
-	enqueueLive(event, reportBackgroundFailure) {
-		this.buffered.push(structuredClone(event));
-		if (this.batchTimer !== void 0 || this.drainPaused) return;
-		this.batchTimer = setTimeout(() => {
-			this.batchTimer = void 0;
-			this.drainLive().catch(reportBackgroundFailure);
-		}, RdbSessionHandle.LIVE_WRITE_BATCH_MAX_DELAY_MS);
-	}
-	resetAfterRewind(cursor, inheritedEventCount) {
-		this.cursor = cursor;
-		if (inheritedEventCount !== void 0) this.state.inheritedEventCount = SessionLogOffset(inheritedEventCount);
-	}
-	drainLive() {
-		return this.draining ??= this.drainBuffered().finally(() => {
-			this.draining = void 0;
-		});
-	}
-	async drainBuffered() {
-		if (this.batchTimer !== void 0) {
-			clearTimeout(this.batchTimer);
-			this.batchTimer = void 0;
-		}
-		this.drainPaused = false;
-		while (this.buffered.length > 0) await this.enqueueChain(async () => {
-			const batch = this.buffered.splice(0);
-			try {
-				const fresh = batch.filter((event) => event.seq >= this.cursor);
-				if (fresh.length === 0) return;
-				for (const [index, event] of fresh.entries()) if (event.seq !== this.cursor + index) throw new Error(`append seq mismatch for "${this.id}": expected ${this.cursor + index} at index ${index}, got ${event.seq}`);
-				await this.persistence.appendBatch(this.header, this.state.inheritedEventCount, fresh, this.tornTruncateTo);
-				this.tornTruncateTo = void 0;
-				this.cursor += fresh.length;
-				this.materialized = true;
-			} catch (error) {
-				this.buffered = batch.concat(this.buffered);
-				this.drainPaused = true;
-				throw error;
-			}
-		});
-	}
-	enqueueChain(op) {
-		const next = this.chain.then(op);
-		this.chain = next.catch(() => {});
-		return next;
-	}
-	async run(operation, op) {
-		this.assertOpen(operation);
-		return this.enqueueChain(async () => {
-			this.assertOpen(operation);
-			return op();
-		});
-	}
-	assertOpen(operation) {
-		if (this.closing !== void 0) throw new SessionHandleClosedError(this.id, operation);
-	}
-	static LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
-};
-const localized = (text) => text;
-const projectionCacheSchema = z.object({
-	writeEveryEvents: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS).description(localized({
-		zh: "每累计这么多事件写回一次投影 checkpoint。",
-		en: "Write the projection checkpoint back after this many events."
-	})),
-	writeIntervalMs: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS).description(localized({
-		zh: "距离上次写回超过这个间隔（毫秒）时也写一次。",
-		en: "Also write back when this many ms passed since the last one."
-	}))
-}).default({
-	writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-	writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-});
-var SessionPersistenceRdb = class extends SessionPersistence {
-	static inject = ["sessions"];
-	static Config = z.union([z.object({
-		type: z.const("sqlite"),
-		path: z.string().required().description(localized({
-			zh: "SQLite 数据库文件路径；`:memory:` 是内存库（进程结束即丢）。",
-			en: "SQLite database file path; `:memory:` keeps it in memory and loses it with the process."
-		})),
-		journalMode: z.union([
-			"wal",
-			"delete",
-			"truncate",
-			"persist"
-		]).default("wal").description(localized({
-			zh: "SQLite 日志模式；默认 wal（并发读最好）。",
-			en: "SQLite journal mode; `wal` by default (best concurrent reads)."
-		})),
-		busyTimeout: z.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS).description(localized({
-			zh: "写锁冲突时的忙等超时（毫秒）。",
-			en: "Busy timeout in ms while a write lock is contended."
-		})),
-		projectionCache: projectionCacheSchema
-	}), z.object({
-		type: z.const("postgres"),
-		connectionString: z.string().required().description(localized({
-			zh: "PostgreSQL 连接串（含库名与凭证）。",
-			en: "PostgreSQL connection string (database and credentials)."
-		})),
-		schema: z.string().default("public").description(localized({
-			zh: "库内的 schema 名；默认 public。",
-			en: "Schema name inside the database; `public` by default."
-		})),
-		projectionCache: projectionCacheSchema
-	})]).description(localized({
-		zh: "会话持久化后端：改这里的连接参数会在这一行重挂时生效（Loader 会重装被改的行）。",
-		en: "Session persistence backend: edits apply when this row is remounted (the Loader re-installs changed rows)."
-	})).volatile();
-	name = "session-rdb";
-	tracker = new RdbBackendTracker(this.name);
-	backend;
-	storeIdentity;
-	ready;
-	writeGuard = new WriteGuard();
-	reuseEventIds = /* @__PURE__ */ new Map();
-	liveBuffers = /* @__PURE__ */ new Map();
-	liveReady = /* @__PURE__ */ new Map();
-	config;
-	constructor(ctx, config, injectedBackend) {
-		super(ctx);
-		this.config = config.get();
-		this.backend = injectedBackend ?? createBackend(this.config);
-		this.ready = this.init();
-		this.installLiveRouting(ctx);
-		new SessionBranchRdb(this.ctx);
-		this.ctx.plugin(SessionQueryRdb, {});
-		registerSessionImport(this.ctx, this);
-		registerSessionDeletion(this.ctx, this);
-		registerSessionExport(this.ctx, this);
-		registerSessionGc(this.ctx, this);
-		registerSessionUsage(this.ctx, this);
-		registerSessionRows(this.ctx, this.backend);
-		installStorageTakeover(this.ctx, {
-			repository: this.backend.storage,
-			ready: this.ready,
-			projectionCache: {
-				writeEveryEvents: this.config.projectionCache?.writeEveryEvents ?? DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
-				writeIntervalMs: this.config.projectionCache?.writeIntervalMs ?? DEFAULT_PROJECTION_WRITE_INTERVAL_MS
-			}
-		});
-	}
-	async init() {
-		await this.backend.open();
-		this.storeIdentity = this.backend.storeIdentity;
-	}
-	async create(header, options) {
-		options?.signal?.throwIfAborted();
-		const snapshot = materializeCreateHeader(header);
-		if (snapshot.isSeeded && options?.inheritedEventCount === void 0) throw new TypeError("seeded session metadata requires an inherited event count");
-		const inheritedEventCount = SessionLogOffset(options?.inheritedEventCount ?? 0);
-		if (!snapshot.isSeeded && inheritedEventCount !== 0) throw new TypeError("unseeded session metadata inherited event count must be 0");
-		await this.ready;
-		options?.signal?.throwIfAborted();
-		if (this.tracker.hasPending(snapshot.id) || await this.backend.getSession(snapshot.id) !== void 0) throw new SessionAlreadyExistsError(snapshot.id);
-		this.tracker.registerCreated(snapshot, inheritedEventCount);
-		return this.tracker.adopt(new RdbSessionHandle(this, snapshot.id, snapshot, "write", {
-			cursor: 0,
-			materialized: false,
-			inheritedEventCount
-		}));
-	}
-	async open(id, access, options) {
-		options?.signal?.throwIfAborted();
-		await this.ready;
-		options?.signal?.throwIfAborted();
-		const pending = this.tracker.pendingOf(id);
-		if (access === "read") {
-			if (pending !== void 0) return this.tracker.adopt(new RdbSessionHandle(this, id, pending.header, "read", {
-				cursor: 0,
-				materialized: false,
-				inheritedEventCount: pending.inheritedEventCount
-			}));
-			const log = await this.readLog(id, {}, options?.signal);
-			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
-			repairReadView(log.events);
-			validateStoredEvents(log.meta, log.events);
-			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "read", {
-				cursor: log.events.length,
-				materialized: true,
-				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
-			}));
-		}
-		this.tracker.claimWrite(id);
-		try {
-			if (pending !== void 0) return this.tracker.adopt(new RdbSessionHandle(this, id, pending.header, "write", {
-				cursor: pending.cursor,
-				materialized: false,
-				inheritedEventCount: pending.inheritedEventCount
-			}));
-			const log = await this.readLog(id, {}, options?.signal);
-			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
-			repairReadView(log.events);
-			validateStoredEvents(log.meta, log.events);
-			if (log.migrated && log.events.length !== log.storedCount) await this.rewriteMigratedLog(id, log);
-			this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
-			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "write", {
-				cursor: log.events.length,
-				materialized: true,
-				inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
-				...log.tornFrom !== void 0 ? { tornTruncateTo: log.tornFrom } : {}
-			}));
-		} catch (error) {
-			this.tracker.releaseClaim(id);
-			throw error;
-		}
-	}
-	flush() {
-		return this.tracker.flushAll();
-	}
-	async stat(id, options) {
-		options?.signal?.throwIfAborted();
-		await this.ready;
-		options?.signal?.throwIfAborted();
-		const pending = this.tracker.pendingOf(id);
-		if (pending !== void 0) return {
-			header: pending.header,
-			revision: pending.revision
-		};
-		const row = await this.backend.getSession(id);
-		if (row === void 0) return void 0;
-		return {
-			header: rowToMeta(row),
-			revision: this.rowRevision(row)
-		};
-	}
-	async list(options) {
-		const signal = options?.signal;
-		const snapshots = [];
-		const listed = /* @__PURE__ */ new Set();
-		for (const [id, pending] of this.tracker.pendingEntries()) {
-			snapshots.push({
-				header: pending.header,
-				revision: pending.revision
-			});
-			listed.add(id);
-		}
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const rows = await this.backend.listSessions();
-		signal?.throwIfAborted();
-		for (const row of rows) {
-			if (listed.has(row.fSessionId)) continue;
-			snapshots.push({
-				header: rowToMeta(row),
-				revision: this.rowRevision(row)
-			});
-		}
-		return snapshots;
-	}
-	async deleteSession(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const row = await this.backend.getSession(id);
-		if (row === void 0) throw new SessionDeletionError(`session "${id}" not found`, "SESSION_NOT_FOUND");
-		if (row.fArchivedAt === null) throw new SessionDeletionError(`session "${id}" is not archived; only archived sessions can be deleted`, "SESSION_NOT_ARCHIVED");
-		if (this.tracker.hasPending(id) || this.tracker.hasOpenHandle(id)) throw new SessionDeletionError(`session "${id}" is live; stop it before deleting`, "SESSION_LIVE");
-		await this.unarchiveBeforeDeletion(id);
-		const referenced = await this.backend.transaction((tx) => tx.deleteSession(id));
-		this.liveBuffers.delete(id);
-		this.liveReady.delete(id);
-		this.liveFailures.delete(id);
-		this.liveDropWarned.delete(id);
-		this.reuseEventIds.delete(id);
-		await this.dropSessionStats(id);
-		await this.refreshEventUsageFlags(referenced);
-	}
-	async collectOrphans() {
-		await this.ready;
-		return this.backend.collectOrphans();
-	}
-	async collectOrphanSessions() {
-		await this.ready;
-		const deletable = (await this.backend.listOrphanSubagentSessions()).filter((id) => !this.tracker.hasPending(id) && !this.tracker.hasOpenHandle(id));
-		if (deletable.length === 0) return 0;
-		const { deleted, eventIds } = await this.backend.transaction((tx) => tx.deleteSessions(deletable));
-		for (const id of deletable) {
-			this.liveBuffers.delete(id);
-			this.liveReady.delete(id);
-			this.liveFailures.delete(id);
-			this.liveDropWarned.delete(id);
-			this.reuseEventIds.delete(id);
-			await this.dropSessionStats(id);
-		}
-		await this.refreshEventUsageFlags(eventIds);
-		return deleted;
-	}
-	async usageReport(sinceMs) {
-		await this.ready;
-		return this.backend.usageReport(sinceMs);
-	}
-	async vacuum() {
-		await this.ready;
-		await this.backend.vacuum();
-	}
-	async unarchiveBeforeDeletion(id) {
-		const registry = this.ctx.get("workspaceRegistry");
-		if (registry === void 0) return;
-		if (!registry.archivedSessionIds.includes(id)) return;
-		await registry.unarchiveSession(id);
-	}
-	async readRaw(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const log = await this.readLog(id, {}, signal);
-		if (log === void 0) return void 0;
-		repairReadView(log.events);
-		const events = balanceRewindPrefix(log.events, { keepOpenTail: true });
-		const inheritedEventCount = Math.min(log.inheritedEventCount, events.length);
-		return {
-			meta: log.meta,
-			inheritedEventCount,
-			filename: sessionFormatLogFilename(SESSION_FORMAT_VERSION),
-			content: toJsonlArtifact(log.meta, inheritedEventCount, events)
-		};
-	}
-	async materializeEmpty(meta, inheritedEventCount) {
-		await this.ready;
-		await this.backend.transaction(async (tx) => {
-			await tx.upsertSession({
-				meta,
-				inheritedEventCount
-			}, randomUUID());
-			await tx.bumpRevision(meta.id);
-		});
-		this.tracker.materialized(meta.id);
-		this.writeGuard.confirmHead(meta.id, -1);
-	}
-	async appendBatch(meta, inheritedEventCount, events, tornTruncateTo) {
-		await this.ready;
-		if (events.length === 0) return false;
-		sealOwnEvents(events);
-		validateStoredEvents(meta, [...events]);
-		const reuse = this.reuseEventIds.get(meta.id);
-		let confirmedHead = -1;
-		let usageRows = [];
-		await this.backend.transaction(async (tx) => {
-			if (tornTruncateTo !== void 0) {
-				await tx.deleteBridgeTail(meta.id, tornTruncateTo);
-				const prev = await tx.getPrevBridge(meta.id, tornTruncateTo - 1);
-				if (prev === void 0) await tx.updateHead(meta.id, "", -1);
-				else await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
-			}
-			await tx.upsertSession({
-				meta,
-				inheritedEventCount
-			}, randomUUID());
-			const head = await tx.getHead(meta.id);
-			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
-			const appended = await appendEventTail(tx, meta, events, {
-				parentId: head.fHeadEventId,
-				nextSeq: head.fHeadSequence + 1
-			}, reuse);
-			usageRows = appended.usageRows;
-			await tx.updateHead(meta.id, appended.headEventId, appended.headSequence);
-			await tx.bumpRevision(meta.id, maxEventTime(events));
-			confirmedHead = appended.headSequence;
-		});
-		if (reuse !== void 0) this.reuseEventIds.delete(meta.id);
-		this.writeGuard.confirmHead(meta.id, confirmedHead);
-		this.tracker.materialized(meta.id);
-		await this.recordSessionStats(meta.id, events, usageRows);
-		return true;
-	}
-	async readLog(id, options = {}, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const row = await this.backend.getSession(id);
-		if (row === void 0) return void 0;
-		const meta = rowToMeta(row);
-		const eventRows = options.fromSeq === void 0 ? await this.backend.getEventRows(id) : await this.backend.getEventRows(id, options.fromSeq);
-		signal?.throwIfAborted();
-		if (isLegacyVersion(row.fVersion)) try {
-			const converted = convertLegacyRows(row, eventRows);
-			return {
-				meta: converted.meta,
-				inheritedEventCount: converted.inheritedEventCount,
-				events: converted.events,
-				incarnation: row.fIncarnation,
-				revision: row.fRevision,
-				storedCount: eventRows.length,
-				migrated: true
-			};
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: session "${id}" is not a single released format; adopting its stored rows as current-format data (${error instanceof Error ? error.message : String(error)})`);
-			const adopted = adoptLegacyRows(row, eventRows);
-			return {
-				meta: adopted.meta,
-				inheritedEventCount: adopted.inheritedEventCount,
-				events: adopted.events,
-				incarnation: row.fIncarnation,
-				revision: row.fRevision,
-				storedCount: eventRows.length,
-				migrated: false,
-				...adopted.tornFrom !== void 0 ? { tornFrom: adopted.tornFrom } : {}
-			};
-		}
-		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
-		if (needsShapeAdoption(preserved)) {
-			const adopted = adoptLegacyRows(row, eventRows);
-			return {
-				meta: adopted.meta,
-				inheritedEventCount: adopted.inheritedEventCount,
-				events: adopted.events,
-				incarnation: row.fIncarnation,
-				revision: row.fRevision,
-				storedCount: eventRows.length,
-				migrated: false,
-				...adopted.tornFrom !== void 0 ? { tornFrom: adopted.tornFrom } : {}
-			};
-		}
-		return {
-			meta,
-			inheritedEventCount: row.fSeedLength ?? 0,
-			events: preserved,
-			incarnation: row.fIncarnation,
-			revision: row.fRevision,
-			storedCount: eventRows.length,
-			migrated: false,
-			...tornFrom !== void 0 ? { tornFrom } : {}
-		};
-	}
-	async recordSessionStats(id, events, usageRows) {
-		const usageBuckets = sessionUsageBuckets(usageRows);
-		if (usageBuckets.length > 0) try {
-			await this.backend.incrementSessionUsage(id, usageBuckets);
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: token usage for "${id}" not updated (${describeError(error)})`);
-		}
-		const countBuckets = sessionCountBuckets(events);
-		if (countBuckets.length > 0) try {
-			await this.backend.incrementSessionCounts(id, countBuckets);
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: activity counts for "${id}" not updated (${describeError(error)})`);
-		}
-	}
-	async rebuildSessionStats(id) {
-		try {
-			await this.backend.rebuildSessionStats(id);
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: session stats for "${id}" not rebuilt (${describeError(error)})`);
-		}
-	}
-	async refreshEventUsageFlags(eventIds) {
-		const unique = [...new Set(eventIds)];
-		if (unique.length === 0) return;
-		try {
-			await this.backend.refreshEventUsageFlags(unique);
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: usage reference flags not refreshed (${describeError(error)})`);
-		}
-	}
-	async dropSessionStats(id) {
-		try {
-			await this.backend.deleteSessionStats(id);
-		} catch (error) {
-			this.ctx.logger.warn(`session-rdb: session stats for "${id}" not deleted (${describeError(error)})`);
-		}
-	}
-	async rewriteMigratedLog(id, log) {
-		let removed = [];
-		await this.backend.transaction(async (tx) => {
-			const head = await tx.getHead(id);
-			if (!this.writeGuard.has(id)) this.writeGuard.confirmHead(id, head.fHeadSequence);
-			this.writeGuard.assertNoConcurrentWriter(id, head.fHeadSequence);
-			removed = await tx.deleteBridgeTail(id, 0);
-			await tx.upsertSession({
-				meta: log.meta,
-				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
-			}, randomUUID());
-			const appended = await appendEventTail(tx, log.meta, log.events, {
-				parentId: "",
-				nextSeq: 0
-			});
-			await tx.updateHead(id, appended.headEventId, appended.headSequence);
-			await tx.bumpRevision(id, maxEventTime(log.events));
-		});
-		await this.rebuildSessionStats(id);
-		await this.refreshEventUsageFlags(removed);
-	}
-	async listSnapshots(signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const snapshots = [];
-		const listed = /* @__PURE__ */ new Set();
-		for (const [id, pending] of this.tracker.pendingEntries()) {
-			snapshots.push({
-				header: pending.header,
-				revision: pending.revision,
-				inheritedEventCount: pending.inheritedEventCount
-			});
-			listed.add(id);
-		}
-		const rows = await this.backend.listSessions();
-		signal?.throwIfAborted();
-		for (const row of rows) {
-			if (listed.has(row.fSessionId)) continue;
-			snapshots.push({
-				header: rowToMeta(row),
-				revision: this.rowRevision(row),
-				inheritedEventCount: row.fSeedLength ?? 0
-			});
-		}
-		return snapshots;
-	}
-	async readStoredRevision(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const row = await this.backend.getSession(id);
-		if (row === void 0) return void 0;
-		return this.rowRevision(row);
-	}
-	async createAndAppend(header, events, inheritedEventCount) {
-		const handle = await this.create(header, inheritedEventCount === void 0 ? void 0 : { inheritedEventCount: SessionLogOffset(inheritedEventCount) });
-		try {
-			if (events.length > 0) await handle.append(events);
-		} finally {
-			await handle.close();
-		}
-	}
-	async load(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const log = await this.readLog(id, {}, signal);
-		if (log === void 0) {
-			const pending = this.tracker.pendingOf(id);
-			if (pending !== void 0) return {
-				meta: pending.header,
-				inheritedEventCount: SessionLogOffset(pending.inheritedEventCount),
-				events: []
-			};
-			throw new SessionPersistenceNotFoundError(id);
-		}
-		repairReadView(log.events);
-		validateStoredEvents(log.meta, log.events);
-		return {
-			meta: log.meta,
-			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
-			events: log.events
-		};
-	}
-	async append(id, events) {
-		const handle = await this.open(id, "write");
-		try {
-			await handle.append(events);
-		} finally {
-			await handle.close();
-		}
-	}
-	async readFrom(id, fromSeq, signal) {
-		const log = await this.readLog(id, { fromSeq }, signal);
-		if (log === void 0) throw new SessionPersistenceNotFoundError(id);
-		return {
-			meta: log.meta,
-			inheritedEventCount: log.inheritedEventCount,
-			events: log.events
-		};
-	}
-	async close() {
-		await this.ready;
-		await this.backend.close();
-	}
-	registerReuseEventIds(childId, map) {
-		this.reuseEventIds.set(childId, new Map(map));
-	}
-	dropReuseEventIds(childId) {
-		this.reuseEventIds.delete(childId);
-	}
-	internals() {
-		return {
-			backend: this.backend,
-			writeGuard: this.writeGuard,
-			create: (meta, inheritedEventCount) => this.create(meta, inheritedEventCount === void 0 ? void 0 : { inheritedEventCount: SessionLogOffset(inheritedEventCount) }),
-			append: (id, events) => this.append(id, events),
-			load: (id) => this.load(id),
-			inspect: (id, signal) => this.load(id, signal),
-			readFrom: (id, fromSeq, signal) => this.readFrom(id, fromSeq, signal),
-			listSnapshots: (signal) => this.listSnapshots(signal),
-			readStoredRevision: (id, signal) => this.readStoredRevision(id, signal),
-			registerReuseEventIds: (childId, map) => this.registerReuseEventIds(childId, map),
-			dropReuseEventIds: (childId) => this.dropReuseEventIds(childId)
-		};
-	}
-	rowRevision(row) {
-		return SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
-	}
-	liveFailures = /* @__PURE__ */ new Map();
-	liveDropWarned = /* @__PURE__ */ new Set();
-	watchLiveReady(ctx, session, ready) {
-		ready.catch((error) => {
-			const failure = error instanceof Error ? error : new Error(typeof error === "string" ? error : `live session "${session.id}" persistence failed`);
-			this.liveFailures.set(session.id, failure);
-			this.liveBuffers.delete(session.id);
-			ctx.logger.error(`session-rdb: live session "${session.id}" persistence unavailable (${failure.message}); its events will not be persisted`);
-		});
-	}
-	installLiveRouting(ctx) {
-		ctx.on("session/created", (session) => {
-			this.liveBuffers.set(session.id, []);
-			const ready = this.ensureLiveHandle(session);
-			this.liveReady.set(session.id, ready);
-			this.watchLiveReady(ctx, session, ready);
-		});
-		for (const session of ctx.sessions.list()) {
-			this.liveBuffers.set(session.id, []);
-			const ready = this.ensureLiveHandle(session);
-			this.liveReady.set(session.id, ready);
-			this.watchLiveReady(ctx, session, ready);
-		}
-		ctx.on("session/event", (session, event) => {
-			const handle = this.tracker.writerOf(session.id);
-			if (handle !== void 0) {
-				handle.enqueueLive(event, (error) => {
-					ctx.logger.warn(`session-rdb: background write for session "${session.id}" failed (buffered events retained): ${String(error)}`);
-				});
-				return;
-			}
-			if (this.liveFailures.has(session.id)) {
-				if (!this.liveDropWarned.has(session.id)) {
-					this.liveDropWarned.add(session.id);
-					ctx.logger.warn(`session-rdb: dropping events for live session "${session.id}" because persistence failed earlier`);
-				}
-				return;
-			}
-			this.liveBuffers.get(session.id)?.push(structuredClone(event));
-		});
-		ctx.on("session/flush", (session) => {
-			const failure = this.liveFailures.get(session.id);
-			if (failure !== void 0) return Promise.reject(failure);
-			const handle = this.tracker.writerOf(session.id);
-			if (handle === void 0) {
-				const ready = this.liveReady.get(session.id);
-				if (ready === void 0) return void 0;
-				return ready.then(() => {
-					const settled = this.tracker.writerOf(session.id);
-					if (settled === void 0) return void 0;
-					return settled.drainLive().then(() => settled.flush());
-				});
-			}
-			return handle.drainLive().then(() => handle.flush());
-		});
-		ctx.on("session/disposed", (session) => {
-			const ready = this.liveReady.get(session.id);
-			this.liveBuffers.delete(session.id);
-			this.liveReady.delete(session.id);
-			this.liveFailures.delete(session.id);
-			this.liveDropWarned.delete(session.id);
-			const closeHandle = () => {
-				const handle = this.tracker.writerOf(session.id);
-				if (handle === void 0) return;
-				handle.close().catch((error) => {
-					ctx.logger.warn(`session-rdb: final drain for session "${session.id}" failed: ${String(error)}`);
-				});
-			};
-			if (ready === void 0) {
-				closeHandle();
-				return;
-			}
-			ready.then(closeHandle, closeHandle);
-		});
-		ctx.effect(() => async () => {
-			await Promise.allSettled(this.liveReady.values());
-			this.liveBuffers.clear();
-			this.liveReady.clear();
-			this.liveFailures.clear();
-			this.liveDropWarned.clear();
-			await this.tracker.closeAll();
-			await this.close();
-		}, `${this.name} open handles`);
-	}
-	async ensureLiveHandle(session) {
-		const id = session.header.id;
-		if (this.tracker.writerOf(id) !== void 0) return;
-		await this.ready;
-		const stored = await this.readLog(id, {});
-		let handle;
-		if (stored === void 0) {
-			handle = await this.create(session.header, { inheritedEventCount: session.inheritedEventCount });
-			const seed = session.snapshotEvents();
-			if (seed.length > 0) await handle.append(seed);
-		} else {
-			if (stored.meta.cwd !== session.header.cwd) throw new Error(`session "${id}" is already persisted at a different cwd (persisted: ${String(stored.meta.cwd)}, live: ${String(session.header.cwd)}) (id collision)`);
-			if (stored.inheritedEventCount !== session.inheritedEventCount) throw new Error(`session "${id}" is already persisted with a different inherited event count (id collision)`);
-			assertVersion(stored.meta);
-			repairReadView(stored.events);
-			const seed = session.snapshotEvents();
-			if (!seedCoversPrefix(seed, stored.events)) throw new Error(`session "${id}" already has a persisted log on disk that does not match this live session (id collision)`);
-			handle = await this.open(id, "write");
-			const suffix = seed.slice(stored.events.length);
-			if (suffix.length > 0) await handle.append(suffix);
-		}
-		const buffered = this.liveBuffers.get(id);
-		if (buffered !== void 0 && buffered.length > 0) {
-			this.liveBuffers.set(id, []);
-			for (const event of buffered) handle.enqueueLive(event, () => {});
-		}
-	}
-};
-function seedCoversPrefix(seed, prefix) {
-	return prefix.length <= seed.length && prefix.every((event, index) => {
-		const seedEvent = seed[index];
-		return seedEvent !== void 0 && JSON.stringify(seedEvent) === JSON.stringify(event);
-	});
-}
-function sessionCountBuckets(events) {
-	const counted = /* @__PURE__ */ new Map();
-	for (const event of events) {
-		if (!COUNTED_EVENT_TYPES.includes(event.type)) continue;
-		const day = localDayKey(event.time);
-		const bucket = counted.get(day) ?? {
-			day,
-			turns: 0,
-			steps: 0,
-			userInputs: 0,
-			toolCalls: 0
-		};
-		addActivityCount(bucket, event.type, 1);
-		counted.set(day, bucket);
-	}
-	return [...counted.values()];
-}
-function sessionUsageBuckets(usageRows) {
-	const counted = /* @__PURE__ */ new Map();
-	for (const row of usageRows) {
-		const provider = row.fProvider ?? "";
-		const model = row.fModel ?? "";
-		const key = `${row.fDay}#${provider}#${model}`;
-		const bucket = counted.get(key) ?? {
-			day: row.fDay,
-			provider,
-			model,
-			inputTokens: 0,
-			outputTokens: 0,
-			cacheReadTokens: 0,
-			reasoningTokens: 0,
-			totalTokens: 0
-		};
-		bucket.inputTokens += row.fInputTokens;
-		bucket.outputTokens += row.fOutputTokens;
-		bucket.cacheReadTokens += row.fCacheReadTokens;
-		bucket.reasoningTokens += row.fReasoningTokens;
-		bucket.totalTokens += row.fTotalTokens;
-		counted.set(key, bucket);
-	}
-	return [...counted.values()];
-}
-function describeError(error) {
-	return error instanceof Error ? error.message : "unknown error";
-}
-function createBackend(config) {
-	if (config.type === "sqlite") return new SqliteBackend({
-		path: config.path,
-		journalMode: config.journalMode ?? "wal",
-		busyTimeout: config.busyTimeout ?? 5e3
-	});
-	const pool = new Pool({ connectionString: config.connectionString });
-	pool.on("error", () => {});
-	return new PostgresBackend(drizzle({ client: pool }), {
-		identityBase: [
-			"postgres",
-			pool.options.host ?? "localhost",
-			String(pool.options.port ?? 5432),
-			pool.options.database ?? "",
-			config.schema ?? "public"
-		].join(":"),
-		schema: config.schema ?? "public",
-		close: () => pool.end()
-	});
-}
-async function appendEventTail(tx, meta, events, anchor, reuse) {
-	let parentId = anchor.parentId;
-	let nextSeq = anchor.nextSeq;
-	const eventRows = [];
-	const usageRows = [];
-	const bridgeRows = [];
-	for (const event of events) {
-		const reusedId = reuse?.get(event.seq);
-		const eventId = reusedId ?? randomUUID();
-		if (reusedId === void 0) {
-			const { kind, role, name, actionId } = eventDimensions(event);
-			const { data, surfaceOp: _surfaceOp, sourceEventSeqs: _sourceEventSeqs, ...envelope } = event;
-			const row = {
-				fEventId: eventId,
-				fParentId: parentId,
-				fType: event.type,
-				fKind: kind,
-				fRole: role,
-				fName: name,
-				fActionId: actionId,
-				fEncoding: EVENT_ENCODING,
-				fData: JSON.stringify({
-					...envelope,
-					data
-				}),
-				fCreatedAt: event.time
-			};
-			eventRows.push(row);
-			const usageRow = usageRowOf(row, meta.origin === "subagent");
-			if (usageRow !== void 0) usageRows.push(usageRow);
-		}
-		const surfaceOp = event.surfaceOp === void 0 ? null : JSON.stringify(event.surfaceOp);
-		bridgeRows.push({
-			fSessionId: meta.id,
-			fEventId: eventId,
-			fSequence: nextSeq,
-			fSurfaceOp: surfaceOp
-		});
-		parentId = eventId;
-		nextSeq++;
-	}
-	if (eventRows.length > 0) await tx.insertEvents(eventRows, usageRows);
-	await tx.insertBridges(bridgeRows);
-	if (events.some((event) => event.type === "session/title")) await tx.refreshTitle(meta.id);
-	return {
-		headEventId: parentId,
-		headSequence: nextSeq - 1,
-		usageRows
-	};
-}
-//#endregion
-//#region src/deletion.ts
-const STATUS_OF_DELETION_ERROR = {
-	SESSION_NOT_FOUND: 404,
-	SESSION_NOT_ARCHIVED: 409,
-	SESSION_LIVE: 409
-};
-function registerSessionDeletion(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_DELETE_PATH,
-			handler: async (req, res) => {
-				const rejection = connection.requestRejection(req);
-				if (rejection !== void 0) {
-					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 = [];
-				for await (const chunk of req) chunks.push(chunk);
-				let envelope;
-				try {
-					envelope = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-				} catch {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "request body is not JSON" }));
-					return;
-				}
-				if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
-					res.writeHead(400, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: "missing sessionId field" }));
-					return;
-				}
-				try {
-					await persistence.deleteSession(envelope.sessionId);
-				} catch (error) {
-					if (error instanceof SessionDeletionError) {
-						res.writeHead(STATUS_OF_DELETION_ERROR[error.code], { "content-type": "application/json" });
-						res.end(JSON.stringify({
-							error: error.message,
-							code: error.code
-						}));
-						return;
-					}
-					res.writeHead(500, { "content-type": "application/json" });
-					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "session deletion failed" }));
-					return;
-				}
-				res.writeHead(200, { "content-type": "application/json" });
-				res.end(JSON.stringify({ deleted: envelope.sessionId }));
-			}
-		}));
-	});
-}
-//#endregion
-export { SessionDeletionError as n, SessionPersistenceRdb as r, registerSessionDeletion as t };