@smoothbricks/lmao 0.1.0

package/dist/lib/sqlite/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SQLite persistence for LMAO span buffers.
+ *
+ * General-purpose writer API for persisting span buffer trees to SQLite.
+ * Platform-agnostic — accepts any SyncSQLiteDatabase (bun:sqlite or better-sqlite3).
+ *
+ * @module sqlite
+ */
+export { SQLiteAsyncTraceWriter } from './sqlite-async-writer.js';
+export { buildAddColumnSql, extractSqliteColumnsFromTableInfo, getMissingSqliteColumns, quoteSqlIdentifier, SPANS_TABLE_INFO_SQL, SPANS_TABLE_INIT_SQL, } from './sqlite-common.js';
+export { createD1SQLiteDatabase, type D1LikeDatabase, type D1LikePreparedStatement } from './sqlite-d1.js';
+export type { AsyncSQLiteDatabase, AsyncSQLiteStatement, SyncSQLiteDatabase, SyncSQLiteStatement, } from './sqlite-db.js';
+export { SQLiteTraceWriter, type SQLiteWriterConfig } from './sqlite-writer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/sqlite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EACL,iBAAiB,EACjB,iCAAiC,EACjC,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,KAAK,cAAc,EAAE,KAAK,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC3G,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/lib/sqlite/index.js

@@ -0,0 +1,12 @@
+/**
+ * SQLite persistence for LMAO span buffers.
+ *
+ * General-purpose writer API for persisting span buffer trees to SQLite.
+ * Platform-agnostic — accepts any SyncSQLiteDatabase (bun:sqlite or better-sqlite3).
+ *
+ * @module sqlite
+ */
+export { SQLiteAsyncTraceWriter } from './sqlite-async-writer.js';
+export { buildAddColumnSql, extractSqliteColumnsFromTableInfo, getMissingSqliteColumns, quoteSqlIdentifier, SPANS_TABLE_INFO_SQL, SPANS_TABLE_INIT_SQL, } from './sqlite-common.js';
+export { createD1SQLiteDatabase } from './sqlite-d1.js';
+export { SQLiteTraceWriter } from './sqlite-writer.js';

package/dist/lib/sqlite/sqlite-async-writer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SQLiteAsyncTraceWriter - Async SQLite persistence for span buffer trees.
+ *
+ * Works with async SQLite drivers (for example Cloudflare D1 adapters) while
+ * preserving the same `spans` table shape as the sync SQLiteTraceWriter.
+ *
+ * @module sqlite-async-writer
+ */
+import type { AnySpanBuffer } from '../types.js';
+import type { AsyncSQLiteDatabase } from './sqlite-db.js';
+export declare class SQLiteAsyncTraceWriter {
+    private db;
+    private knownColumns;
+    private insertStmtCache;
+    private initialized;
+    constructor(db: AsyncSQLiteDatabase);
+    private init;
+    private refreshKnownColumns;
+    private ensureColumns;
+    private getInsertStatement;
+    flush(rootBuffer: AnySpanBuffer): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=sqlite-async-writer.d.ts.map

package/dist/lib/sqlite/sqlite-async-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-async-writer.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/sqlite-async-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAejD,OAAO,KAAK,EAAE,mBAAmB,EAAwB,MAAM,gBAAgB,CAAC;AAEhF,qBAAa,sBAAsB;IAKrB,OAAO,CAAC,EAAE;IAJtB,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,eAAe,CAA2C;IAClE,OAAO,CAAC,WAAW,CAAS;gBAER,EAAE,EAAE,mBAAmB;YAE7B,IAAI;YAYJ,mBAAmB;YAUnB,aAAa;IAe3B,OAAO,CAAC,kBAAkB;IAYpB,KAAK,CAAC,UAAU,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAc/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/lib/sqlite/sqlite-async-writer.js

@@ -0,0 +1,65 @@
+import { buildAddColumnSql, buildInsertParams, buildInsertSql, extractSqliteColumnsFromTableInfo, getActiveUserFields, getInsertStatementCacheKey, getMissingSchemaColumns, isSqliteDuplicateColumnError, parseSqliteTableInfoRows, SPANS_TABLE_INFO_SQL, SPANS_TABLE_INIT_SQL, walkSpanSegments, } from './sqlite-common.js';
+export class SQLiteAsyncTraceWriter {
+    db;
+    knownColumns = new Set();
+    insertStmtCache = new Map();
+    initialized = false;
+    constructor(db) {
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        await this.db.exec(SPANS_TABLE_INIT_SQL);
+        await this.refreshKnownColumns();
+        this.initialized = true;
+    }
+    async refreshKnownColumns() {
+        this.knownColumns.clear();
+        // WHY: async drivers are still a real schema boundary; validate PRAGMA rows before caching column names that drive
+        // later DDL and inserts.
+        const rows = parseSqliteTableInfoRows(await this.db.prepare(SPANS_TABLE_INFO_SQL).all());
+        for (const column of extractSqliteColumnsFromTableInfo(rows)) {
+            this.knownColumns.add(column.name);
+        }
+    }
+    async ensureColumns(schema) {
+        for (const column of getMissingSchemaColumns(schema, this.knownColumns)) {
+            try {
+                await this.db.exec(buildAddColumnSql(column));
+            }
+            catch (error) {
+                if (!isSqliteDuplicateColumnError(error, column.name)) {
+                    throw error;
+                }
+            }
+            await this.refreshKnownColumns();
+            this.knownColumns.add(column.name);
+        }
+    }
+    getInsertStatement(activeUserFields) {
+        const key = getInsertStatementCacheKey(activeUserFields);
+        const cached = this.insertStmtCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const stmt = this.db.prepare(buildInsertSql(activeUserFields));
+        this.insertStmtCache.set(key, stmt);
+        return stmt;
+    }
+    async flush(rootBuffer) {
+        await this.init();
+        for (const segment of walkSpanSegments(rootBuffer)) {
+            await this.ensureColumns(segment.buffer._logSchema);
+            const activeUserFields = getActiveUserFields(segment.buffer._logSchema, this.knownColumns);
+            const insertStmt = this.getInsertStatement(activeUserFields);
+            for (let row = 0; row < segment.buffer._writeIndex; row++) {
+                await insertStmt.run(...buildInsertParams(segment, row, activeUserFields));
+            }
+        }
+    }
+    async close() {
+        await this.db.close();
+    }
+}

package/dist/lib/sqlite/sqlite-common.d.ts

@@ -0,0 +1,37 @@
+import type { LogSchema } from '../schema/LogSchema.js';
+import type { AnySpanBuffer } from '../types.js';
+export declare const SPANS_TABLE_INIT_SQL = "\n  CREATE TABLE IF NOT EXISTS spans (\n    trace_id TEXT NOT NULL,\n    span_id INTEGER NOT NULL,\n    parent_span_id INTEGER NOT NULL,\n    row_index INTEGER NOT NULL,\n    entry_type INTEGER NOT NULL,\n    timestamp_ns INTEGER NOT NULL,\n    message TEXT,\n    PRIMARY KEY (trace_id, span_id, row_index)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_spans_trace ON spans(trace_id);\n  CREATE INDEX IF NOT EXISTS idx_spans_parent ON spans(trace_id, parent_span_id);\n";
+export declare const SPANS_TABLE_INFO_SQL = "PRAGMA table_info(spans)";
+export interface SQLiteColumnDefinition {
+    name: string;
+    sqliteType: string;
+}
+export interface SQLiteTableInfoRow {
+    cid: number;
+    name: string;
+    type: string;
+    notnull: number;
+    dflt_value: string | null;
+    pk: number;
+}
+export interface SpanSegment {
+    buffer: AnySpanBuffer;
+    traceId: string;
+    spanId: number;
+    parentSpanId: number;
+    rowOffset: number;
+}
+export declare function normalizeSqliteColumnType(type: string): string;
+export declare function quoteSqlIdentifier(name: string): string;
+export declare function buildAddColumnSql(column: SQLiteColumnDefinition): string;
+export declare function isSqliteDuplicateColumnError(error: unknown, columnName: string): boolean;
+export declare function getMissingSqliteColumns(columns: readonly SQLiteColumnDefinition[], knownColumns: ReadonlySet<string>): SQLiteColumnDefinition[];
+export declare function extractSqliteColumnsFromTableInfo(columns: readonly SQLiteTableInfoRow[]): SQLiteColumnDefinition[];
+export declare function parseSqliteTableInfoRows(rows: readonly unknown[], boundary?: string): SQLiteTableInfoRow[];
+export declare function walkSpanSegments(rootBuffer: AnySpanBuffer): Generator<SpanSegment>;
+export declare function getMissingSchemaColumns(schema: LogSchema, knownColumns: ReadonlySet<string>): SQLiteColumnDefinition[];
+export declare function getActiveUserFields(schema: LogSchema, knownColumns: ReadonlySet<string>): string[];
+export declare function getInsertStatementCacheKey(activeUserFields: readonly string[]): string;
+export declare function buildInsertSql(activeUserFields: readonly string[]): string;
+export declare function buildInsertParams(segment: SpanSegment, row: number, activeUserFields: readonly string[]): unknown[];
+//# sourceMappingURL=sqlite-common.d.ts.map

package/dist/lib/sqlite/sqlite-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-common.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/sqlite-common.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,oBAAoB,sdAchC,CAAC;AAEF,eAAO,MAAM,oBAAoB,6BAA6B,CAAC;AAI/D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAqID,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAExE;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAMxF;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,sBAAsB,EAAE,EAC1C,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,GAChC,sBAAsB,EAAE,CAQ1B;AAED,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,sBAAsB,EAAE,CAKlH;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,QAAQ,SAA6B,GACpC,kBAAkB,EAAE,CAEtB;AA8BD,wBAAiB,gBAAgB,CAAC,UAAU,EAAE,aAAa,GAAG,SAAS,CAAC,WAAW,CAAC,CAEnF;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,GAChC,sBAAsB,EAAE,CAW1B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAElG;AAED,wBAAgB,0BAA0B,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEtF;AAED,wBAAgB,cAAc,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAK1E;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,EAAE,CAgBnH"}

package/dist/lib/sqlite/sqlite-common.js

@@ -0,0 +1,207 @@
+import { hasOwn, hasOwnString, isRecord } from '@smoothbricks/validation';
+import { getSchemaType } from '../schema/typeGuards.js';
+export const SPANS_TABLE_INIT_SQL = `
+  CREATE TABLE IF NOT EXISTS spans (
+    trace_id TEXT NOT NULL,
+    span_id INTEGER NOT NULL,
+    parent_span_id INTEGER NOT NULL,
+    row_index INTEGER NOT NULL,
+    entry_type INTEGER NOT NULL,
+    timestamp_ns INTEGER NOT NULL,
+    message TEXT,
+    PRIMARY KEY (trace_id, span_id, row_index)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_spans_trace ON spans(trace_id);
+  CREATE INDEX IF NOT EXISTS idx_spans_parent ON spans(trace_id, parent_span_id);
+`;
+export const SPANS_TABLE_INFO_SQL = 'PRAGMA table_info(spans)';
+/** Check if bit at index is set in Arrow null bitmap (1 = valid/present, 0 = null) */
+function isBitSet(bitmap, idx) {
+    return (bitmap[idx >>> 3] & (1 << (idx & 7))) !== 0;
+}
+/**
+ * Read a user column value at the given row.
+ *
+ * Typed arrays are pre-allocated with zeros, so null bitmaps distinguish
+ * "set to zero" from "never written". JS arrays use `undefined` for unwritten slots.
+ */
+function readUserValue(buffer, fieldName, row) {
+    const values = Reflect.get(buffer, `${fieldName}_values`);
+    if (!values)
+        return undefined;
+    if (ArrayBuffer.isView(values)) {
+        const nulls = Reflect.get(buffer, `${fieldName}_nulls`);
+        if (!(nulls instanceof Uint8Array) || !('length' in values)) {
+            return undefined;
+        }
+        return isBitSet(nulls, row) ? Reflect.get(values, row) : undefined;
+    }
+    return Array.isArray(values) ? values[row] : undefined;
+}
+function readScopeValue(buffer, fieldName) {
+    return isRecord(buffer._scopeValues) ? buffer._scopeValues[fieldName] : undefined;
+}
+function describeSqliteBoundaryType(value) {
+    return typeof value;
+}
+function invalidSqliteBoundaryRow(boundary, rowIndex, message) {
+    return new Error(`${boundary} returned an invalid SQLite row ${rowIndex}: ${message}`);
+}
+function normalizeSqliteTableInfoInteger(value, boundary, rowIndex, fieldName) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        return Number(value);
+    }
+    throw invalidSqliteBoundaryRow(boundary, rowIndex, `${fieldName} expected number, got ${describeSqliteBoundaryType(value)}`);
+}
+function parseSqliteTableInfoRow(row, boundary, rowIndex) {
+    if (!isRecord(row)) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, `expected record, got ${describeSqliteBoundaryType(row)}`);
+    }
+    const rowRecord = row;
+    if (!hasOwn(rowRecord, 'cid')) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, 'missing cid');
+    }
+    if (!hasOwnString(rowRecord, 'name')) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, `name expected string, got ${describeSqliteBoundaryType(rowRecord.name)}`);
+    }
+    if (!hasOwnString(rowRecord, 'type')) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, `type expected string, got ${describeSqliteBoundaryType(rowRecord.type)}`);
+    }
+    if (!hasOwn(rowRecord, 'notnull')) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, 'missing notnull');
+    }
+    if (!hasOwn(rowRecord, 'dflt_value')) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, 'missing dflt_value');
+    }
+    if (typeof rowRecord.dflt_value !== 'string' && rowRecord.dflt_value !== null) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, `dflt_value expected string|null, got ${describeSqliteBoundaryType(rowRecord.dflt_value)}`);
+    }
+    if (!hasOwn(rowRecord, 'pk')) {
+        throw invalidSqliteBoundaryRow(boundary, rowIndex, 'missing pk');
+    }
+    return {
+        // WHY: some SQLite adapters promote PRAGMA integer metadata to bigint, but the shared table-info contract uses
+        // numeric counters plus string column descriptors.
+        cid: normalizeSqliteTableInfoInteger(rowRecord.cid, boundary, rowIndex, 'cid'),
+        name: rowRecord.name,
+        type: rowRecord.type,
+        notnull: normalizeSqliteTableInfoInteger(rowRecord.notnull, boundary, rowIndex, 'notnull'),
+        dflt_value: rowRecord.dflt_value,
+        pk: normalizeSqliteTableInfoInteger(rowRecord.pk, boundary, rowIndex, 'pk'),
+    };
+}
+/** Map arrow-builder SchemaType to SQLite column type */
+function schemaTypeToSqlite(schemaType) {
+    switch (schemaType) {
+        case 'category':
+        case 'text':
+        case 'enum':
+            return 'TEXT';
+        case 'number':
+            return 'REAL';
+        case 'bigUint64':
+        case 'boolean':
+            return 'INTEGER';
+        case 'binary':
+            return 'BLOB';
+    }
+    throw new Error(`Unsupported schema type: ${String(schemaType)}`);
+}
+export function normalizeSqliteColumnType(type) {
+    return type.trim() === '' ? 'TEXT' : type;
+}
+export function quoteSqlIdentifier(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Unsafe SQLite identifier: ${name}`);
+    }
+    return `"${name}"`;
+}
+export function buildAddColumnSql(column) {
+    return `ALTER TABLE spans ADD COLUMN ${quoteSqlIdentifier(column.name)} ${normalizeSqliteColumnType(column.sqliteType)}`;
+}
+export function isSqliteDuplicateColumnError(error, columnName) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.toLowerCase().includes(`duplicate column name: ${columnName.toLowerCase()}`);
+}
+export function getMissingSqliteColumns(columns, knownColumns) {
+    const missing = [];
+    for (const column of columns) {
+        if (!knownColumns.has(column.name)) {
+            missing.push(column);
+        }
+    }
+    return missing;
+}
+export function extractSqliteColumnsFromTableInfo(columns) {
+    return columns.map((column) => ({
+        name: column.name,
+        sqliteType: normalizeSqliteColumnType(column.type),
+    }));
+}
+export function parseSqliteTableInfoRows(rows, boundary = 'PRAGMA table_info(spans)') {
+    return rows.map((row, rowIndex) => parseSqliteTableInfoRow(row, boundary, rowIndex));
+}
+function* walkOverflowSegments(buffer, traceId, spanId, parentSpanId, rowOffset) {
+    yield {
+        buffer,
+        traceId,
+        spanId,
+        parentSpanId,
+        rowOffset,
+    };
+    if (buffer._overflow) {
+        yield* walkOverflowSegments(buffer._overflow, traceId, spanId, parentSpanId, rowOffset + buffer._writeIndex);
+    }
+}
+function* walkTree(buffer) {
+    yield* walkOverflowSegments(buffer, buffer.trace_id, buffer.span_id, buffer.parent_span_id, 0);
+    for (const child of buffer._children) {
+        yield* walkTree(child);
+    }
+}
+export function* walkSpanSegments(rootBuffer) {
+    yield* walkTree(rootBuffer);
+}
+export function getMissingSchemaColumns(schema, knownColumns) {
+    const schemaColumns = [];
+    for (const [name, field] of Object.entries(schema.fields)) {
+        const schemaType = getSchemaType(field);
+        if (!schemaType)
+            continue;
+        schemaColumns.push({ name, sqliteType: schemaTypeToSqlite(schemaType) });
+    }
+    return getMissingSqliteColumns(schemaColumns, knownColumns);
+}
+export function getActiveUserFields(schema, knownColumns) {
+    return schema._columnNames.filter((fieldName) => knownColumns.has(fieldName));
+}
+export function getInsertStatementCacheKey(activeUserFields) {
+    return activeUserFields.join(',');
+}
+export function buildInsertSql(activeUserFields) {
+    const userColsSql = activeUserFields.length > 0 ? `, ${activeUserFields.join(', ')}` : '';
+    const userPlaceholders = activeUserFields.length > 0 ? `, ${activeUserFields.map(() => '?').join(', ')}` : '';
+    return `INSERT INTO spans (trace_id, span_id, parent_span_id, row_index, entry_type, timestamp_ns, message${userColsSql})
+   VALUES (?, ?, ?, ?, ?, ?, ?${userPlaceholders})`;
+}
+export function buildInsertParams(segment, row, activeUserFields) {
+    const { buffer, traceId, spanId, parentSpanId, rowOffset } = segment;
+    const entryType = buffer.entry_type[row];
+    const timestampNs = Number(buffer.timestamp[row]);
+    const message = buffer.message_values[row] ?? null;
+    const userValues = activeUserFields.map((fieldName) => {
+        const directValue = readUserValue(buffer, fieldName, row);
+        const val = directValue ?? readScopeValue(buffer, fieldName);
+        if (val === undefined || val === null) {
+            return null;
+        }
+        return typeof val === 'bigint' ? Number(val) : val;
+    });
+    return [traceId, spanId, parentSpanId, rowOffset + row, entryType, timestampNs, message, ...userValues];
+}

package/dist/lib/sqlite/sqlite-d1.d.ts

@@ -0,0 +1,25 @@
+/**
+ * D1 adapter for LMAO async SQLite interfaces.
+ *
+ * This keeps D1-specific behavior in one place while exposing the generic
+ * AsyncSQLiteDatabase contract used by SQLiteAsyncTracer/SQLiteAsyncTraceWriter.
+ *
+ * @module sqlite-d1
+ */
+import type { AsyncSQLiteDatabase } from './sqlite-db.js';
+type D1BindValue = null | number | string | ArrayBuffer | ArrayBufferView;
+export interface D1LikePreparedStatement {
+    bind(...values: D1BindValue[]): D1LikePreparedStatement;
+    run(): Promise<unknown>;
+    all<T = unknown>(): Promise<{
+        results?: T[];
+    }>;
+    first<T = unknown>(): Promise<T | null>;
+}
+export interface D1LikeDatabase {
+    prepare(query: string): D1LikePreparedStatement;
+    exec(query: string): Promise<unknown>;
+}
+export declare function createD1SQLiteDatabase(db: D1LikeDatabase): AsyncSQLiteDatabase;
+export {};
+//# sourceMappingURL=sqlite-d1.d.ts.map

package/dist/lib/sqlite/sqlite-d1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-d1.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/sqlite-d1.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAwB,MAAM,gBAAgB,CAAC;AAEhF,KAAK,WAAW,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,eAAe,CAAC;AAE1E,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,GAAG,uBAAuB,CAAC;IACxD,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACxB,GAAG,CAAC,CAAC,GAAG,OAAO,KAAK,OAAO,CAAC;QAAE,OAAO,CAAC,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC,CAAC;IAC/C,KAAK,CAAC,CAAC,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAAC;IAChD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACvC;AA8ED,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,cAAc,GAAG,mBAAmB,CAE9E"}

package/dist/lib/sqlite/sqlite-d1.js

@@ -0,0 +1,67 @@
+function toD1BindValue(value) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (typeof value === 'bigint') {
+        return Number(value);
+    }
+    if (typeof value === 'number' || typeof value === 'string') {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return value;
+    }
+    if (ArrayBuffer.isView(value)) {
+        return value;
+    }
+    throw new Error(`Unsupported D1 bind param type: ${typeof value}`);
+}
+class D1StatementAdapter {
+    db;
+    query;
+    constructor(db, query) {
+        this.db = db;
+        this.query = query;
+    }
+    bind(params) {
+        const statement = this.db.prepare(this.query);
+        return statement.bind(...params.map(toD1BindValue));
+    }
+    async run(...params) {
+        await this.bind(params).run();
+    }
+    async all(...params) {
+        const result = await this.bind(params).all();
+        return result.results ?? [];
+    }
+    async get(...params) {
+        return (await this.bind(params).first()) ?? undefined;
+    }
+}
+class D1DatabaseAdapter {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async exec(sql) {
+        const statements = sql
+            .split(';')
+            .map((statement) => statement.trim())
+            .filter((statement) => statement.length > 0);
+        for (const statement of statements) {
+            await this.db.prepare(statement).run();
+        }
+    }
+    prepare(sql) {
+        return new D1StatementAdapter(this.db, sql);
+    }
+    async close() {
+        // D1 bindings are managed by the worker runtime.
+    }
+}
+export function createD1SQLiteDatabase(db) {
+    return new D1DatabaseAdapter(db);
+}

package/dist/lib/sqlite/sqlite-db.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal SQLite interfaces used by trace persistence.
+ *
+ * Sync APIs match bun:sqlite / better-sqlite3 style drivers.
+ * Async APIs match worker-style drivers (for example D1 adapters).
+ *
+ * @module sqlite-db
+ */
+export interface SyncSQLiteDatabase {
+    exec(sql: string): void;
+    prepare(sql: string): SyncSQLiteStatement;
+    close(): void;
+}
+export interface SyncSQLiteStatement {
+    run(...params: unknown[]): void;
+    all(...params: unknown[]): unknown[];
+    get(...params: unknown[]): unknown;
+}
+export interface AsyncSQLiteDatabase {
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): AsyncSQLiteStatement;
+    close(): Promise<void>;
+}
+export interface AsyncSQLiteStatement {
+    run(...params: unknown[]): Promise<void>;
+    all(...params: unknown[]): Promise<unknown[]>;
+    get(...params: unknown[]): Promise<unknown>;
+}
+//# sourceMappingURL=sqlite-db.d.ts.map

package/dist/lib/sqlite/sqlite-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-db.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/sqlite-db.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAAC;IAC1C,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC;IACrC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAC;IAC3C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAC9C,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7C"}

package/dist/lib/sqlite/sqlite-db.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/sqlite/sqlite-node.d.ts

@@ -0,0 +1,16 @@
+import type { AsyncSQLiteDatabase, SyncSQLiteDatabase } from './sqlite-db.js';
+/**
+ * Create a Node built-in sqlite database adapter.
+ *
+ * Use this in Node Vitest setup when you want trace output persisted
+ * to a deterministic file path.
+ */
+export declare function createNodeSQLiteDatabase(dbPath: string): SyncSQLiteDatabase;
+/**
+ * Create an async adapter around Node built-in sqlite.
+ *
+ * Useful when wiring into `createAsyncDatabase` callbacks while still
+ * writing to a deterministic file path on Node.
+ */
+export declare function createNodeSQLiteAsyncDatabase(dbPath: string): AsyncSQLiteDatabase;
+//# sourceMappingURL=sqlite-node.d.ts.map

package/dist/lib/sqlite/sqlite-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-node.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/sqlite-node.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EAEnB,kBAAkB,EAEnB,MAAM,gBAAgB,CAAC;AAoBxB;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAa3E;AAgBD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,CAajF"}

package/dist/lib/sqlite/sqlite-node.js

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import { DatabaseSync } from 'node:sqlite';
+function toSyncStatement(statement) {
+    return {
+        run(...params) {
+            statement.run(...params);
+        },
+        all(...params) {
+            return statement.all(...params);
+        },
+        get(...params) {
+            return statement.get(...params);
+        },
+    };
+}
+/**
+ * Create a Node built-in sqlite database adapter.
+ *
+ * Use this in Node Vitest setup when you want trace output persisted
+ * to a deterministic file path.
+ */
+export function createNodeSQLiteDatabase(dbPath) {
+    const db = new DatabaseSync(dbPath);
+    return {
+        exec(sql) {
+            db.exec(sql);
+        },
+        prepare(sql) {
+            return toSyncStatement(db.prepare(sql));
+        },
+        close() {
+            db.close();
+        },
+    };
+}
+function toAsyncStatement(statement) {
+    return {
+        async run(...params) {
+            statement.run(...params);
+        },
+        async all(...params) {
+            return statement.all(...params);
+        },
+        async get(...params) {
+            return statement.get(...params);
+        },
+    };
+}
+/**
+ * Create an async adapter around Node built-in sqlite.
+ *
+ * Useful when wiring into `createAsyncDatabase` callbacks while still
+ * writing to a deterministic file path on Node.
+ */
+export function createNodeSQLiteAsyncDatabase(dbPath) {
+    const syncDb = createNodeSQLiteDatabase(dbPath);
+    return {
+        async exec(sql) {
+            syncDb.exec(sql);
+        },
+        prepare(sql) {
+            return toAsyncStatement(syncDb.prepare(sql));
+        },
+        async close() {
+            syncDb.close();
+        },
+    };
+}

package/dist/lib/sqlite/sqlite-writer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * SQLiteTraceWriter - General-purpose writer that persists span buffer trees to SQLite.
+ *
+ * Accepts a SyncSQLiteDatabase instance (from bun:sqlite or better-sqlite3)
+ * and persists the full span tree as a flat `spans` table with dynamic column
+ * evolution based on the LogSchema fields found at flush time.
+ *
+ * Architecture:
+ * - Single `spans` table — no runs/log_entries decomposition
+ * - trace_id IS the run identifier (one root span per trace)
+ * - Tree structure via span_id / parent_span_id (no depth column)
+ * - User schema columns added dynamically via ALTER TABLE
+ * - Per-buffer ensureColumns for cross-library schema merging
+ *
+ * @module sqlite-writer
+ */
+import type { AnySpanBuffer } from '../types.js';
+import type { SyncSQLiteDatabase } from './sqlite-db.js';
+export interface SQLiteWriterConfig {
+    /** Path to SQLite file. Default: '.trace-results.db' */
+    dbPath?: string;
+}
+export declare class SQLiteTraceWriter {
+    private db;
+    private knownColumns;
+    private insertStmtCache;
+    constructor(db: SyncSQLiteDatabase);
+    private init;
+    private refreshKnownColumns;
+    /** Ensure user-defined schema columns exist in the spans table */
+    private ensureColumns;
+    private writeSegmentRows;
+    private flushAllSegments;
+    private getInsertStatement;
+    /** Write a root SpanBuffer tree to the database */
+    flush(rootBuffer: AnySpanBuffer): void;
+    close(): void;
+}
+//# sourceMappingURL=sqlite-writer.d.ts.map

package/dist/lib/sqlite/sqlite-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-writer.d.ts","sourceRoot":"","sources":["../../../src/lib/sqlite/sqlite-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAgBjD,OAAO,KAAK,EAAE,kBAAkB,EAAuB,MAAM,gBAAgB,CAAC;AAE9E,MAAM,WAAW,kBAAkB;IACjC,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,iBAAiB;IAIhB,OAAO,CAAC,EAAE;IAHtB,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,eAAe,CAA0C;gBAE7C,EAAE,EAAE,kBAAkB;IAI1C,OAAO,CAAC,IAAI;IAQZ,OAAO,CAAC,mBAAmB;IAU3B,kEAAkE;IAClE,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,kBAAkB;IAY1B,mDAAmD;IACnD,KAAK,CAAC,UAAU,EAAE,aAAa,GAAG,IAAI;IAWtC,KAAK,IAAI,IAAI;CAGd"}