@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/testing/extractFacts.ts

@@ -7,6 +7,7 @@
  * @module testing/extractFacts
  */
 
+import { resolveEntryType, resolveMessage } from '../resolveMessage.js';
 import type { LogSchema } from '../schema/LogSchema.js';
 import {
   ENTRY_TYPE_DEBUG,
@@ -17,8 +18,10 @@ import {
   ENTRY_TYPE_SPAN_ERR,
   ENTRY_TYPE_SPAN_EXCEPTION,
   ENTRY_TYPE_SPAN_OK,
+  ENTRY_TYPE_TRACE,
   ENTRY_TYPE_WARN,
 } from '../schema/systemSchema.js';
+import { iterateSpanChildren } from '../traceTopology.js';
 import type { SpanBuffer } from '../types.js';
 import {
   createFactArray,
@@ -106,12 +109,17 @@ const DEFAULT_OPTIONS: Required<ExtractFactsOptions> = {
   tagFields: [],
 };
 
+type WalkFrame<T extends LogSchema> = {
+  buffer: SpanBuffer<T>;
+  children?: Generator<SpanBuffer<T>>;
+};
+
 /**
  * Extract facts from a SpanBuffer tree.
  *
  * Walks the buffer tree depth-first and produces facts for:
  * - Span lifecycle (started, ok, err, exception)
- * - Log entries (info, warn, error, debug)
+ * - Log entries (trace, debug, info, warn, error)
  * - Tag values (from row 0 of each span)
  * - Scope values (propagated through tree)
  * - Feature flag accesses
@@ -138,7 +146,29 @@ export function extractFacts<T extends LogSchema>(
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const facts: TraceFact[] = [];
 
-  walkBuffer(rootBuffer, facts, opts);
+  const stack: WalkFrame<T>[] = [{ buffer: rootBuffer }];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (!frame) break;
+
+    if (!frame.children) {
+      if (frame.buffer._writeIndex === 0) {
+        stack.pop();
+        continue;
+      }
+      enterBuffer(frame.buffer, facts, opts);
+      frame.children = iterateSpanChildren(frame.buffer);
+    }
+
+    const next = frame.children.next();
+    if (!next.done) {
+      stack.push({ buffer: next.value });
+      continue;
+    }
+
+    leaveBuffer(frame.buffer, facts, opts);
+    stack.pop();
+  }
 
   return createFactArray(facts);
 }
@@ -146,112 +176,67 @@ export function extractFacts<T extends LogSchema>(
 /**
  * Walk a buffer and its children, extracting facts.
  */
-function walkBuffer<T extends LogSchema>(
+function enterBuffer<T extends LogSchema>(
   buffer: SpanBuffer<T>,
   facts: TraceFact[],
   opts: Required<ExtractFactsOptions>,
 ): void {
-  // Span name is in message_values[0] (written by writeSpanStart)
-  const spanName = buffer.message_values[0];
+  const spanName = resolveMessage(buffer, 0) ?? '';
   const writeIndex = buffer._writeIndex;
+  if (writeIndex === 0) return;
 
-  if (writeIndex === 0) {
-    // Empty buffer - no facts to extract
-    return;
-  }
-
-  // Always emit span:started as first fact for this span
   facts.push(spanStarted(spanName));
-
-  // Extract scope facts (from buffer's scope values)
   if (opts.includeScope && buffer._scopeValues) {
     for (const [key, value] of Object.entries(buffer._scopeValues)) {
-      if (value !== undefined && value !== null) {
-        facts.push(scopeFact(key, String(value)));
-      }
+      if (value !== undefined && value !== null) facts.push(scopeFact(key, String(value)));
     }
   }
-
-  // Extract tag facts from row 0 (ctx.tag writes here)
-  // Also check row 1 (completion row - .with() on ok()/err())
-  // And rows 2+ (log rows - .with() on log.*)
   if (opts.includeTags) {
-    for (let row = 0; row < writeIndex; row++) {
-      extractTagFacts(buffer, row, facts, opts);
-    }
+    for (let row = 0; row < writeIndex; row++) extractTagFacts(buffer, row, facts, opts);
   }
 
-  // Buffer layout per specs/lmao/01h_entry_types_and_logging_primitives.md:
-  // - Row 0: span-start (tags overwrite this row's attribute columns)
-  // - Row 1: span-ok/err/exception (completion status)
-  // - Row 2+: log entries (info/debug/warn/error), ff entries
-  const entryTypes = buffer.entry_type;
-  const messages = buffer.message_values;
-
-  // Process log/ff entries from row 2 onwards
   for (let row = 2; row < writeIndex; row++) {
-    const entryType = entryTypes[row];
-
+    const entryType = resolveEntryType(buffer, row);
     switch (entryType) {
       case ENTRY_TYPE_INFO:
       case ENTRY_TYPE_DEBUG:
       case ENTRY_TYPE_WARN:
-      case ENTRY_TYPE_ERROR: {
-        if (opts.includeLogs) {
-          const level = entryTypeToLogLevel(entryType);
-          const rowMessage = messages[row];
-          const message = typeof rowMessage === 'string' ? rowMessage : '';
-          facts.push(logFact(level, message));
-        }
+      case ENTRY_TYPE_ERROR:
+      case ENTRY_TYPE_TRACE:
+        if (opts.includeLogs) facts.push(logFact(entryTypeToLogLevel(entryType), resolveMessage(buffer, row) ?? ''));
         break;
-      }
-
       case ENTRY_TYPE_FF_ACCESS:
-      case ENTRY_TYPE_FF_USAGE: {
-        if (opts.includeFF) {
-          extractFFfacts(buffer, row, facts);
-        }
+      case ENTRY_TYPE_FF_USAGE:
+        if (opts.includeFF) extractFFfacts(buffer, row, facts);
         break;
-      }
     }
   }
+}
 
-  // Recurse into children BEFORE completing this span
-  // This maintains the natural execution order in facts
-  for (const child of buffer._children) {
-    walkBuffer(child as SpanBuffer<T>, facts, opts);
-  }
-
-  // Completion status is ALWAYS at row 1 (not last row)
-  // Row 1 is pre-initialized as span-exception, overwritten by ok()/err()
+function leaveBuffer<T extends LogSchema>(
+  buffer: SpanBuffer<T>,
+  facts: TraceFact[],
+  opts: Required<ExtractFactsOptions>,
+): void {
+  const writeIndex = buffer._writeIndex;
+  if (writeIndex === 0) return;
+  const spanName = resolveMessage(buffer, 0) ?? '';
   if (writeIndex >= 2) {
-    const completionEntryType = entryTypes[1];
-
-    switch (completionEntryType) {
+    switch (resolveEntryType(buffer, 1)) {
       case ENTRY_TYPE_SPAN_OK:
         facts.push(spanOk(spanName));
         break;
-
-      case ENTRY_TYPE_SPAN_ERR: {
-        const errorCode = getErrorCode(buffer, 1);
-        facts.push(spanErr(spanName, errorCode));
+      case ENTRY_TYPE_SPAN_ERR:
+        facts.push(spanErr(spanName, getErrorCode(buffer, 1)));
         break;
-      }
-
-      case ENTRY_TYPE_SPAN_EXCEPTION: {
-        const message = getExceptionMessage(buffer, 1);
-        facts.push(spanException(spanName, message));
+      case ENTRY_TYPE_SPAN_EXCEPTION:
+        facts.push(spanException(spanName, getExceptionMessage(buffer, 1)));
         break;
-      }
     }
   }
-
-  // Extract duration metric if requested
   if (opts.includeMetrics) {
     const duration = getSpanDuration(buffer);
-    if (duration !== undefined) {
-      facts.push(metricFact(`${spanName}:duration_ns`, Number(duration)));
-    }
+    if (duration !== undefined) facts.push(metricFact(`${spanName}:duration_ns`, Number(duration)));
   }
 }
 
@@ -269,7 +254,7 @@ function extractTagFacts<T extends LogSchema>(
 
   for (const fieldName of fields) {
     // Skip system fields
-    if (fieldName.startsWith('_')) continue;
+    if (fieldName === 'message' || fieldName.startsWith('_')) continue;
 
     const nullsKey = `${fieldName}_nulls`;
     const valuesKey = `${fieldName}_values`;
@@ -294,10 +279,10 @@ function extractTagFacts<T extends LogSchema>(
  */
 function extractFFfacts<T extends LogSchema>(buffer: SpanBuffer<T>, row: number, facts: TraceFact[]): void {
   // Feature flag entries store the flag name in message_values and the resolved value in ff_value_values.
-  const name = buffer.message_values[row];
+  const name = resolveMessage(buffer, row);
   const value = buffer.ff_value_values[row];
 
-  if (typeof name === 'string' && typeof value === 'string') {
+  if (name !== undefined && typeof value === 'string') {
     facts.push(ffFact(name, value));
   }
 }
@@ -316,6 +301,8 @@ function isNull(nulls: Uint8Array, index: number): boolean {
  */
 function entryTypeToLogLevel(entryType: number): LogLevel {
   switch (entryType) {
+    case ENTRY_TYPE_TRACE:
+      return 'trace';
     case ENTRY_TYPE_DEBUG:
       return 'debug';
     case ENTRY_TYPE_INFO:
@@ -341,8 +328,7 @@ function getErrorCode<T extends LogSchema>(buffer: SpanBuffer<T>, row: number):
  * Get exception message from a span-exception row.
  */
 function getExceptionMessage<T extends LogSchema>(buffer: SpanBuffer<T>, row: number): string {
-  const message = buffer.message_values[row];
-  return typeof message === 'string' ? message : 'Unknown exception';
+  return resolveMessage(buffer, row) ?? 'Unknown exception';
 }
 
 /**

package/src/lib/testing/facts.ts

@@ -88,7 +88,7 @@ export function spanException<N extends string, M extends string>(name: N, messa
 /**
  * Log levels.
  */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
 
 /**
  * A log fact: `log:${level}: ${message}`

package/src/lib/testing/queryable-span.ts

@@ -15,13 +15,15 @@
  * @module queryable-span
  */
 
+import { resolveMessage } from '../resolveMessage.js';
 import type { LogSchema } from '../schema/LogSchema.js';
+import { iterateSpanChildren, iterateSpanTree } from '../traceTopology.js';
 import type { SpanBuffer } from '../types.js';
 import { type ExtractFactsOptions, extractFacts } from './extractFacts.js';
 import type { FactArray } from './facts.js';
 
 export interface QueryableSpan<T extends LogSchema = LogSchema> {
-  /** Span name (from message_values[0]) */
+  /** Resolved span name. */
   readonly name: string;
 
   /** Extract all facts from this span and its children */
@@ -52,7 +54,7 @@ class QueryableSpanImpl<T extends LogSchema> implements QueryableSpan<T> {
   constructor(readonly buffer: SpanBuffer<T>) {}
 
   get name(): string {
-    return this.buffer.message_values[0];
+    return resolveMessage(this.buffer, 0) ?? '';
   }
 
   facts(options?: ExtractFactsOptions): FactArray {
@@ -60,49 +62,40 @@ class QueryableSpanImpl<T extends LogSchema> implements QueryableSpan<T> {
   }
 
   find(name: string): QueryableSpan<T> | undefined {
-    return findInChildren(this.buffer._children as SpanBuffer<T>[], name);
+    for (const descendant of iterateDescendantSpans(this.buffer)) {
+      if (resolveMessage(descendant, 0) === name) return new QueryableSpanImpl(descendant);
+    }
+    return undefined;
   }
 
   findAll(name: string): QueryableSpan<T>[] {
     const results: QueryableSpan<T>[] = [];
-    collectAll(this.buffer._children as SpanBuffer<T>[], name, results);
+    for (const descendant of iterateDescendantSpans(this.buffer)) {
+      if (resolveMessage(descendant, 0) === name) results.push(new QueryableSpanImpl(descendant));
+    }
     return results;
   }
 
   get children(): QueryableSpan<T>[] {
-    return (this.buffer._children as SpanBuffer<T>[]).map((child) => new QueryableSpanImpl(child));
+    const result: QueryableSpan<T>[] = [];
+    for (const child of iterateSpanChildren(this.buffer)) result.push(new QueryableSpanImpl(child));
+    return result;
   }
 
   names(): string[] {
     const result: string[] = [];
-    collectNames(this.buffer._children as SpanBuffer<T>[], result);
-    return result;
-  }
-}
-
-function findInChildren<T extends LogSchema>(children: SpanBuffer<T>[], name: string): QueryableSpan<T> | undefined {
-  for (const child of children) {
-    if (child.message_values[0] === name) {
-      return new QueryableSpanImpl(child);
-    }
-    const found = findInChildren(child._children as SpanBuffer<T>[], name);
-    if (found) return found;
-  }
-  return undefined;
-}
-
-function collectAll<T extends LogSchema>(children: SpanBuffer<T>[], name: string, results: QueryableSpan<T>[]): void {
-  for (const child of children) {
-    if (child.message_values[0] === name) {
-      results.push(new QueryableSpanImpl(child));
+    for (const descendant of iterateDescendantSpans(this.buffer)) {
+      result.push(resolveMessage(descendant, 0) ?? '');
     }
-    collectAll(child._children as SpanBuffer<T>[], name, results);
+    return result;
   }
 }
 
-function collectNames<T extends LogSchema>(children: SpanBuffer<T>[], result: string[]): void {
-  for (const child of children) {
-    result.push(child.message_values[0]);
-    collectNames(child._children as SpanBuffer<T>[], result);
+function* iterateDescendantSpans<T extends LogSchema>(root: SpanBuffer<T>): Generator<SpanBuffer<T>> {
+  let previousNodeIndex = root._nodeIndex;
+  for (const buffer of iterateSpanTree(root)) {
+    if (buffer._nodeIndex === previousNodeIndex) continue;
+    previousNodeIndex = buffer._nodeIndex;
+    yield buffer;
   }
 }

package/src/lib/testing/span-query.ts

@@ -7,18 +7,17 @@
  * @module span-query
  */
 
+import { resolveMessage } from '../resolveMessage.js';
 import type { LogSchema } from '../schema/LogSchema.js';
+import { iterateSpanTree } from '../traceTopology.js';
 import type { SpanBuffer } from '../types.js';
 import { type ExtractFactsOptions, extractFacts } from './extractFacts.js';
 import type { FactArray } from './facts.js';
 
 /** Find first descendant span by name (depth-first) */
 export function findSpan<T extends LogSchema>(root: SpanBuffer<T>, name: string): SpanBuffer<T> | undefined {
-  for (const child of root._children) {
-    const typed = child as SpanBuffer<T>;
-    if (typed.message_values[0] === name) return typed;
-    const found = findSpan(typed, name);
-    if (found) return found;
+  for (const descendant of iterateDescendantSpans(root)) {
+    if (resolveMessage(descendant, 0) === name) return descendant;
   }
   return undefined;
 }
@@ -26,7 +25,9 @@ export function findSpan<T extends LogSchema>(root: SpanBuffer<T>, name: string)
 /** Find all descendant spans matching name (depth-first) */
 export function findAllSpans<T extends LogSchema>(root: SpanBuffer<T>, name: string): SpanBuffer<T>[] {
   const results: SpanBuffer<T>[] = [];
-  collectSpans(root, name, results);
+  for (const descendant of iterateDescendantSpans(root)) {
+    if (resolveMessage(descendant, 0) === name) results.push(descendant);
+  }
   return results;
 }
 
@@ -44,22 +45,17 @@ export function extractFactsFor<T extends LogSchema>(
 /** Collect all descendant span names (flat list, depth-first) */
 export function spanNames<T extends LogSchema>(root: SpanBuffer<T>): string[] {
   const result: string[] = [];
-  collectNames(root._children as SpanBuffer<T>[], result);
-  return result;
-}
-
-function collectSpans<T extends LogSchema>(root: SpanBuffer<T>, name: string, results: SpanBuffer<T>[]): void {
-  for (const child of root._children) {
-    const typed = child as SpanBuffer<T>;
-    if (typed.message_values[0] === name) results.push(typed);
-    collectSpans(typed, name, results);
+  for (const descendant of iterateDescendantSpans(root)) {
+    result.push(resolveMessage(descendant, 0) ?? '');
   }
+  return result;
 }
 
-function collectNames<T extends LogSchema>(children: SpanBuffer<T>[], result: string[]): void {
-  for (const child of children) {
-    const typed = child as SpanBuffer<T>;
-    result.push(typed.message_values[0]);
-    collectNames(typed._children as SpanBuffer<T>[], result);
+function* iterateDescendantSpans<T extends LogSchema>(root: SpanBuffer<T>): Generator<SpanBuffer<T>> {
+  let previousNodeIndex = root._nodeIndex;
+  for (const buffer of iterateSpanTree(root)) {
+    if (buffer._nodeIndex === previousNodeIndex) continue;
+    previousNodeIndex = buffer._nodeIndex;
+    yield buffer;
   }
 }

package/src/lib/testing/stdio-replay.ts

@@ -2,6 +2,7 @@ import { JsBufferStrategy } from '../JsBufferStrategy.js';
 import type { OpContextBinding } from '../opContext/types.js';
 import { createTraceRoot } from '../traceRoot.universal.js';
 import { StdioTracer, type StdioWritable } from '../tracers/StdioTracer.js';
+import { iterateSpanChildren } from '../traceTopology.js';
 import type { AnySpanBuffer } from '../types.js';
 
 function isStdioWritable(value: unknown): value is StdioWritable {
@@ -16,13 +17,31 @@ function makeConsoleWriteStream(write: (line: string) => void): StdioWritable {
     },
   };
 }
+type ReplayFrame = {
+  buffer: AnySpanBuffer;
+  children: Generator<AnySpanBuffer>;
+  replayLifecycle: boolean;
+};
 
-function replayChildSpan(tracer: StdioTracer<OpContextBinding>, buffer: AnySpanBuffer): void {
-  tracer.onSpanStart(buffer);
-  for (const child of buffer._children) {
-    replayChildSpan(tracer, child);
+function replayChildSpans(tracer: StdioTracer<OpContextBinding>, rootBuffer: AnySpanBuffer): void {
+  const stack: ReplayFrame[] = [
+    { buffer: rootBuffer, children: iterateSpanChildren(rootBuffer), replayLifecycle: false },
+  ];
+
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (!frame) break;
+
+    const next = frame.children.next();
+    if (!next.done) {
+      tracer.onSpanStart(next.value);
+      stack.push({ buffer: next.value, children: iterateSpanChildren(next.value), replayLifecycle: true });
+      continue;
+    }
+
+    stack.pop();
+    if (frame.replayLifecycle) tracer.onSpanEnd(frame.buffer);
   }
-  tracer.onSpanEnd(buffer);
 }
 
 export function replayTraceToStdio(binding: OpContextBinding, rootBuffer: AnySpanBuffer): void {
@@ -43,8 +62,6 @@ export function replayTraceToStdio(binding: OpContextBinding, rootBuffer: AnySpa
   });
 
   tracer.onTraceStart(rootBuffer);
-  for (const child of rootBuffer._children) {
-    replayChildSpan(tracer, child);
-  }
+  replayChildSpans(tracer, rootBuffer);
   tracer.onTraceEnd(rootBuffer);
 }

package/src/lib/testing/vitest-harness.ts

@@ -323,7 +323,7 @@ function createRootTracer<B extends OpContextBinding>({
   });
 }
 
-async function closeTracer(tracer: Tracer<OpContextBinding>): Promise<void> {
+async function closeTracer<B extends OpContextBinding>(tracer: Tracer<B>): Promise<void> {
   const close = Reflect.get(tracer, 'close');
   if (typeof close === 'function') {
     await close.call(tracer);

package/src/lib/threadId.ts

@@ -39,11 +39,13 @@ let threadIdBigInt: bigint | null = null;
 function ensureInitialized(): void {
   if (threadIdBytes !== null) return;
 
-  threadIdBytes = new Uint8Array(THREAD_ID_BYTES);
+  // Keep initialization transactional so a failed entropy provider can be retried.
+  const bytes = new Uint8Array(THREAD_ID_BYTES);
 
   // Use Web Crypto API - available in browsers, Node 19+, Deno, Bun, Workers
   if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
-    crypto.getRandomValues(threadIdBytes);
+    crypto.getRandomValues(bytes);
+    threadIdBytes = bytes;
     return;
   }
 
@@ -51,7 +53,8 @@ function ensureInitialized(): void {
   try {
     const nodeCrypto = require('node:crypto');
     if (nodeCrypto && typeof nodeCrypto.randomFillSync === 'function') {
-      nodeCrypto.randomFillSync(threadIdBytes);
+      nodeCrypto.randomFillSync(bytes);
+      threadIdBytes = bytes;
       return;
     }
   } catch {