@smoothbricks/lmao 0.1.0

package/dist/lib/testing/facts.js

@@ -0,0 +1,209 @@
+/**
+ * Type guard for span facts.
+ */
+export function isSpanFact(fact) {
+    return fact.startsWith('span:');
+}
+/**
+ * Create a span:started fact.
+ */
+export function spanStarted(name) {
+    return `span:${name}: started`;
+}
+/**
+ * Create a span:ok fact.
+ */
+export function spanOk(name) {
+    return `span:${name}: ok`;
+}
+/**
+ * Create a span:err fact.
+ */
+export function spanErr(name, code) {
+    return `span:${name}: err(${code})`;
+}
+/**
+ * Create a span:exception fact.
+ */
+export function spanException(name, message) {
+    return `span:${name}: exception(${message})`;
+}
+/**
+ * Type guard for log facts.
+ */
+export function isLogFact(fact) {
+    return fact.startsWith('log:');
+}
+/**
+ * Create a log fact.
+ */
+export function logFact(level, message) {
+    return `log:${level}: ${message}`;
+}
+// Convenience functions
+export const logDebug = (msg) => logFact('debug', msg);
+export const logInfo = (msg) => logFact('info', msg);
+export const logWarn = (msg) => logFact('warn', msg);
+export const logError = (msg) => logFact('error', msg);
+/**
+ * Type guard for tag facts.
+ */
+export function isTagFact(fact) {
+    return fact.startsWith('tag:');
+}
+/**
+ * Create a tag fact.
+ */
+export function tagFact(key, value) {
+    return `tag:${key}: ${value}`;
+}
+/**
+ * Type guard for scope facts.
+ */
+export function isScopeFact(fact) {
+    return fact.startsWith('scope:');
+}
+/**
+ * Create a scope fact.
+ */
+export function scopeFact(key, value) {
+    return `scope:${key}: ${value}`;
+}
+/**
+ * Type guard for feature flag facts.
+ */
+export function isFFFact(fact) {
+    return fact.startsWith('ff:');
+}
+/**
+ * Create a feature flag fact.
+ */
+export function ffFact(flag, value) {
+    return `ff:${flag}: ${value}`;
+}
+/**
+ * Type guard for metric facts.
+ */
+export function isMetricFact(fact) {
+    return fact.startsWith('metric:');
+}
+/**
+ * Create a metric fact.
+ */
+export function metricFact(name, value) {
+    return `metric:${name}: ${value}`;
+}
+function parseFactNamespace(value) {
+    switch (value) {
+        case 'span':
+        case 'log':
+        case 'tag':
+        case 'scope':
+        case 'ff':
+        case 'metric':
+            return value;
+        default:
+            throw new Error(`Unknown fact namespace: ${value}`);
+    }
+}
+/**
+ * Parse a fact string into its components.
+ */
+export function parseFact(fact) {
+    const colonIndex = fact.indexOf(':');
+    const secondColonIndex = fact.indexOf(':', colonIndex + 1);
+    const namespace = parseFactNamespace(fact.slice(0, colonIndex));
+    const name = fact.slice(colonIndex + 1, secondColonIndex).trim();
+    const content = fact.slice(secondColonIndex + 1).trim();
+    return { namespace, name, content, raw: fact };
+}
+class TraceFactArray extends Array {
+    constructor(facts = []) {
+        if (typeof facts === 'number') {
+            super(facts);
+        }
+        else {
+            super();
+            this.push(...facts);
+        }
+        Object.setPrototypeOf(this, TraceFactArray.prototype);
+    }
+    has(fact) {
+        return this.includes(fact);
+    }
+    hasMatch(pattern) {
+        const regex = patternToRegex(pattern);
+        return this.some((fact) => regex.test(fact));
+    }
+    byNamespace(namespace) {
+        return new TraceFactArray(this.filter((fact) => fact.startsWith(`${namespace}:`)));
+    }
+    spans() {
+        return this.filter(isSpanFact);
+    }
+    logs() {
+        return this.filter(isLogFact);
+    }
+    tags() {
+        return this.filter(isTagFact);
+    }
+    hasInOrder(expected) {
+        let lastIndex = -1;
+        for (const fact of expected) {
+            const index = this.indexOf(fact);
+            if (index === -1 || index <= lastIndex) {
+                return false;
+            }
+            lastIndex = index;
+        }
+        return true;
+    }
+    match(pattern) {
+        const regex = patternToRegex(pattern);
+        return new TraceFactArray(this.filter((fact) => regex.test(fact)));
+    }
+}
+/**
+ * Create a FactArray from raw facts.
+ */
+export function createFactArray(facts) {
+    return new TraceFactArray(facts);
+}
+// =============================================================================
+// PATTERN MATCHING
+// =============================================================================
+/**
+ * Convert a glob-like pattern to a regex.
+ *
+ * Supports:
+ * - `*` matches any characters except `:`
+ * - `**` matches any characters including `:`
+ */
+function patternToRegex(pattern) {
+    let result = '';
+    let i = 0;
+    while (i < pattern.length) {
+        if (pattern[i] === '*') {
+            if (pattern[i + 1] === '*') {
+                // ** matches anything
+                result += '.*';
+                i += 2;
+            }
+            else {
+                // * matches anything except colon
+                result += '[^:]*';
+                i += 1;
+            }
+        }
+        else if (/[.+^${}()|[\]\\]/.test(pattern[i])) {
+            // Escape regex special chars
+            result += `\\${pattern[i]}`;
+            i += 1;
+        }
+        else {
+            result += pattern[i];
+            i += 1;
+        }
+    }
+    return new RegExp(`^${result}$`);
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Testing utilities for LMAO trace-testing.
+ *
+ * This module provides strongly-typed trace facts and assertion helpers
+ * based on Akkartik's "tracing tests" approach:
+ * https://akkartik.name/post/tracing-tests
+ *
+ * Instead of testing return values directly, you:
+ * 1. Execute code that emits trace facts
+ * 2. Assert on the facts (WHAT happened, not HOW)
+ *
+ * @example
+ * ```typescript
+ * import { TestTracer } from '@smoothbricks/lmao';
+ * import {
+ *   createFactArray,
+ *   spanStarted,
+ *   spanOk,
+ *   tagFact,
+ * } from '@smoothbricks/lmao/testing';
+ *
+ * const tracer = new TestTracer(opContext);
+ * await tracer.trace('my-op', myOp);
+ *
+ * const facts = extractFacts(tracer.rootBuffers[0]);
+ *
+ * // Assert on WHAT happened
+ * expect(facts.has(spanOk('my-op'))).toBe(true);
+ * expect(facts.hasInOrder([
+ *   spanStarted('validate'),
+ *   spanStarted('execute'),
+ *   spanOk('execute'),
+ *   spanOk('validate'),
+ * ])).toBe(true);
+ * expect(facts.has(tagFact('userId', '123'))).toBe(true);
+ * ```
+ *
+ * @module testing
+ */
+export { createFactArray, type FactArray, type FactNamespace, type FFFact, ffFact, isFFFact, isLogFact, isMetricFact, isScopeFact, isSpanFact, isTagFact, type LogFact, type LogLevel, logDebug, logError, logFact, logInfo, logWarn, type MetricFact, metricFact, type ParsedFact, parseFact, type SchemaScopeFacts, type SchemaTagFacts, type ScopeFact, type SpanFact, type SpanState, scopeFact, spanErr, spanException, spanOk, spanStarted, type TagFact, type TraceFact, tagFact, } from './facts.js';
+export { JsBufferStrategy } from '../JsBufferStrategy.js';
+export type { OpContextBinding, OpContextOf } from '../opContext/types.js';
+export type { TraceRootFactory } from '../traceRoot.js';
+export { createTraceRoot } from '../traceRoot.universal.js';
+export { CompositeTracer } from '../tracers/CompositeTracer.js';
+export { NoOpTracer } from '../tracers/NoOpTracer.js';
+export { SQLiteAsyncTracer, SQLiteTracer } from '../tracers/SQLiteTracer.js';
+export { StdioTracer } from '../tracers/StdioTracer.js';
+export { type StatsSnapshot, TestTracer } from '../tracers/TestTracer.js';
+export { type ExtractFactsOptions, extractFacts } from './extractFacts.js';
+export { replayTraceToStdio } from './stdio-replay.js';
+export { type QueryableSpan, querySpan } from './queryable-span.js';
+export { extractFactsFor, findAllSpans, findSpan, spanNames } from './span-query.js';
+export { SQLiteAsyncTraceWriter, SQLiteTraceWriter, type SQLiteWriterConfig } from '../sqlite/index.js';
+export { createD1SQLiteDatabase, type D1LikeDatabase, type D1LikePreparedStatement } from '../sqlite/sqlite-d1.js';
+export type { AsyncSQLiteDatabase, AsyncSQLiteStatement, SyncSQLiteDatabase, SyncSQLiteStatement, } from '../sqlite/sqlite-db.js';
+export { makeBunTestSuiteTracer, type TestTracer as BunHarnessTestTracer } from './bun-harness.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAMH,OAAO,EACL,eAAe,EAEf,KAAK,SAAS,EAEd,KAAK,aAAa,EAElB,KAAK,MAAM,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,EACV,SAAS,EAET,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,OAAO,EACP,OAAO,EAEP,KAAK,UAAU,EACf,UAAU,EAEV,KAAK,UAAU,EACf,SAAS,EACT,KAAK,gBAAgB,EAErB,KAAK,cAAc,EAEnB,KAAK,SAAS,EAEd,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,SAAS,EACT,OAAO,EACP,aAAa,EACb,MAAM,EACN,WAAW,EAEX,KAAK,OAAO,EAEZ,KAAK,SAAS,EACd,OAAO,GACR,MAAM,YAAY,CAAC;AAMpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC3E,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,KAAK,aAAa,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAM1E,OAAO,EAAE,KAAK,mBAAmB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAMvD,OAAO,EAAE,KAAK,aAAa,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMrF,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxG,OAAO,EAAE,sBAAsB,EAAE,KAAK,cAAc,EAAE,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACnH,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,wBAAwB,CAAC;AAMhC,OAAO,EAAE,sBAAsB,EAAE,KAAK,UAAU,IAAI,oBAAoB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/lib/testing/index.js

@@ -0,0 +1,74 @@
+/**
+ * Testing utilities for LMAO trace-testing.
+ *
+ * This module provides strongly-typed trace facts and assertion helpers
+ * based on Akkartik's "tracing tests" approach:
+ * https://akkartik.name/post/tracing-tests
+ *
+ * Instead of testing return values directly, you:
+ * 1. Execute code that emits trace facts
+ * 2. Assert on the facts (WHAT happened, not HOW)
+ *
+ * @example
+ * ```typescript
+ * import { TestTracer } from '@smoothbricks/lmao';
+ * import {
+ *   createFactArray,
+ *   spanStarted,
+ *   spanOk,
+ *   tagFact,
+ * } from '@smoothbricks/lmao/testing';
+ *
+ * const tracer = new TestTracer(opContext);
+ * await tracer.trace('my-op', myOp);
+ *
+ * const facts = extractFacts(tracer.rootBuffers[0]);
+ *
+ * // Assert on WHAT happened
+ * expect(facts.has(spanOk('my-op'))).toBe(true);
+ * expect(facts.hasInOrder([
+ *   spanStarted('validate'),
+ *   spanStarted('execute'),
+ *   spanOk('execute'),
+ *   spanOk('validate'),
+ * ])).toBe(true);
+ * expect(facts.has(tagFact('userId', '123'))).toBe(true);
+ * ```
+ *
+ * @module testing
+ */
+// =============================================================================
+// FACT TYPES AND BUILDERS
+// =============================================================================
+export { createFactArray, ffFact, isFFFact, isLogFact, isMetricFact, isScopeFact, isSpanFact, isTagFact, logDebug, logError, logFact, logInfo, logWarn, metricFact, parseFact, scopeFact, spanErr, spanException, spanOk, spanStarted, tagFact, } from './facts.js';
+// =============================================================================
+// TRACER RE-EXPORTS
+// =============================================================================
+export { JsBufferStrategy } from '../JsBufferStrategy.js';
+// Universal createTraceRoot — picks Node (hrtime.bigint) or ES (performance.now) at runtime
+export { createTraceRoot } from '../traceRoot.universal.js';
+export { CompositeTracer } from '../tracers/CompositeTracer.js';
+export { NoOpTracer } from '../tracers/NoOpTracer.js';
+export { SQLiteAsyncTracer, SQLiteTracer } from '../tracers/SQLiteTracer.js';
+export { StdioTracer } from '../tracers/StdioTracer.js';
+// Re-export TestTracer for convenience
+export { TestTracer } from '../tracers/TestTracer.js';
+// =============================================================================
+// FACT EXTRACTION
+// =============================================================================
+export { extractFacts } from './extractFacts.js';
+export { replayTraceToStdio } from './stdio-replay.js';
+// =============================================================================
+// SPAN QUERY API
+// =============================================================================
+export { querySpan } from './queryable-span.js';
+export { extractFactsFor, findAllSpans, findSpan, spanNames } from './span-query.js';
+// =============================================================================
+// SQLITE PERSISTENCE
+// =============================================================================
+export { SQLiteAsyncTraceWriter, SQLiteTraceWriter } from '../sqlite/index.js';
+export { createD1SQLiteDatabase } from '../sqlite/sqlite-d1.js';
+// =============================================================================
+// TEST HARNESS WIRING
+// =============================================================================
+export { makeBunTestSuiteTracer } from './bun-harness.js';

package/dist/lib/testing/queryable-span.d.ts

@@ -0,0 +1,39 @@
+/**
+ * QueryableSpan - Ergonomic wrapper around SpanBuffer for test assertions.
+ *
+ * Provides a clean API for navigating the span tree and extracting facts
+ * without needing to know SpanBuffer internals.
+ *
+ * @example
+ * ```typescript
+ * const q = querySpan(tracer.rootBuffers[0]);
+ * expect(q.name).toBe('my-op');
+ * expect(q.find('validate')?.facts().has(spanOk('validate'))).toBe(true);
+ * expect(q.names()).toContain('save');
+ * ```
+ *
+ * @module queryable-span
+ */
+import type { LogSchema } from '../schema/LogSchema.js';
+import type { SpanBuffer } from '../types.js';
+import { type ExtractFactsOptions } from './extractFacts.js';
+import type { FactArray } from './facts.js';
+export interface QueryableSpan<T extends LogSchema = LogSchema> {
+    /** Span name (from message_values[0]) */
+    readonly name: string;
+    /** Extract all facts from this span and its children */
+    facts(options?: ExtractFactsOptions): FactArray;
+    /** Find first child span by name (depth-first) */
+    find(name: string): QueryableSpan<T> | undefined;
+    /** Find all spans matching name (depth-first) */
+    findAll(name: string): QueryableSpan<T>[];
+    /** Direct child spans */
+    readonly children: QueryableSpan<T>[];
+    /** All descendant span names (flat list, depth-first) */
+    names(): string[];
+    /** Raw SpanBuffer for advanced use */
+    readonly buffer: SpanBuffer<T>;
+}
+/** Wrap a SpanBuffer as a QueryableSpan for ergonomic test assertions */
+export declare function querySpan<T extends LogSchema>(buffer: SpanBuffer<T>): QueryableSpan<T>;
+//# sourceMappingURL=queryable-span.d.ts.map

package/dist/lib/testing/queryable-span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryable-span.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/queryable-span.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,mBAAmB,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC5D,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,wDAAwD;IACxD,KAAK,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAEhD,kDAAkD;IAClD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEjD,iDAAiD;IACjD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;IAE1C,yBAAyB;IACzB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;IAEtC,yDAAyD;IACzD,KAAK,IAAI,MAAM,EAAE,CAAC;IAElB,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CAChC;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAEtF"}

package/dist/lib/testing/queryable-span.js

@@ -0,0 +1,58 @@
+import { extractFacts } from './extractFacts.js';
+/** Wrap a SpanBuffer as a QueryableSpan for ergonomic test assertions */
+export function querySpan(buffer) {
+    return new QueryableSpanImpl(buffer);
+}
+class QueryableSpanImpl {
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    get name() {
+        return this.buffer.message_values[0];
+    }
+    facts(options) {
+        return extractFacts(this.buffer, options);
+    }
+    find(name) {
+        return findInChildren(this.buffer._children, name);
+    }
+    findAll(name) {
+        const results = [];
+        collectAll(this.buffer._children, name, results);
+        return results;
+    }
+    get children() {
+        return this.buffer._children.map((child) => new QueryableSpanImpl(child));
+    }
+    names() {
+        const result = [];
+        collectNames(this.buffer._children, result);
+        return result;
+    }
+}
+function findInChildren(children, name) {
+    for (const child of children) {
+        if (child.message_values[0] === name) {
+            return new QueryableSpanImpl(child);
+        }
+        const found = findInChildren(child._children, name);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function collectAll(children, name, results) {
+    for (const child of children) {
+        if (child.message_values[0] === name) {
+            results.push(new QueryableSpanImpl(child));
+        }
+        collectAll(child._children, name, results);
+    }
+}
+function collectNames(children, result) {
+    for (const child of children) {
+        result.push(child.message_values[0]);
+        collectNames(child._children, result);
+    }
+}

package/dist/lib/testing/span-query.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Standalone span query functions — tree-shakable alternative to QueryableSpan.
+ *
+ * These functions operate directly on SpanBuffer instances without wrapping.
+ * Prefer these when you only need one or two operations and want minimal overhead.
+ *
+ * @module span-query
+ */
+import type { LogSchema } from '../schema/LogSchema.js';
+import type { SpanBuffer } from '../types.js';
+import { type ExtractFactsOptions } from './extractFacts.js';
+import type { FactArray } from './facts.js';
+/** Find first descendant span by name (depth-first) */
+export declare function findSpan<T extends LogSchema>(root: SpanBuffer<T>, name: string): SpanBuffer<T> | undefined;
+/** Find all descendant spans matching name (depth-first) */
+export declare function findAllSpans<T extends LogSchema>(root: SpanBuffer<T>, name: string): SpanBuffer<T>[];
+/** Extract facts for a specific named span within a root buffer tree */
+export declare function extractFactsFor<T extends LogSchema>(root: SpanBuffer<T>, spanName: string, options?: ExtractFactsOptions): FactArray | undefined;
+/** Collect all descendant span names (flat list, depth-first) */
+export declare function spanNames<T extends LogSchema>(root: SpanBuffer<T>): string[];
+//# sourceMappingURL=span-query.d.ts.map

package/dist/lib/testing/span-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-query.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/span-query.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,mBAAmB,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,uDAAuD;AACvD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAQ1G;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAIpG;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,CAAC,SAAS,SAAS,EACjD,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,SAAS,GAAG,SAAS,CAIvB;AAED,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,CAI5E"}

package/dist/lib/testing/span-query.js

@@ -0,0 +1,47 @@
+import { extractFacts } from './extractFacts.js';
+/** Find first descendant span by name (depth-first) */
+export function findSpan(root, name) {
+    for (const child of root._children) {
+        const typed = child;
+        if (typed.message_values[0] === name)
+            return typed;
+        const found = findSpan(typed, name);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** Find all descendant spans matching name (depth-first) */
+export function findAllSpans(root, name) {
+    const results = [];
+    collectSpans(root, name, results);
+    return results;
+}
+/** Extract facts for a specific named span within a root buffer tree */
+export function extractFactsFor(root, spanName, options) {
+    const span = findSpan(root, spanName);
+    if (!span)
+        return undefined;
+    return extractFacts(span, options);
+}
+/** Collect all descendant span names (flat list, depth-first) */
+export function spanNames(root) {
+    const result = [];
+    collectNames(root._children, result);
+    return result;
+}
+function collectSpans(root, name, results) {
+    for (const child of root._children) {
+        const typed = child;
+        if (typed.message_values[0] === name)
+            results.push(typed);
+        collectSpans(typed, name, results);
+    }
+}
+function collectNames(children, result) {
+    for (const child of children) {
+        const typed = child;
+        result.push(typed.message_values[0]);
+        collectNames(typed._children, result);
+    }
+}

package/dist/lib/testing/stdio-replay.d.ts

@@ -0,0 +1,4 @@
+import type { OpContextBinding } from '../opContext/types.js';
+import type { AnySpanBuffer } from '../types.js';
+export declare function replayTraceToStdio(binding: OpContextBinding, rootBuffer: AnySpanBuffer): void;
+//# sourceMappingURL=stdio-replay.d.ts.map

package/dist/lib/testing/stdio-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-replay.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/stdio-replay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAuBjD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,aAAa,GAAG,IAAI,CAsB7F"}

package/dist/lib/testing/stdio-replay.js

@@ -0,0 +1,42 @@
+import { JsBufferStrategy } from '../JsBufferStrategy.js';
+import { createTraceRoot } from '../traceRoot.universal.js';
+import { StdioTracer } from '../tracers/StdioTracer.js';
+function isStdioWritable(value) {
+    return typeof value === 'object' && value !== null && typeof Reflect.get(value, 'write') === 'function';
+}
+function makeConsoleWriteStream(write) {
+    return {
+        write(chunk) {
+            write(chunk.replace(/\n$/, ''));
+            return true;
+        },
+    };
+}
+function replayChildSpan(tracer, buffer) {
+    tracer.onSpanStart(buffer);
+    for (const child of buffer._children) {
+        replayChildSpan(tracer, child);
+    }
+    tracer.onSpanEnd(buffer);
+}
+export function replayTraceToStdio(binding, rootBuffer) {
+    const processRef = globalThis.process;
+    const out = isStdioWritable(processRef?.stdout)
+        ? processRef.stdout
+        : makeConsoleWriteStream((line) => console.log(line));
+    const err = isStdioWritable(processRef?.stderr)
+        ? processRef.stderr
+        : makeConsoleWriteStream((line) => console.error(line));
+    const tracer = new StdioTracer(binding, {
+        bufferStrategy: new JsBufferStrategy(),
+        createTraceRoot,
+        out,
+        err,
+        colorEnabled: processRef?.stdout !== undefined,
+    });
+    tracer.onTraceStart(rootBuffer);
+    for (const child of rootBuffer._children) {
+        replayChildSpan(tracer, child);
+    }
+    tracer.onTraceEnd(rootBuffer);
+}

package/dist/lib/testing/trace-query.d.ts

@@ -0,0 +1,59 @@
+/**
+ * TraceQuery - Post-run query API for the SQLite trace database.
+ *
+ * Queries a single flat `spans` table where each row is a buffer entry.
+ * Status and duration are derived from entry_type and timestamps via self-joins.
+ * Tree structure uses span_id / parent_span_id (no depth column).
+ *
+ * Platform-agnostic: accepts a SyncSQLiteDatabase instance from either
+ * bun:sqlite or better-sqlite3.
+ *
+ * @example
+ * ```typescript
+ * import { Database } from 'bun:sqlite';
+ * import { TraceQuery } from '@smoothbricks/lmao/testing';
+ *
+ * const query = new TraceQuery(new Database('.trace-results.db'));
+ * console.log(query.failures());
+ * console.log(query.slowest(undefined, 10));
+ * query.close();
+ * ```
+ *
+ * @module trace-query
+ */
+import type { SyncSQLiteDatabase } from '../sqlite/sqlite-db.js';
+export interface TraceQueryResult {
+    spanName: string;
+    status: 'ok' | 'err' | 'exception' | 'running';
+    errorCode?: string;
+    durationNs?: number;
+    describe?: string;
+    parentSpanId?: number;
+}
+type TraceRun = {
+    traceId: string;
+    spanName: string;
+    startedAt: number;
+};
+type LatestTraceRun = {
+    traceId: string;
+};
+export declare class TraceQuery {
+    private db;
+    constructor(db: SyncSQLiteDatabase);
+    /** Get all trace runs (root spans), most recent first */
+    runs(): TraceRun[];
+    /** Get the most recent trace_id (= run_id) */
+    latestRun(): LatestTraceRun | undefined;
+    /** Get all failed tests in a run (defaults to latest run) */
+    failures(traceId?: string): TraceQueryResult[];
+    /** Get slowest tests in a run (defaults to latest run) */
+    slowest(traceId?: string, limit?: number): TraceQueryResult[];
+    /** Find spans by name pattern (SQL LIKE, defaults to latest run) */
+    findSpans(pattern: string, traceId?: string): TraceQueryResult[];
+    /** Get full span tree for a specific test (all descendants, defaults to latest run) */
+    testTree(testName: string, traceId?: string): TraceQueryResult[];
+    close(): void;
+}
+export {};
+//# sourceMappingURL=trace-query.d.ts.map

package/dist/lib/testing/trace-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-query.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/trace-query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,IAAI,GAAG,KAAK,GAAG,WAAW,GAAG,SAAS,CAAC;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,KAAK,QAAQ,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AACzE,KAAK,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAyG1C,qBAAa,UAAU;IACT,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,kBAAkB;IAE1C,yDAAyD;IACzD,IAAI,IAAI,QAAQ,EAAE;IAelB,8CAA8C;IAC9C,SAAS,IAAI,cAAc,GAAG,SAAS;IAevC,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,EAAE;IAqC9C,0DAA0D;IAC1D,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,gBAAgB,EAAE;IAqCzD,oEAAoE;IACpE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,EAAE;IA2BhE,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,EAAE;IA2ChE,KAAK,IAAI,IAAI;CAGd"}