@morlay/session-rdb 0.0.11 → 0.0.13

package/dist/schema-B-8G4lWc.mjs

@@ -0,0 +1,852 @@
+import { SessionSeq, encodeSeqRanges, packChunkRuns } from "@deepseek-ai/dsh-session";
+import { sql } from "drizzle-orm";
+import { check, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import { bigint, check as check$1, index as index$1, integer as integer$1, pgSchema, pgTable, serial, text as text$1, unique as unique$1 } from "drizzle-orm/pg-core";
+//#region src/log.ts
+function rowToMeta(row) {
+	if (!Number.isSafeInteger(row.fCreatedAt) || row.fCreatedAt < 0) throw new Error("stored session createdAt must be a non-negative safe integer");
+	return {
+		version: row.fVersion,
+		id: row.fSessionId,
+		createdAt: row.fCreatedAt,
+		...row.fCwd !== null ? { cwd: row.fCwd } : {},
+		...row.fParentSession !== null ? { parentSession: row.fParentSession } : {},
+		isSeeded: row.fSeedLength !== null,
+		...row.fOrigin !== null ? { origin: row.fOrigin } : {},
+		...row.fDelegationDepth === null ? {} : { delegationDepth: row.fDelegationDepth }
+	};
+}
+function sessionInsertRow(storage, incarnation) {
+	const meta = storage.meta;
+	return {
+		fSessionId: meta.id,
+		fHeadEventId: "",
+		fHeadSequence: -1,
+		fVersion: meta.version,
+		fCreatedAt: meta.createdAt,
+		fCwd: meta.cwd ?? null,
+		fParentSession: meta.parentSession ?? null,
+		fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+		fOrigin: meta.origin ?? null,
+		fDelegationDepth: meta.delegationDepth ?? null,
+		fIncarnation: incarnation,
+		fRevision: 0
+	};
+}
+function sessionConflictRow(storage) {
+	const meta = storage.meta;
+	return {
+		fVersion: meta.version,
+		fCreatedAt: meta.createdAt,
+		fCwd: meta.cwd ?? null,
+		fParentSession: meta.parentSession ?? null,
+		fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+		fOrigin: meta.origin ?? null,
+		fDelegationDepth: meta.delegationDepth ?? null
+	};
+}
+function remapSurfaceOp(op, remap) {
+	if (op === "append") return op;
+	return {
+		op: "replace",
+		start: SessionSeq(remap(op.start)),
+		end: SessionSeq(remap(op.end))
+	};
+}
+function remapShadowedRange(range, remap) {
+	return {
+		start: remap(range.start),
+		end: remap(range.end)
+	};
+}
+function rowToEvent(row, seqMap) {
+	const remap = (seq) => seqMap.get(seq) ?? seq;
+	const surfaceOp = row.fSurfaceOp !== null ? remapSurfaceOp(JSON.parse(row.fSurfaceOp), remap) : void 0;
+	const data = JSON.parse(row.fData);
+	if (row.fType === "compaction/summary" || row.fType === "compaction/prune") {
+		const metering = data;
+		if (metering.shadowedRange !== void 0) metering.shadowedRange = remapShadowedRange(metering.shadowedRange, remap);
+	}
+	return {
+		type: row.fType,
+		seq: row.fSequence,
+		time: row.fCreatedAt,
+		data,
+		...surfaceOp === void 0 ? {} : { surfaceOp }
+	};
+}
+function buildSeqMap(rows) {
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) if (!map.has(row.fOriginalSeq)) map.set(row.fOriginalSeq, row.fSequence);
+	return map;
+}
+const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"user/message",
+	"assistant/message",
+	"tool/result"
+]);
+function recomputeReplaceProvenance(events) {
+	for (const event of events) {
+		const raw = event;
+		const op = raw.surfaceOp;
+		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
+		const { start, end } = op;
+		const refs = [];
+		for (const candidate of events) if (candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type)) refs.push(candidate.seq);
+		raw.sourceEventSeqs = refs;
+	}
+}
+function isEventSeqLike(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
+}
+function isDeepEqualJson(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((item, i) => isDeepEqualJson(item, b[i]));
+	}
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const aKeys = Object.keys(a);
+	const bRecord = b;
+	if (aKeys.length !== Object.keys(bRecord).length) return false;
+	return aKeys.every((key) => Object.hasOwn(bRecord, key) && isDeepEqualJson(a[key], bRecord[key]));
+}
+function toolResultRewriteContentOnly(original, replacement) {
+	const originalData = original.data;
+	const replacementData = replacement.data;
+	const originalMessage = originalData["message"];
+	const replacementMessage = replacementData["message"];
+	const originalContent = Array.isArray(originalMessage?.content) ? originalMessage.content : void 0;
+	const replacementContent = Array.isArray(replacementMessage?.content) ? replacementMessage.content : void 0;
+	if (originalContent === void 0 || replacementContent === void 0) return false;
+	return isDeepEqualJson({
+		...originalData,
+		message: {
+			...originalMessage,
+			content: [{
+				...originalContent[0],
+				content: null
+			}]
+		}
+	}, {
+		...replacementData,
+		message: {
+			...replacementMessage,
+			content: [{
+				...replacementContent[0],
+				content: null
+			}]
+		}
+	});
+}
+function findSurfaceRepairs(events) {
+	const nodes = [];
+	const degradeToAppend = /* @__PURE__ */ new Set();
+	const addAppendMarker = /* @__PURE__ */ new Set();
+	const clearSurfaceOp = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		const op = event.surfaceOp;
+		if (op === void 0) {
+			if (SURFACE_EVENT_TYPES.has(event.type)) {
+				addAppendMarker.add(event.seq);
+				nodes.push(event.seq);
+			}
+			continue;
+		}
+		if (op === "append") {
+			if (SURFACE_EVENT_TYPES.has(event.type)) nodes.push(event.seq);
+			else clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		if (!SURFACE_EVENT_TYPES.has(event.type)) {
+			clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		const replace = typeof op === "object" && op !== null && !Array.isArray(op) ? op : void 0;
+		const start = replace?.["start"];
+		const end = replace?.["end"];
+		const shapeOk = replace !== void 0 && replace["op"] === "replace" && isEventSeqLike(start) && isEventSeqLike(end);
+		const startIdx = shapeOk ? nodes.indexOf(start) : -1;
+		const endIdx = shapeOk ? nodes.indexOf(end) : -1;
+		const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
+		let rewriteOk = true;
+		if (rangeOk && event.type === "tool/result") {
+			const shadowed = nodes.slice(startIdx, endIdx + 1);
+			if (shadowed.length !== 1) rewriteOk = false;
+			else {
+				const original = events[shadowed[0]];
+				rewriteOk = original?.type === "tool/result" && toolResultRewriteContentOnly(original, event);
+			}
+		}
+		if (!rangeOk || !rewriteOk) {
+			degradeToAppend.add(event.seq);
+			nodes.push(event.seq);
+			continue;
+		}
+		nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
+	}
+	return {
+		degradeToAppend,
+		addAppendMarker,
+		clearSurfaceOp
+	};
+}
+function repairSurfaceOps(events) {
+	const repairs = findSurfaceRepairs(events);
+	if (repairs.degradeToAppend.size === 0 && repairs.addAppendMarker.size === 0 && repairs.clearSurfaceOp.size === 0) return;
+	for (const event of events) {
+		const raw = event;
+		if (repairs.degradeToAppend.has(event.seq)) raw.surfaceOp = "append";
+		else if (repairs.addAppendMarker.has(event.seq)) raw.surfaceOp = "append";
+		else if (repairs.clearSurfaceOp.has(event.seq)) delete raw.surfaceOp;
+	}
+}
+/**
+* 定位无法从空状态增量重放的 agent/inbox/spliced 事件（孤儿操作）。
+*
+* 上游 Inbox 每次构造都从会话起点重放全部 inbox splice，失败即拒绝整个
+* 会话（resume / 编辑重放不可用）。rewind 截断历史轮次后若残留 splice 引用
+* 已被截断的排队消息（插入被删、消费保留，或反之），重放时越界或重复——
+* 无法独立重放。
+*/
+function orphanInboxSpliceSeqs(events) {
+	const inbox = {
+		"next-turn": [],
+		"next-step": []
+	};
+	const orphan = /* @__PURE__ */ new Set();
+	for (const raw of events) {
+		const event = raw;
+		if (event.type !== "agent/inbox/spliced") continue;
+		const { target, start, removedCount, inserted } = event.data;
+		const list = typeof target === "string" ? inbox[target] : void 0;
+		if (list === void 0) {
+			orphan.add(event.seq);
+			continue;
+		}
+		const removed = removedCount ?? 0;
+		const parsedInserted = (inserted ?? []).map((m) => ({ id: typeof m.id === "string" ? m.id : "" }));
+		if (!Number.isSafeInteger(start) || start < 0 || start > list.length || !Number.isSafeInteger(removed) || removed < 0 || start + removed > list.length) {
+			orphan.add(event.seq);
+			continue;
+		}
+		const candidate = [
+			...list.slice(0, start),
+			...parsedInserted,
+			...list.slice(start + removed)
+		];
+		const other = (target === "next-turn" ? inbox["next-step"] : inbox["next-turn"]) ?? [];
+		const seen = /* @__PURE__ */ new Set();
+		let dup = false;
+		for (const m of [...candidate, ...other]) {
+			if (m.id === "") continue;
+			if (seen.has(m.id)) {
+				dup = true;
+				break;
+			}
+			seen.add(m.id);
+		}
+		if (dup) {
+			orphan.add(event.seq);
+			continue;
+		}
+		list.splice(start, removed, ...parsedInserted);
+	}
+	return orphan;
+}
+/** 内存修复：把孤儿 inbox splice 改写为 no-op（调用方负责持久化）。 */
+function repairOrphanInboxSplices(events) {
+	const orphan = orphanInboxSpliceSeqs(events);
+	if (orphan.size === 0) return;
+	for (const event of events) {
+		if (!orphan.has(event.seq)) continue;
+		const target = event.data.target;
+		event.data = {
+			...typeof target === "string" ? { target } : { target: "next-turn" },
+			start: 0,
+			removedCount: 0,
+			inserted: []
+		};
+	}
+}
+function scanRows(rows, base = 0, seqMap = /* @__PURE__ */ new Map()) {
+	const parsed = rows.map((row) => {
+		try {
+			return {
+				ok: true,
+				event: rowToEvent(row, seqMap)
+			};
+		} catch {
+			return { ok: false };
+		}
+	});
+	let lastTurnEnd = -1;
+	for (let i = parsed.length - 1; i >= 0; i--) if (parsed[i]?.ok && rows[i]?.fType === "turn/end") {
+		lastTurnEnd = i;
+		break;
+	}
+	const preserved = [];
+	for (let i = 0; i < rows.length; i++) {
+		const p = parsed[i];
+		if (!p?.ok || p.event === void 0) {
+			if (i <= lastTurnEnd) throw new Error(`corrupt session log: unparsable committed event at seq ${rows[i]?.fSequence}`);
+			break;
+		}
+		if (p.event.seq !== base + i) {
+			if (i <= lastTurnEnd) throw new Error(`corrupt session log: seq gap in committed region (expected ${base + i}, got ${p.event.seq})`);
+			break;
+		}
+		preserved.push(p.event);
+	}
+	return preserved.length < rows.length ? {
+		preserved,
+		tornFrom: base + preserved.length
+	} : { preserved };
+}
+function toStorageRecord(record) {
+	const withSeqs = record;
+	if (withSeqs.sourceEventSeqs === void 0) return record;
+	return {
+		...record,
+		sourceEventSeqs: encodeSeqRanges(withSeqs.sourceEventSeqs)
+	};
+}
+function toJsonlArtifact(meta, inheritedEventCount, events) {
+	const header = {
+		type: "session",
+		version: meta.version,
+		id: meta.id,
+		createdAt: meta.createdAt,
+		...meta.cwd === void 0 ? {} : { cwd: meta.cwd },
+		...meta.parentSession === void 0 ? {} : { parentSession: meta.parentSession },
+		...meta.isSeeded ? { seedLength: inheritedEventCount } : {},
+		...meta.origin === void 0 ? {} : { origin: meta.origin },
+		delegationDepth: meta.delegationDepth ?? 0,
+		...meta.agentPreset === void 0 ? {} : { agentPreset: meta.agentPreset }
+	};
+	const lines = [JSON.stringify(header)];
+	for (const record of packChunkRuns(events)) lines.push(JSON.stringify(toStorageRecord(record)));
+	return lines.join("\n");
+}
+//#endregion
+//#region src/entities/types.ts
+function toProperty(name) {
+	return name.replace(/_([a-z])/g, (_match, char) => char.toUpperCase());
+}
+//#endregion
+//#region src/adapters/to-sqlite.ts
+function buildColumn$1(c, tables) {
+	let col;
+	switch (c.type) {
+		case "text":
+			col = text(c.name);
+			break;
+		case "serial":
+			col = integer(c.name).primaryKey({ autoIncrement: true });
+			break;
+		case "integer":
+		case "bigint": {
+			const built = integer(c.name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+	}
+	if (c.notNull) col = col.notNull();
+	if (c.default !== void 0) col = col.default(c.default);
+	if (c.unique) col = col.unique();
+	if (c.references) {
+		const { table, column, onDelete } = c.references;
+		col = col.references(() => tables[table][toProperty(column)], { onDelete });
+	}
+	return col;
+}
+function toSqliteSchema(defs) {
+	const tables = {};
+	for (const def of defs) {
+		const columns = {};
+		for (const c of def.columns) columns[toProperty(c.name)] = buildColumn$1(c, tables);
+		const extra = (self) => [
+			...(def.checks ?? []).map((c) => check(c.name, sql.raw(c.expression))),
+			...(def.uniques ?? []).map((u) => unique(u.name).on(...u.columns.map((name) => self[toProperty(name)]))),
+			...(def.indexes ?? []).map((i) => index(i.name).on(...i.columns.map((name) => self[toProperty(name)])))
+		];
+		tables[def.name] = sqliteTable(def.name, columns, extra);
+	}
+	return tables;
+}
+//#endregion
+//#region src/adapters/to-postgres.ts
+function buildColumn(c, tables) {
+	let col;
+	switch (c.type) {
+		case "text":
+			col = text$1(c.name);
+			break;
+		case "serial":
+			col = serial(c.name).primaryKey();
+			break;
+		case "integer": {
+			const built = integer$1(c.name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+		case "bigint": {
+			const built = bigint(c.name, { mode: "number" });
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+	}
+	if (c.notNull) col = col.notNull();
+	if (c.default !== void 0) col = col.default(c.default);
+	if (c.unique) col = col.unique();
+	if (c.references) {
+		const { table, column, onDelete } = c.references;
+		col = col.references(() => tables[table][toProperty(column)], { onDelete });
+	}
+	return col;
+}
+function toPostgresSchema(defs, schemaName = "public") {
+	const tables = {};
+	const table = schemaName === "public" ? pgTable : pgSchema(schemaName).table;
+	for (const def of defs) {
+		const columns = {};
+		for (const c of def.columns) columns[toProperty(c.name)] = buildColumn(c, tables);
+		const extra = (self) => [
+			...(def.checks ?? []).map((c) => check$1(c.name, sql.raw(c.expression))),
+			...(def.uniques ?? []).map((u) => unique$1(u.name).on(...u.columns.map((name) => self[toProperty(name)]))),
+			...(def.indexes ?? []).map((i) => index$1(i.name).on(...i.columns.map((name) => self[toProperty(name)])))
+		];
+		tables[def.name] = table(def.name, columns, extra);
+	}
+	return tables;
+}
+//#endregion
+//#region src/entities/persistence-state.ts
+const persistenceState = {
+	name: "t_persistence_state",
+	columns: [{
+		name: "f_singleton",
+		type: "integer",
+		primaryKey: true
+	}, {
+		name: "f_store_id",
+		type: "text",
+		notNull: true
+	}],
+	checks: [{
+		name: "ck_persistence_state_singleton",
+		expression: "f_singleton = 1"
+	}]
+};
+//#endregion
+//#region src/entities/schema-meta.ts
+const schemaMeta = {
+	name: "t_schema_meta",
+	columns: [{
+		name: "f_key",
+		type: "text",
+		primaryKey: true
+	}, {
+		name: "f_value",
+		type: "text",
+		notNull: true
+	}]
+};
+//#endregion
+//#region src/entities/sessions.ts
+const sessions = {
+	name: "t_sessions",
+	columns: [
+		{
+			name: "f_id",
+			type: "serial",
+			primaryKey: true
+		},
+		{
+			name: "f_session_id",
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		{
+			name: "f_head_event_id",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_head_sequence",
+			type: "integer",
+			notNull: true,
+			default: -1
+		},
+		{
+			name: "f_version",
+			type: "integer",
+			notNull: true
+		},
+		{
+			name: "f_created_at",
+			type: "bigint",
+			notNull: true
+		},
+		{
+			name: "f_cwd",
+			type: "text"
+		},
+		{
+			name: "f_parent_session",
+			type: "text"
+		},
+		{
+			name: "f_seed_length",
+			type: "integer"
+		},
+		{
+			name: "f_origin",
+			type: "text"
+		},
+		{
+			name: "f_delegation_depth",
+			type: "integer"
+		},
+		{
+			name: "f_incarnation",
+			type: "text",
+			notNull: true
+		},
+		{
+			name: "f_revision",
+			type: "integer",
+			notNull: true
+		}
+	]
+};
+//#endregion
+//#region src/entities/events.ts
+const events = {
+	name: "t_events",
+	columns: [
+		{
+			name: "f_id",
+			type: "serial",
+			primaryKey: true
+		},
+		{
+			name: "f_event_id",
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		{
+			name: "f_parent_id",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_type",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_kind",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_role",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_name",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_action_id",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_encoding",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_data",
+			type: "text",
+			notNull: true
+		},
+		{
+			name: "f_created_at",
+			type: "bigint",
+			notNull: true,
+			default: 0
+		}
+	],
+	indexes: [
+		{
+			name: "idx_events_kind",
+			columns: ["f_kind"]
+		},
+		{
+			name: "idx_events_role",
+			columns: ["f_role"]
+		},
+		{
+			name: "idx_events_name",
+			columns: ["f_name"]
+		},
+		{
+			name: "idx_events_action_id",
+			columns: ["f_action_id"]
+		}
+	]
+};
+//#endregion
+//#region src/entities/session-events.ts
+const sessionEvents = {
+	name: "t_session_events",
+	columns: [
+		{
+			name: "f_id",
+			type: "serial",
+			primaryKey: true
+		},
+		{
+			name: "f_session_id",
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		{
+			name: "f_event_id",
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_events",
+				column: "f_event_id",
+				onDelete: "cascade"
+			}
+		},
+		{
+			name: "f_sequence",
+			type: "integer",
+			notNull: true
+		},
+		{
+			name: "f_original_seq",
+			type: "integer",
+			notNull: true
+		},
+		{
+			name: "f_surface_op",
+			type: "text"
+		}
+	],
+	uniques: [{
+		name: "uq_session_events_session_sequence",
+		columns: ["f_session_id", "f_sequence"]
+	}],
+	indexes: [{
+		name: "idx_session_events_event_id",
+		columns: ["f_event_id"]
+	}]
+};
+//#endregion
+//#region src/entities/index.ts
+const sqliteTableDefs = [
+	persistenceState,
+	sessions,
+	events,
+	sessionEvents
+];
+const postgresTableDefs = [
+	persistenceState,
+	schemaMeta,
+	sessions,
+	events,
+	sessionEvents
+];
+//#endregion
+//#region src/schema.ts
+const SCHEMA_VERSION = 2;
+const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+const EPHEMERAL_EVENT_TYPES = ["assistant/chunk"];
+const EVENT_ENCODING = "json";
+const sqliteTables = toSqliteSchema(sqliteTableDefs);
+const tPersistenceState = sqliteTables["t_persistence_state"];
+const tSessions = sqliteTables["t_sessions"];
+const tEvents = sqliteTables["t_events"];
+const tSessionEvents = sqliteTables["t_session_events"];
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+function isEphemeralType(type) {
+	return EPHEMERAL_EVENT_TYPES.includes(type);
+}
+function isPersistedEvent(event) {
+	return !isEphemeralType(event.type) && event.ignorable !== true;
+}
+function eventKind(event) {
+	switch (event.type) {
+		case "user/message": return "message";
+		case "assistant/message":
+			if ((event.data.message?.content)?.some((block) => block?.type === "reasoning")) return "thinking";
+			return "message";
+		case "turn/start":
+		case "turn/end":
+		case "step/start":
+		case "step/end":
+		case "session/end-seed": return "turn";
+		case "tool/call":
+		case "tool/result":
+		case "tool/code-dispatch-start":
+		case "tool/code-dispatch": return "tool";
+		case "request/header":
+		case "request/context": return "request";
+		case "model/selection":
+		case "permission/preset":
+		case "approval/policy":
+		case "sandbox/mode":
+		case "plan/mode":
+		case "agent-preset/selected": return "config";
+		case "approval/asked":
+		case "approval/decided":
+		case "command/run":
+		case "command/done":
+		case "hook/invoked":
+		case "hook/result":
+		case "feedback/record": return "audit";
+		case "session/title":
+		case "session/title-llm-request":
+		case "session-log-deepseek/delivery-accepted": return "lifecycle";
+		case "agent/inbox/spliced": return "inbox";
+		case "compaction/start":
+		case "compaction/end":
+		case "compaction/summary":
+		case "compaction/prune": return "compaction";
+		case "llm/retry":
+		case "llm/retry-started": return "llm";
+		case "subagent/descriptor":
+		case "subagent/model-selection-policy": return "subagent";
+		case "team/member":
+		case "team/task":
+		case "team/message/queued":
+		case "team/message/delivered": return "team";
+		case "tool-workflow/run-start":
+		case "tool-workflow/run-end":
+		case "tool-workflow/agent-start":
+		case "tool-workflow/agent-end": return "workflow";
+		case "goal/change": return "goal";
+		case "schedule/change": return "schedule";
+		case "todo/write": return "todo";
+		case "web/deepseek-search-llm-request": return "web";
+		default: return "";
+	}
+}
+function eventDimensions(event) {
+	const kind = eventKind(event);
+	const type = event.type;
+	const data = event.data;
+	switch (type) {
+		case "user/message": return {
+			kind,
+			role: "user",
+			name: "",
+			actionId: ""
+		};
+		case "assistant/message": return {
+			kind,
+			role: "assistant",
+			name: "",
+			actionId: ""
+		};
+		case "tool/result": return {
+			kind,
+			role: "tool",
+			name: "",
+			actionId: data["message"]?.content?.[0]?.toolCallId ?? ""
+		};
+		case "tool/call": return {
+			kind,
+			role: "",
+			name: typeof data["name"] === "string" ? data["name"] : "",
+			actionId: typeof data["callId"] === "string" ? data["callId"] : ""
+		};
+		case "tool/code-dispatch-start":
+		case "tool/code-dispatch": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["subCallId"] === "string" ? data["subCallId"] : ""
+		};
+		case "command/run":
+		case "command/done": return {
+			kind,
+			role: "",
+			name: type === "command/run" && typeof data["name"] === "string" ? data["name"] : "",
+			actionId: typeof data["commandId"] === "string" ? data["commandId"] : ""
+		};
+		case "approval/asked":
+		case "approval/decided": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["id"] === "string" ? data["id"] : ""
+		};
+		case "hook/invoked":
+		case "hook/result": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["handlerId"] === "string" ? data["handlerId"] : ""
+		};
+		case "llm/retry":
+		case "llm/retry-started": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["retryId"] === "string" ? data["retryId"] : ""
+		};
+		case "tool-workflow/run-start":
+		case "tool-workflow/run-end":
+		case "tool-workflow/agent-start":
+		case "tool-workflow/agent-end": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["runId"] === "string" ? data["runId"] : ""
+		};
+		case "todo/write": return {
+			kind,
+			role: "",
+			name: "todos",
+			actionId: ""
+		};
+		case "subagent/descriptor": return {
+			kind,
+			role: "",
+			name: typeof data["label"] === "string" ? data["label"] : "",
+			actionId: ""
+		};
+		default: return {
+			kind,
+			role: "",
+			name: "",
+			actionId: ""
+		};
+	}
+}
+//#endregion
+export { toJsonlArtifact as A, repairOrphanInboxSplices as C, scanRows as D, rowToMeta as E, sessionConflictRow as O, remapSurfaceOp as S, rowToEvent as T, buildSeqMap as _, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as a, recomputeReplaceProvenance as b, isEphemeralType as c, tPersistenceState as d, tSessionEvents as f, toPostgresSchema as g, sqliteTableDefs as h, SCHEMA_VERSION as i, sessionInsertRow as k, isPersistedEvent as l, postgresTableDefs as m, EPHEMERAL_EVENT_TYPES as n, eventDimensions as o, tSessions as p, EVENT_ENCODING as r, eventKind as s, DEFAULT_BUSY_TIMEOUT_MS as t, tEvents as u, findSurfaceRepairs as v, repairSurfaceOps as w, remapShadowedRange as x, orphanInboxSpliceSeqs as y };