@morlay/session-rdb 0.1.5 → 0.1.6

package/dist/log-C0q5svm7.d.mts

@@ -0,0 +1,594 @@
+import { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { SessionAccess, SessionHandle, SessionHandleAppendOptions, SessionHandleFlushOptions, SessionHandleReadOptions, SessionHandleReadResult, SessionPersistence, SessionPersistenceCreateOptions, SessionPersistenceListOptions, SessionPersistenceOpenOptions, SessionPersistenceRevision, SessionPersistenceSnapshot, SessionPersistenceStatOptions, SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import { ScheduleTask } from "@deepseek-ai/dsh-schedule";
+import { CheckpointIdentity } from "@deepseek-ai/dsh-session-projection-cache";
+import { ProjectionCheckpoint } from "@deepseek-ai/dsh-session-projection";
+import { WorkspaceDomainState, WorkspaceRecord } from "@deepseek-ai/dsh-workspace";
+import { Context } from "@deepseek-ai/cordis";
+import { Volatile } from "@deepseek-ai/cosmokit";
+import z from "@deepseek-ai/schemastery";
+import { BranchAnchorMode, BranchBoundary, ForkFromOptions, SessionBranch, SessionBranchProvider } from "@morlay/session-branch";
+//#region src/storage-takeover/types.d.ts
+interface StoredProjcacheEntry {
+  sessionId: SessionId;
+  identity: CheckpointIdentity;
+  rows: ProjectionCheckpoint;
+}
+interface StorageRepository {
+  readUnitVersion(name: string): Promise<number | undefined>;
+  insertUnitVersion(name: string, version: number): Promise<void>;
+  listWorkspaces(): Promise<Array<{
+    id: string;
+    record: WorkspaceRecord;
+  }>>;
+  putWorkspace(id: string, record: WorkspaceRecord): Promise<void>;
+  deleteWorkspace(id: string): Promise<void>;
+  readWorkspaceState(): Promise<WorkspaceDomainState | null>;
+  writeWorkspaceState(state: WorkspaceDomainState): Promise<void>;
+  listScheduleTasks(): Promise<Array<{
+    id: string;
+    task: ScheduleTask;
+  }>>;
+  putScheduleTask(id: string, task: ScheduleTask): Promise<void>;
+  deleteScheduleTask(id: string): Promise<void>;
+  loadProjcache(): Promise<StoredProjcacheEntry[]>;
+  readProjcacheDirect?(sessionId: string): StoredProjcacheEntry | undefined;
+  readSessionTitleDirect?(sessionId: string): {
+    title: string;
+    seq: number;
+  } | undefined;
+  putProjcache(sessionId: string, rows: ProjectionCheckpoint): Promise<void>;
+  pruneStaleProjcache(): Promise<number>;
+}
+//#endregion
+//#region src/routes.d.ts
+declare const SESSION_ROWS_PATH = "/api/morlay/v1/session/rows";
+declare const SESSION_EXPORT_PATH = "/api/morlay/v1/session/export";
+declare const SESSION_IMPORT_PATH = "/api/morlay/v1/session/import";
+declare const SESSION_DELETE_PATH = "/api/morlay/v1/session/delete";
+declare const SESSION_GC_PATH = "/api/morlay/v1/session/gc";
+declare const SESSION_USAGE_PATH = "/api/morlay/v1/session/usage";
+//#endregion
+//#region src/write-guard.d.ts
+declare class WriteGuard {
+  private readonly headSeqs;
+  confirmHead(id: SessionId, head: number): void;
+  has(id: SessionId): boolean;
+  assertNoConcurrentWriter(id: SessionId, storedHead: number): void;
+}
+//#endregion
+//#region src/schema.d.ts
+declare const SCHEMA_VERSION = 3;
+declare const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+declare const EVENT_ENCODING = "json";
+declare const tPersistenceState: any;
+declare const tSchemaMeta: any;
+declare const tSessions: any;
+declare const tEvents: any;
+declare const tSessionEvents: any;
+declare const tStorageUnits: any;
+declare const tWorkspaces: any;
+declare const tWorkspaceSessions: any;
+declare const tWorkspaceState: any;
+declare const tScheduleTasks: any;
+declare const tSessionProjcacheRows: any;
+declare const tEventUsage: any;
+declare const tSessionUsage: any;
+declare const tSessionCounts: any;
+type JournalMode = "wal" | "delete" | "truncate" | "persist";
+declare const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+type EventKind = "message" | "thinking" | "turn" | "tool" | "request" | "config" | "audit" | "lifecycle" | "inbox" | "compaction" | "llm" | "subagent" | "team" | "workflow" | "goal" | "schedule" | "todo" | "web";
+type EventRole = "user" | "assistant" | "tool";
+declare function eventKind(event: {
+  type: string;
+  data?: unknown;
+}): EventKind | "";
+declare function eventDimensions(event: SessionEvent): {
+  kind: string;
+  role: string;
+  name: string;
+  actionId: string;
+};
+//#endregion
+//#region src/rows.d.ts
+interface SessionRowsItem {
+  sessionId: string;
+  title: string | null;
+  origin: string | null;
+  cwd: string | null;
+  createdAt: number;
+  updatedAt: number;
+  archived: boolean;
+  workspace: string | null;
+}
+interface SessionRowsValue {
+  items: SessionRowsItem[];
+  total: number;
+  page: number;
+  pageSize: number;
+}
+//#endregion
+//#region src/branch.d.ts
+declare function locateTurnEnd(events: readonly SessionEvent[], atSeq?: number, mode?: BranchAnchorMode): number;
+interface LiveSessionHooks {
+  getSession(id: SessionId): Session | undefined;
+  getAgent(id: SessionId): LiveAgentLike | undefined;
+  flush(session: Session): Promise<boolean>;
+  warn?(message: string): void;
+  resetProjections?(session: Session): void;
+  resetTokenMeter?(session: Session): void;
+  refreshProjectionCache?(session: ProjectionCacheSession): Promise<void>;
+}
+interface ProjectionCacheSession {
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly inheritedEventCount: SessionLogOffset;
+  readonly headSeq?: number;
+  snapshotEvents(): readonly SessionEvent[];
+}
+interface LiveAgentLike {
+  session: Session;
+  requestHeaderLogged?: boolean;
+  inbox?: {
+    clear(): void;
+  };
+}
+declare function truncateLiveSession(session: Session, newLength: number): void;
+declare class SessionBranchRdbProvider implements SessionBranchProvider {
+  private readonly persistence;
+  private readonly live;
+  readonly name = "session-rdb";
+  constructor(persistence: SessionPersistenceRdb, live?: LiveSessionHooks);
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+  private rewindKeepLength;
+  private refreshProjectionCache;
+}
+declare class SessionBranchRdb extends SessionBranch {
+  static inject: string[];
+  private readonly warned;
+  constructor(ctx: import("@deepseek-ai/cordis").Context);
+  resetLiveDerivedState(session: Session): void;
+  private warnOnce;
+  private resetProjectionCells;
+  private resetTokenMeterFold;
+  private readonly provider;
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
+  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    events: readonly SessionEvent[];
+  }>;
+  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
+}
+//#endregion
+//#region src/index.d.ts
+interface SessionPersistenceRdbInternals {
+  readonly backend: Backend;
+  readonly writeGuard: WriteGuard;
+  create(meta: SessionHeader, inheritedEventCount?: number): Promise<SessionHandle>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  load(id: SessionId): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  inspect(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceRevision | undefined>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+  dropReuseEventIds(childId: SessionId): void;
+}
+interface ProjectionCacheOptions {
+  writeEveryEvents?: number;
+  writeIntervalMs?: number;
+}
+type Config = {
+  type: "sqlite";
+  path: string;
+  journalMode?: JournalMode | undefined;
+  busyTimeout?: number | undefined;
+  projectionCache?: ProjectionCacheOptions | undefined;
+} | {
+  type: "postgres";
+  connectionString: string;
+  schema?: string | undefined;
+  projectionCache?: ProjectionCacheOptions | undefined;
+};
+type ResolvedConfig = Volatile<Config>;
+type SessionDeletionErrorCode = "SESSION_NOT_FOUND" | "SESSION_NOT_ARCHIVED" | "SESSION_LIVE";
+declare class SessionDeletionError extends Error {
+  readonly code: SessionDeletionErrorCode;
+  constructor(message: string, code: SessionDeletionErrorCode);
+}
+interface PendingSession {
+  readonly header: SessionHeader;
+  readonly revision: SessionPersistenceRevision;
+  readonly inheritedEventCount: SessionLogOffset;
+  readonly cursor: number;
+  readonly everAppended: boolean;
+}
+declare class RdbBackendTracker {
+  private readonly name;
+  private readonly writers;
+  private readonly pending;
+  private readonly openHandles;
+  private counter;
+  constructor(name: string);
+  registerCreated(header: SessionHeader, inheritedEventCount: SessionLogOffset): void;
+  updatePending(id: SessionId, cursor: number, everAppended: boolean): void;
+  claimWrite(id: SessionId): void;
+  releaseClaim(id: SessionId): void;
+  pendingOf(id: SessionId): PendingSession | undefined;
+  hasPending(id: SessionId): boolean;
+  pendingEntries(): IterableIterator<[SessionId, PendingSession]>;
+  materialized(id: SessionId): void;
+  adopt(handle: RdbSessionHandle): RdbSessionHandle;
+  release(handle: RdbSessionHandle, materialized: boolean): void;
+  writerOf(id: SessionId): RdbSessionHandle | undefined;
+  hasOpenHandle(id: SessionId): boolean;
+  flushAll(): Promise<void>;
+  closeAll(): Promise<void>;
+}
+declare class RdbSessionHandle implements SessionHandle {
+  private readonly persistence;
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly access: SessionAccess;
+  private readonly state;
+  private chain;
+  private closing;
+  private cursor;
+  private materialized;
+  private buffered;
+  private batchTimer;
+  private drainPaused;
+  private draining;
+  private tornTruncateTo;
+  private everAppended;
+  constructor(persistence: SessionPersistenceRdb, id: SessionId, header: SessionHeader, access: SessionAccess, state: {
+    cursor: number;
+    materialized: boolean;
+    inheritedEventCount: SessionLogOffset;
+    tornTruncateTo?: number;
+  });
+  get inheritedEventCount(): SessionLogOffset;
+  get cursorValue(): number;
+  read(offset?: number, length?: number, options?: SessionHandleReadOptions): Promise<SessionHandleReadResult>;
+  append(events: readonly SessionEvent[], options?: SessionHandleAppendOptions): Promise<void>;
+  flush(options?: SessionHandleFlushOptions): Promise<void>;
+  close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  enqueueLive(event: SessionEvent, reportBackgroundFailure: (error: unknown) => void): void;
+  resetAfterRewind(cursor: number, inheritedEventCount?: number): void;
+  drainLive(): Promise<void>;
+  private drainBuffered;
+  private enqueueChain;
+  private run;
+  private assertOpen;
+  static readonly LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
+}
+declare class SessionPersistenceRdb extends SessionPersistence {
+  static inject: string[];
+  static Config: z<Config, ResolvedConfig>;
+  readonly name = "session-rdb";
+  readonly tracker: RdbBackendTracker;
+  private readonly backend;
+  private storeIdentity;
+  private readonly ready;
+  private readonly writeGuard;
+  private readonly reuseEventIds;
+  private readonly liveBuffers;
+  private readonly liveReady;
+  readonly config: Config;
+  constructor(ctx: Context, config: ResolvedConfig, injectedBackend?: Backend);
+  private init;
+  create(header: SessionHeader, options?: SessionPersistenceCreateOptions): Promise<SessionHandle>;
+  open(id: SessionId, access: SessionAccess, options?: SessionPersistenceOpenOptions): Promise<SessionHandle>;
+  flush(): Promise<void>;
+  stat(id: SessionId, options?: SessionPersistenceStatOptions): Promise<SessionPersistenceSnapshot | undefined>;
+  list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
+  deleteSession(id: SessionId, signal?: AbortSignal): Promise<void>;
+  collectOrphans(): Promise<number>;
+  collectOrphanSessions(): Promise<number>;
+  usageReport(sinceMs?: number): Promise<UsageAggregate>;
+  vacuum(): Promise<void>;
+  private unarchiveBeforeDeletion;
+  readRaw(id: SessionId, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    filename: string;
+    content: string;
+  } | undefined>;
+  materializeEmpty(meta: SessionHeader, inheritedEventCount: SessionLogOffset): Promise<void>;
+  appendBatch(meta: SessionHeader, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent[], tornTruncateTo?: number): Promise<boolean>;
+  readLog(id: SessionId, options?: {
+    fromSeq?: number;
+  }, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: SessionEvent[];
+    tornFrom?: number;
+    incarnation: string;
+    revision: number;
+    storedCount: number;
+    migrated: boolean;
+  } | undefined>;
+  private recordSessionStats;
+  rebuildSessionStats(id: SessionId): Promise<void>;
+  private refreshEventUsageFlags;
+  private dropSessionStats;
+  private rewriteMigratedLog;
+  listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
+    inheritedEventCount: number;
+  }>>;
+  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<SessionPersistenceRevision | undefined>;
+  createAndAppend(header: SessionHeader, events: readonly SessionEvent[], inheritedEventCount?: number): Promise<void>;
+  load(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
+  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+    meta: SessionHeader;
+    inheritedEventCount: number;
+    events: readonly SessionEvent[];
+  }>;
+  close(): Promise<void>;
+  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
+  dropReuseEventIds(childId: SessionId): void;
+  internals(): SessionPersistenceRdbInternals;
+  private rowRevision;
+  private readonly liveFailures;
+  private readonly liveDropWarned;
+  private watchLiveReady;
+  private installLiveRouting;
+  private ensureLiveHandle;
+}
+//#endregion
+//#region src/usage.d.ts
+type UsageRangeKey = "all" | "day" | "week" | "7d" | "30d" | "90d";
+declare function resolveUsageSince(range: UsageRangeKey, now: number): number | undefined;
+interface UsageTokenTotals {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  reasoningTokens: number;
+  totalTokens: number;
+}
+interface UsageActivityTotals {
+  turns: number;
+  steps: number;
+  userInputs: number;
+  toolCalls: number;
+}
+interface UsageTotals extends UsageTokenTotals, UsageActivityTotals {}
+interface UsageBucket extends UsageTokenTotals {
+  day: string;
+  provider: string | null;
+  model: string | null;
+  subagent: boolean;
+}
+interface UsageSessionRow extends UsageTotals {
+  sessionId: string;
+  title: string | null;
+  subagent: boolean;
+  archived: boolean;
+}
+interface UsageAggregate {
+  totals: UsageTotals;
+  subagent: UsageTotals;
+  human: UsageTotals;
+  buckets: UsageBucket[];
+  sessions: UsageSessionRow[];
+}
+type SessionUsageReport = UsageAggregate;
+declare const COUNTED_EVENT_TYPES: readonly ["turn/start", "step/start", "user/message", "tool/call"];
+declare function addActivityCount(target: UsageActivityTotals, type: string, count: number): UsageActivityTotals;
+declare function localDayKey(ms: number): string;
+declare function emptyTotals(): UsageTotals;
+declare function addTokenTotals(target: UsageTokenTotals, row: UsageTokenTotals): UsageTokenTotals;
+declare function addActivityTotals(target: UsageActivityTotals, row: UsageActivityTotals): UsageActivityTotals;
+declare function addTotals(target: UsageTotals, row: UsageTotals): UsageTotals;
+declare function registerSessionUsage(ctx: Context, persistence: SessionPersistenceRdb): void;
+//#endregion
+//#region src/backend.d.ts
+interface SessionRow {
+  fSessionId: string;
+  fHeadEventId: string;
+  fHeadSequence: number;
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+  fAgentPreset: string | null;
+  fIncarnation: string;
+  fRevision: number;
+  fArchivedAt: number | null;
+  fPinnedSeq: number | null;
+  fLastEventAt: number | null;
+}
+interface EventInsert {
+  fEventId: string;
+  fParentId: string;
+  fType: string;
+  fKind: string;
+  fRole: string;
+  fName: string;
+  fActionId: string;
+  fEncoding: string;
+  fData: string;
+  fCreatedAt: number;
+}
+interface EventRow {
+  fEventId: string;
+  fSequence: number;
+  fType: string;
+  fKind: string;
+  fRole: string;
+  fName: string;
+  fActionId: string;
+  fCreatedAt: number;
+  fData: string;
+  fSurfaceOp: string | null;
+}
+interface BackendTx {
+  upsertSession(storage: SessionStorageMetadata, incarnation: string): Promise<void>;
+  getHead(id: SessionId): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">>;
+  getSeedLength(id: SessionId): Promise<number | null>;
+  updateSeedLength(id: SessionId, seedLength: number): Promise<void>;
+  refreshTitle(id: SessionId): Promise<void>;
+  insertEvents(events: EventInsert[], usageRows: readonly EventUsageRow[]): Promise<void>;
+  insertBridges(rows: Array<{
+    fSessionId: SessionId;
+    fEventId: string;
+    fSequence: number;
+    fSurfaceOp: string | null;
+  }>): Promise<void>;
+  updateHead(id: SessionId, headEventId: string, headSequence: number): Promise<void>;
+  bumpRevision(id: SessionId, lastEventAt?: number): Promise<void>;
+  deleteBridgeTail(id: SessionId, fromSequence: number): Promise<readonly string[]>;
+  getPrevBridge(id: SessionId, sequence: number): Promise<{
+    fEventId: string;
+    fSequence: number;
+  } | undefined>;
+  deleteSession(id: SessionId): Promise<readonly string[]>;
+  deleteSessions(ids: SessionId[]): Promise<{
+    deleted: number;
+    eventIds: readonly string[];
+  }>;
+}
+interface SessionListRowRecord {
+  sessionId: string;
+  title: string | null;
+  origin: string | null;
+  cwd: string | null;
+  createdAt: number;
+  updatedAt: number;
+  archived: boolean;
+  subagent: boolean;
+  workspace: string | null;
+}
+interface SessionListRowsQuery {
+  query?: string;
+  includeSubagents?: boolean;
+  limit?: number;
+  offset?: number;
+}
+interface SessionListRowsPage {
+  items: SessionListRowRecord[];
+  total: number;
+}
+interface SessionCountBucket extends UsageActivityTotals {
+  day: string;
+}
+interface SessionUsageBucket extends UsageTokenTotals {
+  day: string;
+  provider: string | null;
+  model: string | null;
+}
+interface Backend {
+  readonly kind: "sqlite" | "postgres";
+  readonly storeIdentity: string;
+  readonly storage: StorageRepository;
+  open(): Promise<void>;
+  getSession(id: SessionId): Promise<SessionRow | undefined>;
+  getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
+  getEventTypeAt(id: SessionId, sequence: number): Promise<string | undefined>;
+  getEventTypesBefore(id: SessionId, beforeSequence: number, limit: number): Promise<Array<Pick<EventRow, "fSequence" | "fType">>>;
+  listSessions(): Promise<SessionRow[]>;
+  transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
+  collectOrphans(): Promise<number>;
+  listOrphanSubagentSessions(): Promise<SessionId[]>;
+  usageReport(sinceMs?: number): Promise<UsageAggregate>;
+  listSessionRows(query?: SessionListRowsQuery): Promise<SessionListRowsPage>;
+  incrementSessionUsage(id: SessionId, buckets: readonly SessionUsageBucket[]): Promise<void>;
+  incrementSessionCounts(id: SessionId, buckets: readonly SessionCountBucket[]): Promise<void>;
+  rebuildSessionStats(id: SessionId): Promise<void>;
+  refreshEventUsageFlags(eventIds: readonly string[]): Promise<void>;
+  deleteSessionStats(id: SessionId): Promise<void>;
+  vacuum(): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/log.d.ts
+declare function rowToMeta(row: SessionRow): SessionHeader;
+declare function sessionInsertRow(storage: SessionStorageMetadata, incarnation: string): {
+  fSessionId: string;
+  fHeadEventId: string;
+  fHeadSequence: number;
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+  fAgentPreset: string | null;
+  fIncarnation: string;
+  fRevision: number;
+};
+declare function sessionConflictRow(storage: SessionStorageMetadata): {
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+  fAgentPreset: string | null;
+};
+declare function rowToEvent(row: EventRow): SessionEvent;
+declare function recomputeReplaceProvenance(events: SessionEvent[]): void;
+declare function findSurfaceRepairs(events: readonly SessionEvent[]): {
+  degradeToAppend: Set<number>;
+  addAppendMarker: Set<number>;
+  clearSurfaceOp: Set<number>;
+  clampEnd: Map<number, number>;
+};
+declare function repairSurfaceOps(events: SessionEvent[]): void;
+declare function repairAssistantSettlement(events: SessionEvent[]): void;
+declare function repairRequestHeaders(events: SessionEvent[]): void;
+declare function syncMeteringRanges(events: SessionEvent[]): void;
+declare function renameLegacyPtcEvents(events: SessionEvent[]): void;
+declare function normalizeToCurrentShape(events: SessionEvent[]): void;
+declare function sealOwnEvents(events: readonly SessionEvent[]): void;
+declare const OWN_EVENT_TYPES: ReadonlySet<string>;
+declare function needsShapeAdoption(events: readonly SessionEvent[]): boolean;
+declare function repairReadView(events: SessionEvent[]): void;
+declare function orphanInboxSpliceSeqs(events: readonly SessionEvent[]): Set<number>;
+declare function repairOrphanInboxSplices(events: SessionEvent[]): void;
+declare function scanRows(rows: readonly EventRow[], base?: number): {
+  preserved: SessionEvent[];
+  tornFrom?: number;
+};
+declare function toJsonlArtifact(meta: SessionHeader, inheritedEventCount: number, events: readonly SessionEvent[]): string;
+declare function titleOfEventData(data: string): string | undefined;
+interface EventUsageRow {
+  fEventId: string;
+  fCreatedAt: number;
+  fDay: string;
+  fProvider: string | null;
+  fModel: string | null;
+  fReferenced: number;
+  fSubagent: number;
+  fInputTokens: number;
+  fOutputTokens: number;
+  fCacheReadTokens: number;
+  fReasoningTokens: number;
+  fTotalTokens: number;
+}
+declare function usageRowOf(event: {
+  fEventId: string;
+  fCreatedAt: number;
+  fType: string;
+  fData: string;
+}, subagent: boolean): EventUsageRow | undefined;
+//#endregion
+export { SessionDeletionErrorCode as $, SessionRow as A, tWorkspaces as At, UsageTotals as B, usageRowOf as C, tSessionEvents as Ct, SessionCountBucket as D, tStorageUnits as Dt, EventRow as E, tSessions as Et, UsageAggregate as F, SESSION_IMPORT_PATH as Ft, emptyTotals as G, addActivityTotals as H, UsageBucket as I, SESSION_ROWS_PATH as It, resolveUsageSince as J, localDayKey as K, UsageRangeKey as L, SESSION_USAGE_PATH as Lt, COUNTED_EVENT_TYPES as M, SESSION_DELETE_PATH as Mt, SessionUsageReport as N, SESSION_EXPORT_PATH as Nt, SessionListRowsPage as O, tWorkspaceSessions as Ot, UsageActivityTotals as P, SESSION_GC_PATH as Pt, SessionDeletionError as Q, UsageSessionRow as R, StorageRepository as Rt, toJsonlArtifact as S, tSessionCounts as St, BackendTx as T, tSessionUsage as Tt, addTokenTotals as U, addActivityCount as V, addTotals as W, ProjectionCacheOptions as X, Config as Y, ResolvedConfig as Z, sealOwnEvents as _, tEventUsage as _t, normalizeToCurrentShape as a, truncateLiveSession as at, syncMeteringRanges as b, tScheduleTasks as bt, renameLegacyPtcEvents as c, DEFAULT_BUSY_TIMEOUT_MS as ct, repairReadView as d, EventRole as dt, SessionPersistenceRdb as et, repairRequestHeaders as f, JournalMode as ft, scanRows as g, eventKind as gt, rowToMeta as h, eventDimensions as ht, needsShapeAdoption as i, locateTurnEnd as it, SessionUsageBucket as j, WriteGuard as jt, SessionListRowsQuery as k, tWorkspaceState as kt, repairAssistantSettlement as l, EVENT_ENCODING as lt, rowToEvent as m, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as mt, OWN_EVENT_TYPES as n, SessionBranchRdb as nt, orphanInboxSpliceSeqs as o, SessionRowsItem as ot, repairSurfaceOps as p, SCHEMA_VERSION as pt, registerSessionUsage as q, findSurfaceRepairs as r, SessionBranchRdbProvider as rt, recomputeReplaceProvenance as s, SessionRowsValue as st, EventUsageRow as t, SessionPersistenceRdbInternals as tt, repairOrphanInboxSplices as u, EventKind as ut, sessionConflictRow as v, tEvents as vt, Backend as w, tSessionProjcacheRows as wt, titleOfEventData as x, tSchemaMeta as xt, sessionInsertRow as y, tPersistenceState as yt, UsageTokenTotals as z };