@morlay/session-rdb 0.1.1 → 0.1.3

package/dist/rolldown-runtime-EAsCxrDo.mjs

@@ -0,0 +1,14 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as n, __commonJSMin as t };

package/dist/routes-DGBlBE_I.mjs

@@ -0,0 +1,10 @@
+//#region src/routes.ts
+const MORLAY_SESSION_API_PREFIX = "/api/morlay/v1/session";
+const SESSION_ROWS_PATH = `${MORLAY_SESSION_API_PREFIX}/rows`;
+const SESSION_EXPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/export`;
+const SESSION_IMPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/import`;
+const SESSION_DELETE_PATH = `${MORLAY_SESSION_API_PREFIX}/delete`;
+const SESSION_GC_PATH = `${MORLAY_SESSION_API_PREFIX}/gc`;
+const SESSION_USAGE_PATH = `${MORLAY_SESSION_API_PREFIX}/usage`;
+//#endregion
+export { SESSION_ROWS_PATH as a, SESSION_IMPORT_PATH as i, SESSION_EXPORT_PATH as n, SESSION_USAGE_PATH as o, SESSION_GC_PATH as r, SESSION_DELETE_PATH as t };

package/dist/{sqlite-SCiSnwaz.mjs → sqlite-YCr2-Fov.mjs}

@@ -1,5 +1,5 @@
 import { COUNTED_EVENT_TYPES, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey } from "./usage.mjs";
-import { _ as sessionConflictRow, b as titleOfEventData, v as sessionInsertRow } from "./log-BWVFYAh5.mjs";
+import { _ as sessionConflictRow, b as titleOfEventData, v as sessionInsertRow } from "./log-DYxdjJ-l.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
 import { and, desc, eq, gte, inArray, isNotNull, lt, notInArray, sql } from "drizzle-orm";
@@ -17,7 +17,6 @@ var WriteGuard = class {
 	confirmHead(id, head) {
 		this.headSeqs.set(id, head);
 	}
-	/** 本实例有没有这条会话的 head 记录（迁移重写用它决定是"登记基准"还是"严格比较"）。 */
 	has(id) {
 		return this.headSeqs.has(id);
 	}
@@ -452,12 +451,6 @@ const sessionProjcacheRows = {
 };
 //#endregion
 //#region src/entities/v3/event-usage.ts
-/**
-* 用量日志：一条 `assistant/message` 事件一行（按事件行唯一，fork 共享行不重复）。
-* 读侧维度全部物化在行上——本地日、是否被会话引用、是否被子代理会话引用——统计因此不做
-* `EXISTS` 判定、也不回连事件表；事件行本身仍留在 `t_events`。
-* 取舍见 ADR-统计衍生表物化归属与汇总。
-*/
 const eventUsage = {
 	name: "t_event_usage",
 	columns: {
@@ -520,11 +513,6 @@ const eventUsage = {
 };
 //#endregion
 //#region src/entities/v3/session-usage.ts
-/**
-* 会话 × 本地日 × 模型的 token 汇总（派生统计表）：**按会话的行**读它，因此保住
-* 「fork 子会话含继承前缀」的口径（各会话行之和 ≥ 总量）而不回连事件表。
-* 旁路累加、可按会话重建，读侧只读；取舍见 ADR-统计衍生表物化归属与汇总。
-*/
 const sessionUsage = {
 	name: "t_session_usage",
 	columns: {
@@ -586,11 +574,6 @@ const sessionUsage = {
 };
 //#endregion
 //#region src/entities/v3/session-counts.ts
-/**
-* 会话 × 本地日的活动计数（派生统计表）：轮次 / 步骤 / 用户输入 / 工具调用四列直接读，
-* 不再存事件类型、也不在读取时折。旁路累加、可按会话重建，读侧只读；
-* 取舍见 ADR-统计衍生表物化归属与汇总。
-*/
 const sessionCounts = {
 	name: "t_session_counts",
 	columns: {
@@ -1096,22 +1079,16 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region src/sqlite.ts
-/** 用量行的「被引用」物化表达式（`%EVENT%` 换成事件 id 列）。 */
 const EVENT_REFERENCED_SQL = `EXISTS (SELECT 1 FROM t_session_events rb
                                        WHERE rb.f_event_id = %EVENT%)`;
-/** 用量行的「被 subagent 会话引用」物化表达式（`%EVENT%` 换成事件 id 列）。 */
 const EVENT_SUBAGENT_SQL = `EXISTS (SELECT 1 FROM t_session_events sb
                                      JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
                                     WHERE sb.f_event_id = %EVENT% AND ss.f_origin = 'subagent')`;
-/** `IN (...)` 用的类型字面量（与 `COUNTED_EVENT_TYPES` 同源）。 */
 const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
+const REFRESH_FLAG_CHUNK = 400;
 function withEvent(expression, column) {
 	return expression.replace("%EVENT%", column);
 }
-/**
-* 派生统计表的回填：任一表为空即按事件表全量重算（幂等；迁移删表重建后、手动清空后都靠它自愈）。
-* 顺序有依赖：用量行（带物化列）先落，两张会话汇总表再从它 / 事件表重算。
-*/
 function backfillUsageTables(db) {
 	backfillEventUsage(db);
 	backfillSessionUsage(db);
@@ -1120,7 +1097,6 @@ function backfillUsageTables(db) {
 function tableIsEmpty(db, table) {
 	return db.prepare(`SELECT count(*) AS n FROM ${table}`).get().n === 0;
 }
-/** 用量行：一条 `assistant/message` 事件行一行，物化本地日与两个归属标记。 */
 function backfillEventUsage(db) {
 	if (!tableIsEmpty(db, "t_event_usage")) return;
 	db.exec(`INSERT OR IGNORE INTO t_event_usage (
@@ -1149,7 +1125,6 @@ function backfillEventUsage(db) {
        AND (json_extract(e.f_data, '$.data.usage') IS NOT NULL
             OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
 }
-/** 会话 × 本地日 × 模型的 token 汇总：从桥接行 × 用量行重算（含 fork 继承前缀）。 */
 function backfillSessionUsage(db) {
 	if (!tableIsEmpty(db, "t_session_usage")) return;
 	db.exec(`INSERT OR IGNORE INTO t_session_usage (
@@ -1162,7 +1137,6 @@ function backfillSessionUsage(db) {
       JOIN t_event_usage u ON u.f_event_id = b.f_event_id
      GROUP BY b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, '')`);
 }
-/** 会话 × 本地日的活动计数：从桥接行 × 事件类型重算。 */
 function backfillSessionCounts(db) {
 	if (!tableIsEmpty(db, "t_session_counts")) return;
 	db.exec(`INSERT OR IGNORE INTO t_session_counts (
@@ -1191,7 +1165,6 @@ function sessionListRowOf(row) {
 		workspace: typeof row["workspace"] === "string" ? row["workspace"] : null
 	};
 }
-/** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
 function tokenTotalsOf(row) {
 	return {
 		inputTokens: row.input_tokens ?? 0,
@@ -1201,7 +1174,6 @@ function tokenTotalsOf(row) {
 		totalTokens: row.total_tokens ?? 0
 	};
 }
-/** `t_session_counts` 的原始行（列名是 SQL 别名）折成四项活动计数。 */
 function activityTotalsOf(row) {
 	return {
 		turns: row.turns ?? 0,
@@ -1210,7 +1182,6 @@ function activityTotalsOf(row) {
 		toolCalls: row.tool_calls ?? 0
 	};
 }
-/** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
 function emptyActivity() {
 	return {
 		turns: 0,
@@ -1219,7 +1190,6 @@ function emptyActivity() {
 		toolCalls: 0
 	};
 }
-/** 有 token 用量的会话：活动计数与列表都限定在这一批会话里，口径一致（读汇总表，几百行）。 */
 function hasUsageSession(column) {
 	return `EXISTS (SELECT 1 FROM t_session_usage ub WHERE ub.f_session_id = ${column})`;
 }
@@ -1482,7 +1452,7 @@ var SqliteBackend = class SqliteBackend {
 		}).where(eq(tSessions.fSessionId, id)).run();
 	}
 	async deleteBridgeTail(id, fromSequence) {
-		this.db.delete(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence))).run();
+		return this.db.$client.prepare("DELETE FROM t_session_events WHERE f_session_id = ? AND f_sequence >= ? RETURNING f_event_id").all(id, fromSequence).map((row) => row.f_event_id);
 	}
 	async getPrevBridge(id, sequence) {
 		return this.db.select({
@@ -1491,19 +1461,18 @@ var SqliteBackend = class SqliteBackend {
 		}).from(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get();
 	}
 	async deleteSession(id) {
-		this.db.delete(tSessionEvents).where(eq(tSessionEvents.fSessionId, id)).run();
+		const rows = this.db.$client.prepare("DELETE FROM t_session_events WHERE f_session_id = ? RETURNING f_event_id").all(id);
 		this.db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fSessionId, id)).run();
 		this.db.delete(tSessionProjcacheRows).where(eq(tSessionProjcacheRows.fSessionId, id)).run();
 		this.db.delete(tSessions).where(eq(tSessions.fSessionId, id)).run();
+		return rows.map((row) => row.f_event_id);
 	}
-	/** 事件行可能被多个会话共享（fork 派生），所以孤儿只能在全库范围内判定。 */
 	async collectOrphans() {
 		const referenced = this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents);
 		const info = this.db.delete(tEvents).where(notInArray(tEvents.fEventId, referenced)).run();
 		this.db.delete(tEventUsage).where(notInArray(tEventUsage.fEventId, this.db.select({ fEventId: tEvents.fEventId }).from(tEvents))).run();
 		return Number(info.changes);
 	}
-	/** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
 	async listOrphanSubagentSessions() {
 		return this.db.$client.prepare(`SELECT f_session_id AS id FROM t_sessions
          WHERE f_origin = 'subagent'
@@ -1511,18 +1480,20 @@ var SqliteBackend = class SqliteBackend {
                 OR f_parent_session NOT IN (SELECT f_session_id FROM t_sessions))`).all().map((row) => row.id);
 	}
 	async deleteSessions(ids) {
-		if (ids.length === 0) return 0;
-		this.db.delete(tSessionEvents).where(inArray(tSessionEvents.fSessionId, ids)).run();
+		if (ids.length === 0) return {
+			deleted: 0,
+			eventIds: []
+		};
+		const placeholders = ids.map(() => "?").join(", ");
+		const rows = this.db.$client.prepare(`DELETE FROM t_session_events WHERE f_session_id IN (${placeholders}) RETURNING f_event_id`).all(...ids);
 		this.db.delete(tWorkspaceSessions).where(inArray(tWorkspaceSessions.fSessionId, ids)).run();
 		this.db.delete(tSessionProjcacheRows).where(inArray(tSessionProjcacheRows.fSessionId, ids)).run();
 		const info = this.db.delete(tSessions).where(inArray(tSessions.fSessionId, ids)).run();
-		return Number(info.changes);
+		return {
+			deleted: Number(info.changes),
+			eventIds: rows.map((row) => row.f_event_id)
+		};
 	}
-	/**
-	* 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
-	* 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
-	* `f_created_at`（同一时刻写入，口径一致）。
-	*/
 	async listSessionRows(query = {}) {
 		const needle = query.query?.trim().toLowerCase() ?? "";
 		const like = `%${needle}%`;
@@ -1562,12 +1533,6 @@ var SqliteBackend = class SqliteBackend {
 			total: Number(counted.n)
 		};
 	}
-	/**
-	* 用量聚合：只读三张派生统计表——事件级用量行给去重口径的总量与「天 × 模型」桶，
-	* `t_session_usage` / `t_session_counts` 给按会话的行（含 fork 继承前缀）。
-	* 归属、本地日与「是否被引用」都是物化列，这里不再现算、也不回连事件表。
-	* 事件级按毫秒时间戳过滤、汇总表按本地日过滤——`sinceMs` 对齐到本地零点时两者等价。
-	*/
 	async usageReport(sinceMs) {
 		const usageSince = sinceMs === void 0 ? "" : " AND f_created_at >= ?";
 		const params = sinceMs === void 0 ? [] : [sinceMs];
@@ -1653,7 +1618,6 @@ var SqliteBackend = class SqliteBackend {
 			}))
 		};
 	}
-	/** token 用量旁路累加：派生表 `t_session_usage`，不在写事务里（失败可丢，表可销毁重建）。 */
 	async incrementSessionUsage(id, buckets) {
 		if (buckets.length === 0) return;
 		const statement = this.db.$client.prepare(`INSERT INTO t_session_usage (f_session_id, f_day, f_provider, f_model,
@@ -1667,7 +1631,6 @@ var SqliteBackend = class SqliteBackend {
          f_total_tokens = f_total_tokens + excluded.f_total_tokens`);
 		for (const bucket of buckets) statement.run(id, bucket.day, bucket.provider ?? "", bucket.model ?? "", bucket.inputTokens, bucket.outputTokens, bucket.cacheReadTokens, bucket.reasoningTokens, bucket.totalTokens);
 	}
-	/** 活动计数旁路累加：派生表 `t_session_counts`，同上（四项计数一次落）。 */
 	async incrementSessionCounts(id, buckets) {
 		if (buckets.length === 0) return;
 		const statement = this.db.$client.prepare(`INSERT INTO t_session_counts (f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
@@ -1679,7 +1642,6 @@ var SqliteBackend = class SqliteBackend {
          f_tool_calls = f_tool_calls + excluded.f_tool_calls`);
 		for (const bucket of buckets) statement.run(id, bucket.day, bucket.turns, bucket.steps, bucket.userInputs, bucket.toolCalls);
 	}
-	/** 按会话重算两张汇总表（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
 	async rebuildSessionStats(id) {
 		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
 		this.db.$client.prepare(`INSERT INTO t_session_usage (
@@ -1706,15 +1668,15 @@ var SqliteBackend = class SqliteBackend {
           WHERE b.f_session_id = ? AND e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
           GROUP BY b.f_session_id, 2`).run(id);
 	}
-	/**
-	* 全量重算用量行的引用标记：rewind 截断 / fork 复用 / 会话删除都会让「引用」跨会话变化，
-	* 只按本会话判定不够。低频路径，一次全表 UPDATE（3 万行量级）。
-	*/
-	async refreshEventUsageFlags() {
-		const eventId = "t_event_usage.f_event_id";
-		this.db.$client.exec(`UPDATE t_event_usage SET
-         f_referenced = ${withEvent(EVENT_REFERENCED_SQL, eventId)},
-         f_subagent = ${withEvent(EVENT_SUBAGENT_SQL, eventId)}`);
+	async refreshEventUsageFlags(eventIds) {
+		for (let at = 0; at < eventIds.length; at += REFRESH_FLAG_CHUNK) {
+			const chunk = eventIds.slice(at, at + REFRESH_FLAG_CHUNK);
+			const placeholders = chunk.map(() => "?").join(", ");
+			this.db.$client.prepare(`UPDATE t_event_usage SET
+             f_referenced = ${withEvent(EVENT_REFERENCED_SQL, "f_event_id")},
+             f_subagent = ${withEvent(EVENT_SUBAGENT_SQL, "f_event_id")}
+           WHERE f_event_id IN (${placeholders})`).run(...chunk);
+		}
 	}
 	async deleteSessionStats(id) {
 		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);