@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/sqlite/sqlite-common.ts

@@ -1,7 +1,9 @@
 import type { SchemaType } from '@smoothbricks/arrow-builder';
 import { hasOwn, hasOwnString, isRecord } from '@smoothbricks/validation';
+import { resolveEntryType, resolveMessage } from '../resolveMessage.js';
 import type { LogSchema } from '../schema/LogSchema.js';
 import { getSchemaType } from '../schema/typeGuards.js';
+import { iterateSpanTree, NO_NODE } from '../traceTopology.js';
 import type { AnySpanBuffer } from '../types.js';
 
 export const SPANS_TABLE_INIT_SQL = `
@@ -227,36 +229,23 @@ export function parseSqliteTableInfoRows(
   return rows.map((row, rowIndex) => parseSqliteTableInfoRow(row, boundary, rowIndex));
 }
 
-function* walkOverflowSegments(
-  buffer: AnySpanBuffer,
-  traceId: string,
-  spanId: number,
-  parentSpanId: number,
-  rowOffset: number,
-): Generator<SpanSegment> {
-  yield {
-    buffer,
-    traceId,
-    spanId,
-    parentSpanId,
-    rowOffset,
-  };
-
-  if (buffer._overflow) {
-    yield* walkOverflowSegments(buffer._overflow, traceId, spanId, parentSpanId, rowOffset + buffer._writeIndex);
-  }
-}
-
-function* walkTree(buffer: AnySpanBuffer): Generator<SpanSegment> {
-  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: AnySpanBuffer): Generator<SpanSegment> {
-  yield* walkTree(rootBuffer);
+  let logicalNode = NO_NODE;
+  let rowOffset = 0;
+  for (const buffer of iterateSpanTree(rootBuffer)) {
+    if (buffer._nodeIndex !== logicalNode) {
+      logicalNode = buffer._nodeIndex;
+      rowOffset = 0;
+    }
+    yield {
+      buffer,
+      traceId: buffer.trace_id,
+      spanId: buffer.span_id,
+      parentSpanId: buffer.parent_span_id,
+      rowOffset,
+    };
+    rowOffset += buffer._writeIndex;
+  }
 }
 
 export function getMissingSchemaColumns(
@@ -301,9 +290,9 @@ export function readSpanFieldValue(buffer: AnySpanBuffer, fieldName: string, row
 
 export function buildInsertParams(segment: SpanSegment, row: number, activeUserFields: readonly string[]): unknown[] {
   const { buffer, traceId, spanId, parentSpanId, rowOffset } = segment;
-  const entryType = buffer.entry_type[row];
+  const entryType = resolveEntryType(buffer, row);
   const timestampNs = Number(buffer.timestamp[row]);
-  const message = buffer.message_values[row] ?? null;
+  const message = resolveMessage(buffer, row);
 
   const userValues = activeUserFields.map((fieldName) => {
     const directValue = readUserValue(buffer, fieldName, row);

package/src/lib/testing/__tests__/topology-traversal.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it, spyOn } from 'bun:test';
+import { defineOpContext } from '../../defineOpContext.js';
+import { JsBufferStrategy } from '../../JsBufferStrategy.js';
+import { resolveMessage } from '../../resolveMessage.js';
+import { defineLogSchema } from '../../schema/defineLogSchema.js';
+import { ENTRY_TYPE_SPAN_OK, ENTRY_TYPE_SPAN_START } from '../../schema/systemSchema.js';
+import { createTraceRoot } from '../../traceRoot.node.js';
+import { ArrayQueueTracer } from '../../tracers/ArrayQueueTracer.js';
+import { StdioTracer } from '../../tracers/StdioTracer.js';
+import { extractFacts } from '../extractFacts.js';
+import { querySpan } from '../queryable-span.js';
+import { extractFactsFor, findAllSpans, findSpan, spanNames } from '../span-query.js';
+import { replayTraceToStdio } from '../stdio-replay.js';
+
+const schema = defineLogSchema({});
+const binding = defineOpContext({ logSchema: schema });
+
+function createRuntimeRoot(name = 'root') {
+  const tracer = new ArrayQueueTracer(binding, {
+    bufferStrategy: new JsBufferStrategy(),
+    createTraceRoot,
+  });
+  tracer.trace(name, (ctx) => ctx.ok(null));
+  const root = tracer.queue[0];
+  if (!root) throw new Error(`Expected traced root '${name}'`);
+  return { root, tracer };
+}
+
+function addCompletedChild(
+  runtime: ReturnType<typeof createRuntimeRoot>,
+  parent: ReturnType<typeof createRuntimeRoot>['root'],
+  name: string,
+) {
+  const child = runtime.tracer.bufferStrategy.createChildSpanBuffer(parent, parent._opMetadata, parent._opMetadata, 8);
+  child.message(0, name);
+  {
+    const entryTypes = child.entry_type;
+    if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+    entryTypes[0] = ENTRY_TYPE_SPAN_START;
+  }
+  {
+    const entryTypes = child.entry_type;
+    if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+    entryTypes[1] = ENTRY_TYPE_SPAN_OK;
+  }
+  child._writeIndex = 2;
+  return child;
+}
+
+const factOptions = {
+  includeScope: false,
+  includeTags: false,
+  includeLogs: false,
+  includeFF: false,
+  includeMetrics: false,
+};
+
+describe('iterative test-support span traversal', () => {
+  it('preserves depth-first insertion order across facts, queries, and stdio replay', () => {
+    const runtime = createRuntimeRoot();
+    const first = addCompletedChild(runtime, runtime.root, 'first');
+    addCompletedChild(runtime, first, 'target');
+    addCompletedChild(runtime, first, 'nested-last');
+    addCompletedChild(runtime, runtime.root, 'target');
+
+    const expectedNames = ['first', 'target', 'nested-last', 'target'];
+    expect(spanNames(runtime.root)).toEqual(expectedNames);
+    expect(querySpan(runtime.root).names()).toEqual(expectedNames);
+    expect(findAllSpans(runtime.root, 'target').map((span) => resolveMessage(span, 0))).toEqual(['target', 'target']);
+    expect(
+      querySpan(runtime.root)
+        .findAll('target')
+        .map((span) => span.name),
+    ).toEqual(['target', 'target']);
+    expect(findSpan(runtime.root, 'nested-last')).toBe(querySpan(runtime.root).find('nested-last')?.buffer);
+    expect(extractFactsFor(runtime.root, 'first', factOptions)).toEqual(querySpan(first).facts(factOptions));
+
+    expect(Array.from(extractFacts(runtime.root, factOptions))).toEqual([
+      'span:root: started',
+      'span:first: started',
+      'span:target: started',
+      'span:target: ok',
+      'span:nested-last: started',
+      'span:nested-last: ok',
+      'span:first: ok',
+      'span:target: started',
+      'span:target: ok',
+      'span:root: ok',
+    ]);
+
+    const replayEvents: string[] = [];
+    const traceStart = spyOn(StdioTracer.prototype, 'onTraceStart').mockImplementation((buffer) => {
+      replayEvents.push(`trace-start:${resolveMessage(buffer, 0)}`);
+    });
+    const spanStart = spyOn(StdioTracer.prototype, 'onSpanStart').mockImplementation((buffer) => {
+      replayEvents.push(`span-start:${resolveMessage(buffer, 0)}`);
+    });
+    const spanEnd = spyOn(StdioTracer.prototype, 'onSpanEnd').mockImplementation((buffer) => {
+      replayEvents.push(`span-end:${resolveMessage(buffer, 0)}`);
+    });
+    const traceEnd = spyOn(StdioTracer.prototype, 'onTraceEnd').mockImplementation((buffer) => {
+      replayEvents.push(`trace-end:${resolveMessage(buffer, 0)}`);
+    });
+
+    try {
+      replayTraceToStdio(binding, runtime.root);
+    } finally {
+      traceStart.mockRestore();
+      spanStart.mockRestore();
+      spanEnd.mockRestore();
+      traceEnd.mockRestore();
+    }
+
+    expect(replayEvents).toEqual([
+      'trace-start:root',
+      'span-start:first',
+      'span-start:target',
+      'span-end:target',
+      'span-start:nested-last',
+      'span-end:nested-last',
+      'span-end:first',
+      'span-start:target',
+      'span-end:target',
+      'trace-end:root',
+    ]);
+  });
+
+  it('handles a tree deeper than the JavaScript call stack in every public test-support traversal', () => {
+    const runtime = createRuntimeRoot();
+    const edgeCount = 20_000;
+    let parent = runtime.root;
+
+    for (let depth = 0; depth < edgeCount; depth++) {
+      parent = addCompletedChild(runtime, parent, depth === edgeCount - 1 ? 'deepest' : 'level');
+    }
+
+    const names = spanNames(runtime.root);
+    expect(names).toHaveLength(edgeCount);
+    expect(names[0]).toBe('level');
+    expect(names[edgeCount - 1]).toBe('deepest');
+    expect(findSpan(runtime.root, 'deepest')).toBe(parent);
+    expect(querySpan(runtime.root).find('deepest')?.buffer).toBe(parent);
+
+    const facts = Array.from(extractFacts(runtime.root, factOptions));
+    expect(facts).toHaveLength((edgeCount + 1) * 2);
+    expect(facts[0]).toBe('span:root: started');
+    expect(facts[edgeCount]).toBe('span:deepest: started');
+    expect(facts[edgeCount + 1]).toBe('span:deepest: ok');
+    expect(facts[facts.length - 1]).toBe('span:root: ok');
+
+    let replayedStarts = 0;
+    let replayedEnds = 0;
+    const spanStart = spyOn(StdioTracer.prototype, 'onSpanStart').mockImplementation(() => {
+      replayedStarts++;
+    });
+    const spanEnd = spyOn(StdioTracer.prototype, 'onSpanEnd').mockImplementation(() => {
+      replayedEnds++;
+    });
+    const traceStart = spyOn(StdioTracer.prototype, 'onTraceStart').mockImplementation(() => {});
+    const traceEnd = spyOn(StdioTracer.prototype, 'onTraceEnd').mockImplementation(() => {});
+
+    try {
+      replayTraceToStdio(binding, runtime.root);
+    } finally {
+      spanStart.mockRestore();
+      spanEnd.mockRestore();
+      traceStart.mockRestore();
+      traceEnd.mockRestore();
+    }
+
+    expect(replayedStarts).toBe(edgeCount);
+    expect(replayedEnds).toBe(edgeCount);
+  });
+});

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

@@ -21,7 +21,8 @@ describe('vitest harness tracer defaults', () => {
     const tracer = makeVitestTestTracer({ binding: vitestBinding });
     installVitestTestTracing(tracer);
 
-    expect(getTracer()).toBe(tracer.getTracer());
+    // Global accessor erases the concrete binding generic; assert identity directly.
+    expect(Object.is(getTracer(), tracer.getTracer())).toBe(true);
   });
 
   it('routes initTraceTestRun through the active suite tracer path', () => {

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

@@ -179,6 +179,38 @@ function extendBindingLogSchema<
   return extendedBinding;
 }
 
+type RuntimeHarnessBinding<
+  TFields extends SchemaFields,
+  FF extends FeatureFlagSchema,
+  Deps extends DepsConfig,
+  UserCtx extends Record<string, unknown>,
+  TExt extends SchemaFields,
+> = OpContextBinding<LogSchema<TFields & (BunTestHarnessBuiltins | HarnessSchema<TExt>)>, FF, Deps, UserCtx>;
+
+function createRuntimeHarnessBinding<
+  TFields extends SchemaFields,
+  FF extends FeatureFlagSchema,
+  Deps extends DepsConfig,
+  UserCtx extends Record<string, unknown>,
+  TExt extends SchemaFields,
+>(
+  binding: OpContextBinding<LogSchema<TFields>, FF, Deps, UserCtx>,
+  options: BunTestSetupOptions<TExt> | undefined,
+): RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt> {
+  const harnessSchema: BunTestHarnessBuiltins | HarnessSchema<TExt> =
+    options?.extraTestColumns === undefined
+      ? buildHarnessSchemaExtensions(binding, undefined)
+      : buildHarnessSchemaExtensions(binding, options.extraTestColumns);
+  return extendBindingLogSchema<
+    OpContextBinding<LogSchema<TFields>, FF, Deps, UserCtx>,
+    TFields,
+    FF,
+    Deps,
+    UserCtx,
+    BunTestHarnessBuiltins | HarnessSchema<TExt>
+  >(binding, harnessSchema);
+}
+
 function isTruthyEnvFlag(value: unknown): boolean {
   return value === true || value === '1' || value === 'true';
 }
@@ -207,6 +239,15 @@ function isTracerForBinding<B extends OpContextBinding>(value: unknown, binding:
   );
 }
 
+function isTracerInstance(value: unknown): value is Tracer<OpContextBinding> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof Reflect.get(value, 'trace') === 'function' &&
+    typeof Reflect.get(value, 'flush') === 'function'
+  );
+}
+
 function isVerboseTraceEnabled(explicitVerbose: boolean | undefined): boolean {
   if (explicitVerbose !== undefined) {
     return explicitVerbose;
@@ -293,14 +334,19 @@ export interface BunTestSuiteTracer<B extends OpContextBinding> {
 export type BunTestSuiteUseTestTracer<
   B extends OpContextBinding,
   TExt extends SchemaFields = Record<never, never>,
-> = ReturnType<typeof makeBunTestSuiteTracer<B, TExt>>['useTestTracer'];
+> = BunTestTracerInstance<ExtendBindingLogSchema<B, HarnessSchema<TExt>>>;
 
 export type TestTracer<
   B extends OpContextBinding,
   TExt extends SchemaFields = Record<never, never>,
 > = BunTestSuiteUseTestTracer<B, TExt>;
 
-type ActiveBunTestTracer = BunTestTracerInstance<OpContextBinding>;
+export interface ActiveBunTestTracer {
+  setup(): void;
+  useTestSpan(): unknown;
+  getTracer(): unknown;
+  createBunTestMock<TModule extends BunTestModuleShape>(bunTestModule: TModule): TModule;
+}
 
 let _activeSuiteTracer: ActiveBunTestTracer | null = null;
 
@@ -326,7 +372,7 @@ export function makeBunTestSuiteTracer<B extends OpContextBinding, TExt extends
 export function makeBunTestSuiteTracer<B extends OpContextBinding, TExt extends SchemaFields = Record<never, never>>(
   binding: B,
   options?: BunTestSetupOptions<TExt>,
-): BunTestSuiteTracer<OpContextBinding> {
+) {
   const useTestTracer = createTestTracerInstance(binding, options);
   return {
     useTestTracer,
@@ -357,12 +403,7 @@ export function defineTestTracer<B extends OpContextBinding>(
   return {
     opContext: binding,
     extraTestColumns: options?.extraTestColumns,
-    // WHY no re-validation: the global useTestSpan() already validates against
-    // the active suite tracer's (extended) binding. Re-checking against the
-    // original binding fails when extraTestColumns extend the schema, because
-    // the span's _schema is the extended LogSchema, not the original.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- WHY: useTestSpan() returns SpanContext typed to the suite binding; narrowing to OpContextOf<B> is safe because initTraceTestRun validates the binding matches
-    useTestSpan: () => useTestSpan() as SpanContext<OpContextOf<B>>,
+    useTestSpan: () => useTestSpan<B>(),
   };
 }
 
@@ -382,31 +423,37 @@ export function makeTestTracer<B extends OpContextBinding, TExt extends SchemaFi
 export function makeTestTracer<B extends OpContextBinding, TExt extends SchemaFields = Record<never, never>>(
   binding: B,
   options?: BunTestSetupOptions<TExt>,
-): BunTestTracerInstance<OpContextBinding> {
+) {
   return createTestTracerInstance(binding, options);
 }
-function createTestTracerInstance<B extends OpContextBinding, TExt extends SchemaFields = Record<never, never>>(
-  binding: B,
+function createTestTracerInstance<
+  TFields extends SchemaFields,
+  FF extends FeatureFlagSchema,
+  Deps extends DepsConfig,
+  UserCtx extends Record<string, unknown>,
+  TExt extends SchemaFields = Record<never, never>,
+>(
+  binding: OpContextBinding<LogSchema<TFields>, FF, Deps, UserCtx>,
   options?: BunTestSetupOptions<TExt>,
-): BunTestTracerInstance<OpContextBinding> {
-  let activeBinding: OpContextBinding | null = null;
-  let tracer: Tracer<OpContextBinding> | null = null;
+): BunTestTracerInstance<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> {
+  let activeBinding: RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt> | null = null;
+  let tracer: Tracer<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> | null = null;
   let verboseTrace = false;
-  let rootCtx: SpanContext<OpContext> | null = null;
+  let rootCtx: HarnessSpanContext<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> | null = null;
   let resolveTestRun: (() => void) | null = null;
   let rootTracePromise: Promise<unknown> | null = null;
   let isSetup = false;
 
-  const als = new AsyncLocalStorage<SpanContext<OpContext>>();
+  const als = new AsyncLocalStorage<HarnessSpanContext<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>>>();
 
-  function assertRootCtx(): SpanContext<OpContext> {
+  function assertRootCtx(): HarnessSpanContext<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> {
     if (!rootCtx || !activeBinding || !isSpanContextForBinding(rootCtx, activeBinding)) {
       throw new Error('Call setup() before wiring bun:test wrappers');
     }
     return rootCtx;
   }
 
-  function assertTracer(): Tracer<OpContextBinding> {
+  function assertTracer(): Tracer<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> {
     if (!tracer || !activeBinding || !isTracerForBinding(tracer, activeBinding)) {
       throw new Error('Call setup() in preload before tests');
     }
@@ -510,11 +557,7 @@ function createTestTracerInstance<B extends OpContextBinding, TExt extends Schem
       }
       isSetup = true;
 
-      const harnessSchema =
-        options?.extraTestColumns === undefined
-          ? buildHarnessSchemaExtensions(binding, undefined)
-          : buildHarnessSchemaExtensions(binding, options.extraTestColumns);
-      const extendedBinding = extendBindingLogSchema(binding, harnessSchema);
+      const extendedBinding = createRuntimeHarnessBinding(binding, options);
       activeBinding = extendedBinding;
 
       verboseTrace = isVerboseTraceEnabled(options?.verbose);
@@ -526,7 +569,7 @@ function createTestTracerInstance<B extends OpContextBinding, TExt extends Schem
       });
 
       tracer = activeTracer;
-      rootTracePromise = activeTracer.trace('test-run', (ctx: SpanContext<OpContext>) => {
+      rootTracePromise = activeTracer.trace('test-run', (ctx) => {
         rootCtx = ctx;
         return new Promise<void>((resolve) => {
           resolveTestRun = resolve;
@@ -570,7 +613,7 @@ function createTestTracerInstance<B extends OpContextBinding, TExt extends Schem
       });
     },
 
-    useTestSpan(): SpanContext<OpContext> {
+    useTestSpan(): HarnessSpanContext<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> {
       const ctx = als.getStore();
       if (!ctx || !activeBinding || !isSpanContextForBinding(ctx, activeBinding)) {
         throw new Error('useTestSpan() called outside of a traced it()');
@@ -578,7 +621,7 @@ function createTestTracerInstance<B extends OpContextBinding, TExt extends Schem
       return ctx;
     },
 
-    getTracer(): Tracer<OpContextBinding> {
+    getTracer(): Tracer<RuntimeHarnessBinding<TFields, FF, Deps, UserCtx, TExt>> {
       return assertTracer();
     },
 
@@ -601,11 +644,11 @@ function createTestTracerInstance<B extends OpContextBinding, TExt extends Schem
 }
 
 // Global singleton — one root tracer for the entire bun test run
-let _tracer: Tracer<OpContextBinding> | null = null;
+let _tracer: unknown = null;
 let _verboseTrace = false;
 
 // Root span context, its resolver, and the trace promise — one root per test run
-let _rootCtx: SpanContext<OpContext> | null = null;
+let _rootCtx: unknown = null;
 let _resolveTestRun: (() => void) | null = null;
 let _rootTracePromise: Promise<unknown> | null = null;
 
@@ -630,20 +673,20 @@ export function initTraceTestRun<B extends OpContextBinding>(opContext: B, optio
 
   _verboseTrace = isVerboseTraceEnabled(options?.verbose);
 
-  _tracer = createRootTracer({
+  const tracer = createRootTracer({
     binding: extendedBinding,
     sqlite: options?.sqlite,
     verbose: _verboseTrace,
   });
+  _tracer = tracer;
 
   // Create the single root trace — a long-lived promise keeps it alive
-  const tracer = _tracer;
-  _rootTracePromise = tracer.trace('test-run', (ctx: SpanContext<OpContext>) => {
+  _rootTracePromise = tracer.trace('test-run', (ctx) => {
     _rootCtx = ctx;
     return new Promise<void>((resolve) => {
       _resolveTestRun = resolve;
     });
-  }) as Promise<unknown>;
+  });
 
   // Register global teardown — resolve root, wait for span-end, then flush tracer outputs
   _afterAll(async () => {
@@ -663,12 +706,12 @@ export function initTraceTestRun<B extends OpContextBinding>(opContext: B, optio
       _rootTracePromise = null;
     }
 
-    if (_tracer) {
+    if (isTracerInstance(_tracer)) {
       try {
         cleanupDebug('global.tracer.flush:start', { tracer: _tracer.constructor.name });
         await _tracer.flush();
         cleanupDebug('global.tracer.flush:end', { tracer: _tracer.constructor.name });
-        if (options?.sqlite && _rootCtx) {
+        if (options?.sqlite && isSpanContext(_rootCtx)) {
           const traceId = _rootCtx.buffer.trace_id;
           const dbPath = options.sqlite.dbPath ?? '.trace-results.db';
           console.log(`\n[trace] trace_id: ${traceId} → ${dbPath}`);
@@ -695,7 +738,7 @@ export function initTraceTestRun<B extends OpContextBinding>(opContext: B, optio
  * @param bunTestModule - The original bun:test namespace (`import * as bunTest from 'bun:test'`)
  */
 export function createBunTestMock<TModule extends BunTestModuleShape>(bunTestModule: TModule): TModule {
-  if (!_rootCtx) {
+  if (!isSpanContext(_rootCtx)) {
     if (_activeSuiteTracer) {
       return _activeSuiteTracer.createBunTestMock(bunTestModule);
     }
@@ -734,7 +777,7 @@ export function createBunTestMock<TModule extends BunTestModuleShape>(bunTestMod
     // Capture describe path at registration time (synchronous)
     const describePath = describeStack.length > 0 ? describeStack.join(' > ') : null;
     return origIt(name, () =>
-      rootCtx.span(name, async (ctx: SpanContext<OpContext>) => {
+      rootCtx.span(name, async (ctx) => {
         writeDescribeTag(ctx.tag, describePath);
         try {
           await als.run(ctx, fn);
@@ -775,10 +818,14 @@ export function createBunTestMock<TModule extends BunTestModuleShape>(bunTestMod
  * `useTestSpan()` preserves the suite-local schema extension instead of falling
  * back to the erased global singleton shape.
  */
-export function useTestSpan<TCtx extends SpanContext<OpContextOf<OpContextBinding>>>(): TCtx;
-export function useTestSpan(): SpanContext<OpContextOf<OpContextBinding>> {
+export function useTestSpan<B extends OpContextBinding>(): SpanContext<OpContextOf<B>>;
+export function useTestSpan(): unknown {
   if (_activeSuiteTracer) {
-    return _activeSuiteTracer.useTestSpan();
+    const ctx = _activeSuiteTracer.useTestSpan();
+    if (!isSpanContext<OpContextOf<OpContextBinding>>(ctx)) {
+      throw new TypeError('Active test tracer returned an invalid span context');
+    }
+    return ctx;
   }
 
   const ctx = _als.getStore();
@@ -795,10 +842,14 @@ export function useTestSpan(): SpanContext<OpContextOf<OpContextBinding>> {
  */
 export function getTracer(): Tracer<OpContextBinding> {
   if (_activeSuiteTracer) {
-    return _activeSuiteTracer.getTracer();
+    const tracer = _activeSuiteTracer.getTracer();
+    if (!isTracerInstance(tracer)) {
+      throw new TypeError('Active test tracer returned an invalid tracer');
+    }
+    return tracer;
   }
 
-  if (!_tracer) throw new Error('Call initTraceTestRun() in preload before tests');
+  if (!isTracerInstance(_tracer)) throw new Error('Call initTraceTestRun() in preload before tests');
   return _tracer;
 }
 
@@ -887,7 +938,7 @@ assignOptionalBoundTestFunction(describe, 'if', _describe, _describe);
 export function it(name: string, fn: () => void | Promise<void>): void {
   const describePath = _standaloneDescribeStack.length > 0 ? _standaloneDescribeStack.join(' > ') : null;
   _it(name, () => {
-    if (!_rootCtx) throw new Error('Call initTraceTestRun() in preload before tests');
+    if (!isSpanContext(_rootCtx)) throw new Error('Call initTraceTestRun() in preload before tests');
     return _rootCtx.span(name, async (ctx: SpanContext<OpContext>) => {
       writeDescribeTag(ctx.tag, describePath);
       try {