@interactive-inc/claude-funnel 0.67.0 → 0.68.0

package/dist/{sqlite-diagnostic-log-BDxfXGZy.js → sqlite-diagnostic-log-Qs4cf9I_.js}

@@ -3,8 +3,8 @@ import { t as NodeFunnelFileSystem } from "./node-file-system-xJx7dymE.js";
 import { t as NodeFunnelProcessRunner } from "./node-process-runner-D4rzPl8Q.js";
 import { n as FUNNEL_DIR, s as resolveFunnelPort } from "./settings-store-ZFWBhOnp.js";
 import { t as FunnelAuthFailedError } from "./funnel-error-DoSBCogD.js";
-import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-CoBk_EFF.js";
-import { t as FunnelLogSqliteSink } from "./funnel-log-sqlite-sink-CXbs3qQp.js";
+import { n as diagnosticEventOfProcessed, t as diagnosticConnectionEventOf } from "./diagnostic-event-CxMM5Bl2.js";
+import { t as SqliteEventLog } from "./sqlite-event-log-eZuXKszJ.js";
 import { dirname, join } from "node:path";
 import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -159,13 +159,19 @@ var MemoryConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 		});
 	}
 	queryRaw(query) {
-		const matched = this.raws.filter((event) => matches(event, query));
+		const matched = this.raws.filter((event) => {
+			if (!matches(event, query)) return false;
+			if (query.eventId !== void 0 && event.eventId !== query.eventId) return false;
+			return true;
+		});
 		return takeRecent(matched, query.limit);
 	}
 	queryProcessed(query) {
 		const matched = this.processeds.filter((event) => {
 			if (!matches(event, query)) return false;
+			if (query.eventId !== void 0 && event.eventId !== query.eventId) return false;
 			if (query.outcome !== void 0 && event.outcome !== query.outcome) return false;
+			if (query.outcomePrefix !== void 0 && !event.outcome.startsWith(query.outcomePrefix)) return false;
 			return true;
 		});
 		return takeRecent(matched, query.limit);
@@ -174,6 +180,7 @@ var MemoryConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 		const matched = this.connections.filter((event) => {
 			if (!matches(event, query)) return false;
 			if (query.status !== void 0 && event.status !== query.status) return false;
+			if (query.statuses !== void 0 && !query.statuses.includes(event.status)) return false;
 			return true;
 		});
 		return takeRecent(matched, query.limit);
@@ -189,6 +196,7 @@ const matches = (event, query) => {
 	if (query.type !== void 0 && event.type !== query.type) return false;
 	if (query.connectorId !== void 0 && event.connectorId !== query.connectorId) return false;
 	if (query.channelId !== void 0 && event.channelId !== query.channelId) return false;
+	if ("seq" in event && query.seq !== void 0 && event.seq !== query.seq) return false;
 	return true;
 };
 const takeRecent = (events, limit) => {
@@ -452,7 +460,6 @@ var FunnelBroadcaster = class {
 			offset: this.latestOffset
 		};
 		const payload = JSON.stringify(event);
-		meta?.connector;
 		this.eventsBroadcast += 1;
 		this.lastBroadcastAt = this.now();
 		if (this.replayBufferSize > 0) {
@@ -579,7 +586,7 @@ var SqliteFunnelEventLog = class extends FunnelEventLog {
 		this.now = props.now ?? (() => Date.now());
 		this.logger = props.logger;
 		this.onError = props.onError;
-		this.sink = new FunnelLogSqliteSink({
+		this.sink = new SqliteEventLog({
 			path: props.path,
 			indexes: ["channel_id", "connector_id"],
 			extractIndexes: (event) => ({
@@ -893,7 +900,7 @@ var FunnelListenerRegistry = class FunnelListenerRegistry {
 	async stopAll() {
 		this.stopHealthCheck();
 		this.pendingRetry.clear();
-		for (const [, entry] of [...this.running.entries()]) await this.stop(entry.channelName, entry.config.name);
+		for (const [, entry] of this.running.entries()) await this.stop(entry.channelName, entry.config.name);
 	}
 	ensureStats(key) {
 		const existing = this.stats.get(key);
@@ -940,7 +947,7 @@ var FunnelListenerRegistry = class FunnelListenerRegistry {
 		this.healthCheckInFlight = true;
 		try {
 			const dead = [];
-			for (const [key, entry] of [...this.running.entries()]) {
+			for (const [key, entry] of this.running.entries()) {
 				if (entry.listener.isAlive()) {
 					this.failureCounts.delete(key);
 					continue;
@@ -953,7 +960,7 @@ var FunnelListenerRegistry = class FunnelListenerRegistry {
 			}
 			await Promise.all(dead.map((target) => this.recoverDead(target.channelName, target.connectorName, target.type)));
 			const retries = [];
-			for (const [key, pending] of [...this.pendingRetry.entries()]) {
+			for (const [key, pending] of this.pendingRetry.entries()) {
 				if (this.running.has(key)) {
 					this.pendingRetry.delete(key);
 					continue;
@@ -1189,19 +1196,6 @@ const channelsPublishHandler = factory.createHandlers(zParam(z.object({ channel:
 });
 //#endregion
 //#region lib/gateway/routes/debug.ts
-const extractPreview = (payload) => {
-	if (typeof payload !== "string" || payload.length === 0) return null;
-	try {
-		const parsed = JSON.parse(payload);
-		if (parsed !== null && typeof parsed === "object" && "text" in parsed) {
-			const text = String(parsed.text);
-			return text.length > 80 ? `${text.slice(0, 80)}…` : text;
-		}
-	} catch {
-		return payload.length > 80 ? `${payload.slice(0, 80)}…` : payload;
-	}
-	return payload.length > 80 ? `${payload.slice(0, 80)}…` : payload;
-};
 const buildChannelDiagnosis = (channel) => {
 	const rootCause = (channel.connectionErrors[channel.connectionErrors.length - 1] ?? null)?.detail ?? null;
 	if (channel.connectors.length === 0) return {
@@ -1250,11 +1244,6 @@ const debugHandler = factory.createHandlers(async (c) => {
 	const gatewayListeners = deps.registry.list();
 	const gatewayClients = deps.broadcaster.listChannels();
 	const metrics = deps.broadcaster.getMetrics();
-	const tmpDir = funnelTmpDir();
-	const rawPath = join(tmpDir, "connector-raw.db");
-	const processedPath = join(tmpDir, "connector-processed.db");
-	const connectionPath = join(tmpDir, "connector-connection.db");
-	const hasStore = existsSync(rawPath) && existsSync(processedPath) && existsSync(connectionPath);
 	const channels = targetChannels.map((ch) => {
 		const listenerEntry = gatewayListeners.find((l) => l.channelName === ch.name) ?? null;
 		const listener = listenerEntry ? {
@@ -1264,61 +1253,30 @@ const debugHandler = factory.createHandlers(async (c) => {
 			lastEventAt: listenerEntry.lastEventAt
 		} : null;
 		const claudeClients = gatewayClients.filter((cl) => cl.channel === ch.id || cl.channel === ch.name).length;
-		const recentEvents = [];
-		const connectionErrors = [];
-		if (hasStore) {
-			const reader = new ConnectorDiagnosticSqlReader({
-				rawPath,
-				processedPath,
-				connectionPath
-			});
-			const rows = (() => {
-				try {
-					return reader.query("SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT 10", [ch.id]);
-				} finally {
-					reader.close();
-				}
-			})();
-			if (!(rows instanceof Error)) for (const row of [...rows].reverse()) {
-				const rawPayload = typeof row.payload === "string" ? row.payload : null;
-				let payloadParsed = null;
-				if (rawPayload) try {
-					const parsed = JSON.parse(rawPayload);
-					if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) payloadParsed = parsed;
-				} catch {
-					payloadParsed = null;
-				}
-				recentEvents.push({
-					seq: typeof row.seq === "number" ? row.seq : null,
-					ts: typeof row.ts === "number" ? row.ts : null,
-					type: typeof row.type === "string" ? row.type : "?",
-					outcome: typeof row.outcome === "string" ? row.outcome : "?",
-					payload: rawPayload,
-					payloadParsed,
-					preview: extractPreview(row.payload)
-				});
+		const recentEvents = (() => {
+			if (!deps.diagnosticLog) return [];
+			try {
+				return deps.diagnosticLog.queryProcessed({
+					channelId: ch.id,
+					limit: 10
+				}).map(diagnosticEventOfProcessed);
+			} catch {
+				return [];
 			}
-			if (listener && (!listener.alive || listener.errors > 0) || !listener) {
-				const errReader = new ConnectorDiagnosticSqlReader({
-					rawPath,
-					processedPath,
-					connectionPath
-				});
-				const errRows = (() => {
-					try {
-						return errReader.query("SELECT ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT 3", [ch.id]);
-					} finally {
-						errReader.close();
-					}
-				})();
-				if (!(errRows instanceof Error)) for (const row of [...errRows].reverse()) connectionErrors.push({
-					ts: typeof row.ts === "number" ? row.ts : null,
-					type: typeof row.type === "string" ? row.type : "?",
-					status: typeof row.status === "string" ? row.status : "?",
-					detail: typeof row.detail === "string" && row.detail.length > 0 ? row.detail : null
-				});
+		})();
+		const needsConnErrors = listener && (!listener.alive || listener.errors > 0) || !listener;
+		const connectionErrors = (() => {
+			if (!needsConnErrors || !deps.diagnosticLog) return [];
+			try {
+				return deps.diagnosticLog.queryConnection({
+					channelId: ch.id,
+					statuses: ["auth-failed", "error"],
+					limit: 3
+				}).map(diagnosticConnectionEventOf);
+			} catch {
+				return [];
 			}
-		}
+		})();
 		const base = {
 			id: ch.id,
 			name: ch.name,
@@ -1468,6 +1426,7 @@ var FunnelGatewayServer = class {
 	nowMs;
 	extraRoutes;
 	ownsEventLog;
+	diagnosticLog;
 	startedAt = null;
 	server = null;
 	disposed = false;
@@ -1489,6 +1448,7 @@ var FunnelGatewayServer = class {
 		this.token = deps.token ?? "";
 		this.allowInsecureHost = deps.allowInsecureHost ?? false;
 		this.extraRoutes = deps.extraRoutes ?? null;
+		this.diagnosticLog = deps.diagnosticLog;
 		const clock = deps.clock;
 		this.nowMs = clock ? () => clock.millis() : () => Date.now();
 		if (deps.eventLog) {
@@ -1681,7 +1641,8 @@ var FunnelGatewayServer = class {
 				registry: this.registry,
 				channels: this.channels,
 				uptimeMs: () => this.startedAt ? this.nowMs() - this.startedAt : 0,
-				emit: (input) => this.emit(input)
+				emit: (input) => this.emit(input),
+				diagnosticLog: this.diagnosticLog
 			});
 			return next();
 		});
@@ -1946,7 +1907,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 			...ageCap,
 			...rawMax !== void 0 ? { maxRows: rawMax } : {}
 		};
-		this.raw = new FunnelLogSqliteSink({
+		this.raw = new SqliteEventLog({
 			path: props.rawPath,
 			indexes: [
 				"event_id",
@@ -1960,7 +1921,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 			}),
 			...rawCap
 		});
-		this.processed = new FunnelLogSqliteSink({
+		this.processed = new SqliteEventLog({
 			path: props.processedPath,
 			indexes: [
 				"event_id",
@@ -1976,7 +1937,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 			}),
 			...verdictCap
 		});
-		this.connection = new FunnelLogSqliteSink({
+		this.connection = new SqliteEventLog({
 			path: props.connectionPath,
 			indexes: [
 				"connector_id",
@@ -2042,10 +2003,13 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 		});
 	}
 	queryRaw(query) {
+		const where = buildWhere(query);
+		if (query.eventId !== void 0) where.event_id = query.eventId;
 		return this.raw.query({
 			...query.type !== void 0 ? { type: query.type } : {},
+			...query.seq !== void 0 ? { seq: query.seq } : {},
 			...query.limit !== void 0 ? { limit: query.limit } : {},
-			where: buildWhere(query),
+			where,
 			order: "desc"
 		}).map((record) => ({
 			seq: record.seq,
@@ -2059,11 +2023,14 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 	}
 	queryProcessed(query) {
 		const where = buildWhere(query);
+		if (query.eventId !== void 0) where.event_id = query.eventId;
 		if (query.outcome !== void 0) where.outcome = query.outcome;
 		return this.processed.query({
 			...query.type !== void 0 ? { type: query.type } : {},
+			...query.seq !== void 0 ? { seq: query.seq } : {},
 			...query.limit !== void 0 ? { limit: query.limit } : {},
 			where,
+			...query.outcomePrefix !== void 0 ? { wherePrefix: { outcome: query.outcomePrefix } } : {},
 			order: "desc"
 		}).map((record) => ({
 			seq: record.seq,
@@ -2081,8 +2048,10 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 		if (query.status !== void 0) where.status = query.status;
 		return this.connection.query({
 			...query.type !== void 0 ? { type: query.type } : {},
+			...query.seq !== void 0 ? { seq: query.seq } : {},
 			...query.limit !== void 0 ? { limit: query.limit } : {},
 			where,
+			...query.statuses !== void 0 ? { whereIn: { status: query.statuses } } : {},
 			order: "desc"
 		}).map((record) => ({
 			seq: record.seq,

package/dist/sqlite-event-log-BYgCFMxC.d.ts

@@ -0,0 +1,284 @@
+//#region lib/event-log/event-log-entry.d.ts
+/**
+ * Wrapper that `EventLog.append` puts around every event before handing it
+ * to a sink. `seq` is monotonic across the lifetime of the underlying store —
+ * sinks persist it as the primary key so replay (and broadcaster seeding
+ * after restart) is an indexed range scan, not a full table walk. `ts` is
+ * epoch milliseconds. `event` is the caller-defined payload validated by the
+ * validation function passed to the log.
+ */
+type EventLogEntry<E> = {
+  seq: number;
+  ts: number;
+  event: E;
+};
+//#endregion
+//#region lib/event-log/event-log-store.d.ts
+/**
+ * Relay sink. Receives records that already have a `seq` assigned by the
+ * primary and stores or forwards them — memory ring, stdout, network push,
+ * a second SQLite mirror, etc. Does not generate seq itself, so any number
+ * can be attached and they all observe the same monotonic stream.
+ *
+ * `write` returns `void` on success or an `Error` the `EventLog` surfaces via
+ * `onSinkError`. Throwing is also tolerated (`EventLog` catches it), but
+ * returning is preferred so the failure path is part of the type.
+ */
+type EventLogRelay<E> = {
+  write(record: EventLogEntry<E>): void | Error;
+  close?(): void;
+};
+/**
+ * Primary sink. Owns the canonical seq sequence for the log. `insert` is
+ * the atomic boundary — it assigns a seq strictly greater than every
+ * previously assigned one, persists the record, and returns it. SQLite
+ * implementations get atomicity for free by delegating to `INTEGER PRIMARY
+ * KEY` so two processes sharing one database file see one monotonic
+ * stream without coordinating through `EventLog`.
+ *
+ * `getMaxSeq` is the highest seq currently in the sink — used for
+ * observability and for replay seeding by clients reading the store.
+ */
+type EventLogStore<E> = {
+  insert(input: {
+    ts: number;
+    event: E;
+  }): EventLogEntry<E> | Error;
+  getMaxSeq(): number;
+  close?(): void;
+};
+//#endregion
+//#region lib/event-log/event-log.d.ts
+type Listener<E> = (record: EventLogEntry<E>) => void;
+type SinkErrorHandler<E> = (error: Error, record: EventLogEntry<E>, sink: EventLogRelay<E>) => void;
+type EventLogValidator<E> = (event: unknown) => {
+  success: true;
+  data: E;
+} | {
+  success: false;
+  error: Error;
+};
+type EventLogProps<E> = {
+  /** Validates each event before emission. Use `schema.safeParse` from any validation library, or a plain function. */
+  validate: EventLogValidator<E>;
+  /** Owns seq assignment + durability. Use `SqliteEventLog` for multi-process safety. */
+  primary: EventLogStore<E>;
+  /** Optional fanout for already-sequenced records (memory ring, stdout, network mirror). */
+  relays?: ReadonlyArray<EventLogRelay<E>>;
+  /** Override for tests. Defaults to `Date.now`. */
+  now?: () => number;
+  /** Observer for relay failures. Default: silently swallow. */
+  onSinkError?: SinkErrorHandler<E>;
+};
+/**
+ * Validated event log. Three responsibilities and nothing else:
+ * validate the event, delegate seq + persistence to the primary sink, and
+ * fan the resulting record out to relays and live subscribers.
+ *
+ * Splitting "primary" from "relays" makes the seq invariant honest: there
+ * is exactly one source of truth (the primary's atomic insert). Two
+ * `EventLog` instances pointed at the same SQLite file therefore see
+ * one monotonic stream without coordinating with each other. Relays mirror
+ * already-sequenced records, so they can be added or removed without
+ * affecting correctness.
+ *
+ * Failure isolation:
+ *   - Primary failure short-circuits append and is returned to the caller.
+ *   - Relay failures never block the primary path — they surface via the
+ *     optional `onSinkError` callback so the caller can observe without
+ *     being interrupted.
+ *   - A subscriber that throws is contained; the rest of the fanout
+ *     completes normally.
+ */
+declare class EventLog<E> {
+  private readonly validate;
+  private readonly primary;
+  private readonly relays;
+  private readonly now;
+  private readonly onSinkError;
+  private readonly listeners;
+  constructor(props: EventLogProps<E>);
+  append(event: E): EventLogEntry<E> | Error;
+  subscribe(listener: Listener<E>): () => void;
+  getMaxSeq(): number;
+  close(): void;
+  private callPrimary;
+  private fanOutToRelays;
+  private callRelay;
+  private fanOutToListeners;
+  private callClose;
+}
+//#endregion
+//#region lib/event-log/memory-event-log.d.ts
+type MemoryEventLogProps = {
+  /** Hard cap on retained records. The oldest is evicted on overflow. 0 disables retention. */
+  capacity?: number;
+};
+/**
+ * In-memory ring buffer that doubles as primary or relay. As primary it
+ * owns its own seq counter (single-process only — for multi-process
+ * safety, use `SqliteEventLog` as primary and place this as a
+ * relay). As relay it accepts whatever seq the primary assigned and
+ * advances its own counter to match, so `getMaxSeq` stays meaningful.
+ *
+ * Useful as a test double, as a short-window replay buffer paired with a
+ * persistent primary (covering reconnects without round-tripping disk),
+ * or as a backing store for live subscribers.
+ */
+declare class MemoryEventLog<E> implements EventLogStore<E>, EventLogRelay<E> {
+  private readonly capacity;
+  private readonly buffer;
+  private seq;
+  constructor(props?: MemoryEventLogProps);
+  insert(input: {
+    ts: number;
+    event: E;
+  }): EventLogEntry<E>;
+  write(record: EventLogEntry<E>): void;
+  getMaxSeq(): number;
+  query(): ReadonlyArray<EventLogEntry<E>>;
+  clear(): void;
+  private append;
+}
+//#endregion
+//#region lib/event-log/sqlite-event-log.d.ts
+type IndexValues<I extends ReadonlyArray<string>> = Record<I[number], string | null>;
+type IndexPrefixes<I extends ReadonlyArray<string>> = Partial<Record<I[number], string>>;
+type IndexSets<I extends ReadonlyArray<string>> = Partial<Record<I[number], ReadonlyArray<string | null>>>;
+/**
+ * Constructor props. The shape narrows on `I`: when no indexes are
+ * declared (the default), `extractIndexes` is forbidden; when indexes
+ * are declared, both `indexes` and `extractIndexes` are required and
+ * `extractIndexes` is type-checked against the index keys.
+ */
+type SqliteEventLogProps<E, I extends ReadonlyArray<string>> = I extends readonly [] ? {
+  path: string;
+  maxRows?: number;
+  maxAgeMs?: number;
+  maxBytes?: number;
+  targetBytes?: number;
+  now?: () => number;
+  indexes?: I;
+  extractIndexes?: never;
+} : {
+  path: string;
+  maxRows?: number;
+  maxAgeMs?: number;
+  maxBytes?: number;
+  targetBytes?: number;
+  now?: () => number;
+  indexes: I;
+  extractIndexes: (event: E) => IndexValues<I>;
+};
+type SqliteEventLogQuery<I extends ReadonlyArray<string>> = {
+  /** Return only records with seq strictly greater than this. */
+  sinceSeq?: number;
+  /** Match one sequence number exactly instead of using `sinceSeq`. */
+  seq?: number;
+  /** Filter by the top-level `event.type` discriminator. */
+  type?: string;
+  /** Filter by indexed columns. Keys are constrained to the declared `indexes`. */
+  where?: Partial<IndexValues<I>>;
+  /** Prefix-match indexed text columns. */
+  wherePrefix?: IndexPrefixes<I>;
+  /** Match any value in a set for indexed columns. */
+  whereIn?: IndexSets<I>;
+  /** Maximum rows returned. Default 1000. */
+  limit?: number;
+  /**
+   * Which end of the seq range to take when `limit` clips the result.
+   * "asc" (default) returns the oldest matching rows; "desc" returns the
+   * newest. Rows are always sorted ascending by seq before returning, so the
+   * caller sees a chronological slice either way — "desc" just picks the tail.
+   */
+  order?: "asc" | "desc";
+};
+/**
+ * SQLite-backed sink built on `bun:sqlite`. Implements both primary and
+ * relay roles so the same instance can own seq generation for one log and
+ * mirror records from another (e.g. cross-process replication, restore
+ * from a backup stream).
+ *
+ * Concurrency model: seq is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically via `lastInsertRowid`. Two `EventLog` instances pointed
+ * at the same database file therefore see one monotonically increasing
+ * seq stream without coordinating through `EventLog` — the database itself is
+ * the synchronization point.
+ *
+ * Schema is version-managed via `PRAGMA user_version`. Migrations are
+ * append-only and run in a transaction on every construct so a partial
+ * upgrade rolls back cleanly. Caller-defined `indexes` are layered on top
+ * via `ALTER TABLE ADD COLUMN` + `CREATE INDEX IF NOT EXISTS`, so adding
+ * a new index to an existing database is a no-downtime operation.
+ *
+ * Type safety: the second generic parameter `I` is the literal tuple of
+ * index column names. `extractIndexes` and `query({ where })` are
+ * both type-checked against this tuple, so a typo at the call site is a
+ * compile-time error rather than a silent miss at runtime.
+ *
+ * Retention is bounded by `maxRows` and/or `maxAgeMs`. Both run on every
+ * insert as a single indexed DELETE that no-ops below the cap.
+ *
+ * Bulk inserts use `insertMany`, which wraps the batch in one transaction
+ * for ~10–100x throughput at the cost of one fsync per batch instead of
+ * one per row.
+ */
+declare class SqliteEventLog<E, const I extends ReadonlyArray<string> = readonly []> implements EventLogStore<E>, EventLogRelay<E> {
+  private readonly db;
+  private readonly maxRows;
+  private readonly maxAgeMs;
+  private readonly maxBytes;
+  private readonly targetBytes;
+  private readonly now;
+  private readonly indexes;
+  private readonly extractIndexes;
+  private readonly insertStmt;
+  private readonly insertWithSeqStmt;
+  private readonly maxSeqStmt;
+  private readonly countStmt;
+  private readonly trimRowsStmt;
+  private readonly trimAgeStmt;
+  private readonly trimOldestStmt;
+  private insertsSinceByteCheck;
+  constructor(props: SqliteEventLogProps<E, I>);
+  insert(input: {
+    ts: number;
+    event: E;
+  }): EventLogEntry<E> | Error;
+  insertMany(inputs: ReadonlyArray<{
+    ts: number;
+    event: E;
+  }>): EventLogEntry<E>[] | Error;
+  write(record: EventLogEntry<E>): void | Error;
+  getMaxSeq(): number;
+  query(props?: SqliteEventLogQuery<I>): EventLogEntry<E>[];
+  /**
+   * Current schema version. Useful for diagnostics and for tests that want
+   * to verify migrations ran. Reads `PRAGMA user_version` once per call.
+   */
+  getSchemaVersion(): number;
+  close(): void;
+  private buildInsertParams;
+  private appendWhereConditions;
+  private appendPrefixConditions;
+  private appendSetConditions;
+  private trim;
+  private indexKeys;
+  /**
+   * Throttled byte-size enforcement. Only every BYTE_CHECK_INTERVAL inserts do
+   * we measure the file; on overflow we estimate how many of the oldest rows to
+   * drop to land near targetBytes (by the byte/row ratio), delete them in one
+   * statement, then VACUUM once to return the freed pages to the filesystem (a
+   * plain DELETE only frees pages inside the file). One DELETE + one VACUUM per
+   * overflow keeps the expensive rewrite rare — the file must refill the whole
+   * maxBytes→targetBytes delta before the next overflow can trigger.
+   */
+  private maybeTrimBytes;
+  private byteSize;
+  /** Drop every row and reclaim the file space. Used by `<log>.clear()`. */
+  clear(): void;
+  private syncIndexColumns;
+  private migrate;
+}
+//#endregion
+export { MemoryEventLogProps as a, EventLogValidator as c, EventLogEntry as d, MemoryEventLog as i, EventLogRelay as l, SqliteEventLogProps as n, EventLog as o, SqliteEventLogQuery as r, EventLogProps as s, SqliteEventLog as t, EventLogStore as u };