@noego/wood 0.4.0 → 0.4.1

package/dist/trace-testing/trace_assertions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace-testing/trace_assertions.ts"],"sourcesContent":["import type { TraceEvent } from '../tracing/index.js';\nimport { createTraceQuery, type TraceFilter, type TraceQuery } from './trace_query.js';\n\nexport type TraceAssertions = TraceQuery & {\n  expectCount(filter: TraceFilter, expectedCount: number): void;\n  expectNone(filter: TraceFilter): void;\n  expectOnce(filter: TraceFilter): void;\n  expectSequence(filters: TraceFilter[]): void;\n  expectUniqueBy(filter: TraceFilter, path: string): void;\n};\n\ntype TraceSource = TraceEvent[] | (() => TraceEvent[]);\n\nexport function createTraceAssertions(source: TraceSource): TraceAssertions {\n  const query = createTraceQuery(source);\n  return {\n    ...query,\n    expectCount(filter, expectedCount) {\n      const actual = query.count(filter);\n      if (actual !== expectedCount) {\n        throw new Error(`Expected ${expectedCount} trace events for ${formatFilter(filter)}, found ${actual}.`);\n      }\n    },\n    expectNone(filter) {\n      const actual = query.count(filter);\n      if (actual !== 0) {\n        throw new Error(`Expected no trace events for ${formatFilter(filter)}, found ${actual}.`);\n      }\n    },\n    expectOnce(filter) {\n      const actual = query.count(filter);\n      if (actual !== 1) {\n        throw new Error(`Expected one trace event for ${formatFilter(filter)}, found ${actual}.`);\n      }\n    },\n    expectSequence(filters) {\n      if (!query.sequence(filters)) {\n        throw new Error(`Expected trace sequence ${formatFilter(filters)}.`);\n      }\n    },\n    expectUniqueBy(filter, path) {\n      if (!query.uniqueBy(filter, path)) {\n        throw new Error(`Expected trace values at \"${path}\" to be unique for ${formatFilter(filter)}.`);\n      }\n    },\n  };\n}\n\nfunction formatFilter(value: unknown): string {\n  if (typeof value === 'function') {\n    return '[predicate]';\n  }\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,yBAAoE;AAY7D,SAAS,sBAAsB,QAAsC;AAC1E,QAAM,YAAQ,qCAAiB,MAAM;AACrC,SAAO;AAAA,IACL,GAAG;AAAA,IACH,YAAY,QAAQ,eAAe;AACjC,YAAM,SAAS,MAAM,MAAM,MAAM;AACjC,UAAI,WAAW,eAAe;AAC5B,cAAM,IAAI,MAAM,YAAY,aAAa,qBAAqB,aAAa,MAAM,CAAC,WAAW,MAAM,GAAG;AAAA,MACxG;AAAA,IACF;AAAA,IACA,WAAW,QAAQ;AACjB,YAAM,SAAS,MAAM,MAAM,MAAM;AACjC,UAAI,WAAW,GAAG;AAChB,cAAM,IAAI,MAAM,gCAAgC,aAAa,MAAM,CAAC,WAAW,MAAM,GAAG;AAAA,MAC1F;AAAA,IACF;AAAA,IACA,WAAW,QAAQ;AACjB,YAAM,SAAS,MAAM,MAAM,MAAM;AACjC,UAAI,WAAW,GAAG;AAChB,cAAM,IAAI,MAAM,gCAAgC,aAAa,MAAM,CAAC,WAAW,MAAM,GAAG;AAAA,MAC1F;AAAA,IACF;AAAA,IACA,eAAe,SAAS;AACtB,UAAI,CAAC,MAAM,SAAS,OAAO,GAAG;AAC5B,cAAM,IAAI,MAAM,2BAA2B,aAAa,OAAO,CAAC,GAAG;AAAA,MACrE;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,MAAM;AAC3B,UAAI,CAAC,MAAM,SAAS,QAAQ,IAAI,GAAG;AACjC,cAAM,IAAI,MAAM,6BAA6B,IAAI,sBAAsB,aAAa,MAAM,CAAC,GAAG;AAAA,MAChG;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,aAAa,OAAwB;AAC5C,MAAI,OAAO,UAAU,YAAY;AAC/B,WAAO;AAAA,EACT;AACA,MAAI;AACF,WAAO,KAAK,UAAU,KAAK;AAAA,EAC7B,QAAQ;AACN,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;","names":[]}

package/dist/trace-testing/trace_assertions.d.cts

@@ -0,0 +1,15 @@
+import { TraceEvent } from '../tracing/trace_hub.cjs';
+import { TraceQuery, TraceFilter } from './trace_query.cjs';
+import 'rxjs';
+
+type TraceAssertions = TraceQuery & {
+    expectCount(filter: TraceFilter, expectedCount: number): void;
+    expectNone(filter: TraceFilter): void;
+    expectOnce(filter: TraceFilter): void;
+    expectSequence(filters: TraceFilter[]): void;
+    expectUniqueBy(filter: TraceFilter, path: string): void;
+};
+type TraceSource = TraceEvent[] | (() => TraceEvent[]);
+declare function createTraceAssertions(source: TraceSource): TraceAssertions;
+
+export { type TraceAssertions, createTraceAssertions };

package/dist/trace-testing/trace_assertions.d.ts

@@ -0,0 +1,15 @@
+import { TraceEvent } from '../tracing/trace_hub.js';
+import { TraceQuery, TraceFilter } from './trace_query.js';
+import 'rxjs';
+
+type TraceAssertions = TraceQuery & {
+    expectCount(filter: TraceFilter, expectedCount: number): void;
+    expectNone(filter: TraceFilter): void;
+    expectOnce(filter: TraceFilter): void;
+    expectSequence(filters: TraceFilter[]): void;
+    expectUniqueBy(filter: TraceFilter, path: string): void;
+};
+type TraceSource = TraceEvent[] | (() => TraceEvent[]);
+declare function createTraceAssertions(source: TraceSource): TraceAssertions;
+
+export { type TraceAssertions, createTraceAssertions };

package/dist/trace-testing/trace_assertions.js

@@ -0,0 +1,49 @@
+import { createTraceQuery } from "./trace_query.js";
+function createTraceAssertions(source) {
+  const query = createTraceQuery(source);
+  return {
+    ...query,
+    expectCount(filter, expectedCount) {
+      const actual = query.count(filter);
+      if (actual !== expectedCount) {
+        throw new Error(`Expected ${expectedCount} trace events for ${formatFilter(filter)}, found ${actual}.`);
+      }
+    },
+    expectNone(filter) {
+      const actual = query.count(filter);
+      if (actual !== 0) {
+        throw new Error(`Expected no trace events for ${formatFilter(filter)}, found ${actual}.`);
+      }
+    },
+    expectOnce(filter) {
+      const actual = query.count(filter);
+      if (actual !== 1) {
+        throw new Error(`Expected one trace event for ${formatFilter(filter)}, found ${actual}.`);
+      }
+    },
+    expectSequence(filters) {
+      if (!query.sequence(filters)) {
+        throw new Error(`Expected trace sequence ${formatFilter(filters)}.`);
+      }
+    },
+    expectUniqueBy(filter, path) {
+      if (!query.uniqueBy(filter, path)) {
+        throw new Error(`Expected trace values at "${path}" to be unique for ${formatFilter(filter)}.`);
+      }
+    }
+  };
+}
+function formatFilter(value) {
+  if (typeof value === "function") {
+    return "[predicate]";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+export {
+  createTraceAssertions
+};
+//# sourceMappingURL=trace_assertions.js.map

package/dist/trace-testing/trace_assertions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace-testing/trace_assertions.ts"],"sourcesContent":["import type { TraceEvent } from '../tracing/index.js';\nimport { createTraceQuery, type TraceFilter, type TraceQuery } from './trace_query.js';\n\nexport type TraceAssertions = TraceQuery & {\n  expectCount(filter: TraceFilter, expectedCount: number): void;\n  expectNone(filter: TraceFilter): void;\n  expectOnce(filter: TraceFilter): void;\n  expectSequence(filters: TraceFilter[]): void;\n  expectUniqueBy(filter: TraceFilter, path: string): void;\n};\n\ntype TraceSource = TraceEvent[] | (() => TraceEvent[]);\n\nexport function createTraceAssertions(source: TraceSource): TraceAssertions {\n  const query = createTraceQuery(source);\n  return {\n    ...query,\n    expectCount(filter, expectedCount) {\n      const actual = query.count(filter);\n      if (actual !== expectedCount) {\n        throw new Error(`Expected ${expectedCount} trace events for ${formatFilter(filter)}, found ${actual}.`);\n      }\n    },\n    expectNone(filter) {\n      const actual = query.count(filter);\n      if (actual !== 0) {\n        throw new Error(`Expected no trace events for ${formatFilter(filter)}, found ${actual}.`);\n      }\n    },\n    expectOnce(filter) {\n      const actual = query.count(filter);\n      if (actual !== 1) {\n        throw new Error(`Expected one trace event for ${formatFilter(filter)}, found ${actual}.`);\n      }\n    },\n    expectSequence(filters) {\n      if (!query.sequence(filters)) {\n        throw new Error(`Expected trace sequence ${formatFilter(filters)}.`);\n      }\n    },\n    expectUniqueBy(filter, path) {\n      if (!query.uniqueBy(filter, path)) {\n        throw new Error(`Expected trace values at \"${path}\" to be unique for ${formatFilter(filter)}.`);\n      }\n    },\n  };\n}\n\nfunction formatFilter(value: unknown): string {\n  if (typeof value === 'function') {\n    return '[predicate]';\n  }\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n"],"mappings":"AACA,SAAS,wBAA2D;AAY7D,SAAS,sBAAsB,QAAsC;AAC1E,QAAM,QAAQ,iBAAiB,MAAM;AACrC,SAAO;AAAA,IACL,GAAG;AAAA,IACH,YAAY,QAAQ,eAAe;AACjC,YAAM,SAAS,MAAM,MAAM,MAAM;AACjC,UAAI,WAAW,eAAe;AAC5B,cAAM,IAAI,MAAM,YAAY,aAAa,qBAAqB,aAAa,MAAM,CAAC,WAAW,MAAM,GAAG;AAAA,MACxG;AAAA,IACF;AAAA,IACA,WAAW,QAAQ;AACjB,YAAM,SAAS,MAAM,MAAM,MAAM;AACjC,UAAI,WAAW,GAAG;AAChB,cAAM,IAAI,MAAM,gCAAgC,aAAa,MAAM,CAAC,WAAW,MAAM,GAAG;AAAA,MAC1F;AAAA,IACF;AAAA,IACA,WAAW,QAAQ;AACjB,YAAM,SAAS,MAAM,MAAM,MAAM;AACjC,UAAI,WAAW,GAAG;AAChB,cAAM,IAAI,MAAM,gCAAgC,aAAa,MAAM,CAAC,WAAW,MAAM,GAAG;AAAA,MAC1F;AAAA,IACF;AAAA,IACA,eAAe,SAAS;AACtB,UAAI,CAAC,MAAM,SAAS,OAAO,GAAG;AAC5B,cAAM,IAAI,MAAM,2BAA2B,aAAa,OAAO,CAAC,GAAG;AAAA,MACrE;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,MAAM;AAC3B,UAAI,CAAC,MAAM,SAAS,QAAQ,IAAI,GAAG;AACjC,cAAM,IAAI,MAAM,6BAA6B,IAAI,sBAAsB,aAAa,MAAM,CAAC,GAAG;AAAA,MAChG;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,aAAa,OAAwB;AAC5C,MAAI,OAAO,UAAU,YAAY;AAC/B,WAAO;AAAA,EACT;AACA,MAAI;AACF,WAAO,KAAK,UAAU,KAAK;AAAA,EAC7B,QAAQ;AACN,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;","names":[]}

package/dist/trace-testing/trace_query.cjs

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trace_query_exports = {};
+__export(trace_query_exports, {
+  createTraceQuery: () => createTraceQuery,
+  matchesTrace: () => matchesTrace,
+  readPath: () => readPath
+});
+module.exports = __toCommonJS(trace_query_exports);
+function createTraceQuery(source) {
+  const readEvents = () => Array.isArray(source) ? source.slice() : source().slice();
+  return {
+    all: () => readEvents(),
+    filter: (filter) => readEvents().filter((event) => matchesTrace(event, filter)),
+    count: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length,
+    countByType: (types) => countTracesByType(readEvents(), types),
+    payloads: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).map((event) => event.payload).filter((payload) => isRecord(payload)),
+    first: (filter) => readEvents().find((event) => matchesTrace(event, filter)) ?? null,
+    last: (filter) => findLastTrace(readEvents(), filter),
+    sequence: (filters) => includesTraceSequence(readEvents(), filters),
+    none: (filter) => readEvents().every((event) => !matchesTrace(event, filter)),
+    once: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length === 1,
+    uniqueBy: (filter, path) => valuesAtPathAreUnique(readEvents(), filter, path)
+  };
+}
+function matchesTrace(event, filter) {
+  if (typeof filter === "function") {
+    return filter(event);
+  }
+  for (const [path, expected] of Object.entries(filter)) {
+    const actual = readPath(event, path);
+    if (!matchesValue(actual, expected)) {
+      return false;
+    }
+  }
+  return true;
+}
+function readPath(value, path) {
+  let current = value;
+  for (const segment of path.split(".")) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function countTracesByType(traces, types) {
+  const allowedTypes = types ? new Set(types) : null;
+  const counts = {};
+  for (const trace of traces) {
+    if (allowedTypes && !allowedTypes.has(trace.type)) {
+      continue;
+    }
+    counts[trace.type] = (counts[trace.type] ?? 0) + 1;
+  }
+  return counts;
+}
+function findLastTrace(traces, filter) {
+  for (let index = traces.length - 1; index >= 0; index -= 1) {
+    const trace = traces[index];
+    if (trace && matchesTrace(trace, filter)) {
+      return trace;
+    }
+  }
+  return null;
+}
+function includesTraceSequence(traces, filters) {
+  let filterIndex = 0;
+  if (filters.length === 0) {
+    return true;
+  }
+  for (const trace of traces) {
+    const filter = filters[filterIndex];
+    if (!filter || !matchesTrace(trace, filter)) {
+      continue;
+    }
+    filterIndex += 1;
+    if (filterIndex === filters.length) {
+      return true;
+    }
+  }
+  return false;
+}
+function valuesAtPathAreUnique(traces, filter, path) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const trace of traces) {
+    if (!matchesTrace(trace, filter)) {
+      continue;
+    }
+    const value = readPath(trace, path);
+    if (seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+  }
+  return true;
+}
+function matchesValue(actual, expected) {
+  if (expected instanceof RegExp) {
+    return typeof actual === "string" && expected.test(actual);
+  }
+  if (typeof expected === "function") {
+    return Boolean(expected(actual));
+  }
+  if (isRecord(expected)) {
+    return isRecord(actual) && objectContains(actual, expected);
+  }
+  return Object.is(actual, expected);
+}
+function objectContains(actual, expected) {
+  for (const [key, value] of Object.entries(expected)) {
+    if (!matchesValue(actual[key], value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTraceQuery,
+  matchesTrace,
+  readPath
+});
+//# sourceMappingURL=trace_query.cjs.map

package/dist/trace-testing/trace_query.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace-testing/trace_query.ts"],"sourcesContent":["import type { TraceEvent } from '../tracing/index.js';\n\nexport type TraceFilter =\n  | ((event: TraceEvent) => boolean)\n  | Record<string, unknown>;\n\nexport type TraceCountSummary = Record<string, number>;\n\nexport type TraceQuery = {\n  all(): TraceEvent[];\n  filter(filter: TraceFilter): TraceEvent[];\n  count(filter: TraceFilter): number;\n  countByType(types?: string[]): TraceCountSummary;\n  payloads(filter: TraceFilter): Record<string, unknown>[];\n  first(filter: TraceFilter): TraceEvent | null;\n  last(filter: TraceFilter): TraceEvent | null;\n  sequence(filters: TraceFilter[]): boolean;\n  none(filter: TraceFilter): boolean;\n  once(filter: TraceFilter): boolean;\n  uniqueBy(filter: TraceFilter, path: string): boolean;\n};\n\ntype TraceSource = TraceEvent[] | (() => TraceEvent[]);\n\nexport function createTraceQuery(source: TraceSource): TraceQuery {\n  const readEvents = () => Array.isArray(source) ? source.slice() : source().slice();\n  return {\n    all: () => readEvents(),\n    filter: (filter) => readEvents().filter((event) => matchesTrace(event, filter)),\n    count: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length,\n    countByType: (types) => countTracesByType(readEvents(), types),\n    payloads: (filter) => readEvents()\n      .filter((event) => matchesTrace(event, filter))\n      .map((event) => event.payload)\n      .filter((payload): payload is Record<string, unknown> => isRecord(payload)),\n    first: (filter) => readEvents().find((event) => matchesTrace(event, filter)) ?? null,\n    last: (filter) => findLastTrace(readEvents(), filter),\n    sequence: (filters) => includesTraceSequence(readEvents(), filters),\n    none: (filter) => readEvents().every((event) => !matchesTrace(event, filter)),\n    once: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length === 1,\n    uniqueBy: (filter, path) => valuesAtPathAreUnique(readEvents(), filter, path),\n  };\n}\n\nexport function matchesTrace(event: TraceEvent, filter: TraceFilter): boolean {\n  if (typeof filter === 'function') {\n    return filter(event);\n  }\n  for (const [path, expected] of Object.entries(filter)) {\n    const actual = readPath(event, path);\n    if (!matchesValue(actual, expected)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function readPath(value: unknown, path: string): unknown {\n  let current = value;\n  for (const segment of path.split('.')) {\n    if (!isRecord(current)) {\n      return undefined;\n    }\n    current = current[segment];\n  }\n  return current;\n}\n\nfunction countTracesByType(traces: TraceEvent[], types?: string[]): TraceCountSummary {\n  const allowedTypes = types ? new Set(types) : null;\n  const counts: TraceCountSummary = {};\n  for (const trace of traces) {\n    if (allowedTypes && !allowedTypes.has(trace.type)) {\n      continue;\n    }\n    counts[trace.type] = (counts[trace.type] ?? 0) + 1;\n  }\n  return counts;\n}\n\nfunction findLastTrace(traces: TraceEvent[], filter: TraceFilter): TraceEvent | null {\n  for (let index = traces.length - 1; index >= 0; index -= 1) {\n    const trace = traces[index];\n    if (trace && matchesTrace(trace, filter)) {\n      return trace;\n    }\n  }\n  return null;\n}\n\nfunction includesTraceSequence(traces: TraceEvent[], filters: TraceFilter[]): boolean {\n  let filterIndex = 0;\n  if (filters.length === 0) {\n    return true;\n  }\n  for (const trace of traces) {\n    const filter = filters[filterIndex];\n    if (!filter || !matchesTrace(trace, filter)) {\n      continue;\n    }\n    filterIndex += 1;\n    if (filterIndex === filters.length) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction valuesAtPathAreUnique(traces: TraceEvent[], filter: TraceFilter, path: string): boolean {\n  const seen = new Set<unknown>();\n  for (const trace of traces) {\n    if (!matchesTrace(trace, filter)) {\n      continue;\n    }\n    const value = readPath(trace, path);\n    if (seen.has(value)) {\n      return false;\n    }\n    seen.add(value);\n  }\n  return true;\n}\n\nfunction matchesValue(actual: unknown, expected: unknown): boolean {\n  if (expected instanceof RegExp) {\n    return typeof actual === 'string' && expected.test(actual);\n  }\n  if (typeof expected === 'function') {\n    return Boolean((expected as (value: unknown) => boolean)(actual));\n  }\n  if (isRecord(expected)) {\n    return isRecord(actual) && objectContains(actual, expected);\n  }\n  return Object.is(actual, expected);\n}\n\nfunction objectContains(actual: Record<string, unknown>, expected: Record<string, unknown>): boolean {\n  for (const [key, value] of Object.entries(expected)) {\n    if (!matchesValue(actual[key], value)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n"],"mappings":"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","names":[]}

package/dist/trace-testing/trace_query.d.cts

@@ -0,0 +1,24 @@
+import { TraceEvent } from '../tracing/trace_hub.cjs';
+import 'rxjs';
+
+type TraceFilter = ((event: TraceEvent) => boolean) | Record<string, unknown>;
+type TraceCountSummary = Record<string, number>;
+type TraceQuery = {
+    all(): TraceEvent[];
+    filter(filter: TraceFilter): TraceEvent[];
+    count(filter: TraceFilter): number;
+    countByType(types?: string[]): TraceCountSummary;
+    payloads(filter: TraceFilter): Record<string, unknown>[];
+    first(filter: TraceFilter): TraceEvent | null;
+    last(filter: TraceFilter): TraceEvent | null;
+    sequence(filters: TraceFilter[]): boolean;
+    none(filter: TraceFilter): boolean;
+    once(filter: TraceFilter): boolean;
+    uniqueBy(filter: TraceFilter, path: string): boolean;
+};
+type TraceSource = TraceEvent[] | (() => TraceEvent[]);
+declare function createTraceQuery(source: TraceSource): TraceQuery;
+declare function matchesTrace(event: TraceEvent, filter: TraceFilter): boolean;
+declare function readPath(value: unknown, path: string): unknown;
+
+export { type TraceCountSummary, type TraceFilter, type TraceQuery, createTraceQuery, matchesTrace, readPath };

package/dist/trace-testing/trace_query.d.ts

@@ -0,0 +1,24 @@
+import { TraceEvent } from '../tracing/trace_hub.js';
+import 'rxjs';
+
+type TraceFilter = ((event: TraceEvent) => boolean) | Record<string, unknown>;
+type TraceCountSummary = Record<string, number>;
+type TraceQuery = {
+    all(): TraceEvent[];
+    filter(filter: TraceFilter): TraceEvent[];
+    count(filter: TraceFilter): number;
+    countByType(types?: string[]): TraceCountSummary;
+    payloads(filter: TraceFilter): Record<string, unknown>[];
+    first(filter: TraceFilter): TraceEvent | null;
+    last(filter: TraceFilter): TraceEvent | null;
+    sequence(filters: TraceFilter[]): boolean;
+    none(filter: TraceFilter): boolean;
+    once(filter: TraceFilter): boolean;
+    uniqueBy(filter: TraceFilter, path: string): boolean;
+};
+type TraceSource = TraceEvent[] | (() => TraceEvent[]);
+declare function createTraceQuery(source: TraceSource): TraceQuery;
+declare function matchesTrace(event: TraceEvent, filter: TraceFilter): boolean;
+declare function readPath(value: unknown, path: string): unknown;
+
+export { type TraceCountSummary, type TraceFilter, type TraceQuery, createTraceQuery, matchesTrace, readPath };

package/dist/trace-testing/trace_query.js

@@ -0,0 +1,118 @@
+function createTraceQuery(source) {
+  const readEvents = () => Array.isArray(source) ? source.slice() : source().slice();
+  return {
+    all: () => readEvents(),
+    filter: (filter) => readEvents().filter((event) => matchesTrace(event, filter)),
+    count: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length,
+    countByType: (types) => countTracesByType(readEvents(), types),
+    payloads: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).map((event) => event.payload).filter((payload) => isRecord(payload)),
+    first: (filter) => readEvents().find((event) => matchesTrace(event, filter)) ?? null,
+    last: (filter) => findLastTrace(readEvents(), filter),
+    sequence: (filters) => includesTraceSequence(readEvents(), filters),
+    none: (filter) => readEvents().every((event) => !matchesTrace(event, filter)),
+    once: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length === 1,
+    uniqueBy: (filter, path) => valuesAtPathAreUnique(readEvents(), filter, path)
+  };
+}
+function matchesTrace(event, filter) {
+  if (typeof filter === "function") {
+    return filter(event);
+  }
+  for (const [path, expected] of Object.entries(filter)) {
+    const actual = readPath(event, path);
+    if (!matchesValue(actual, expected)) {
+      return false;
+    }
+  }
+  return true;
+}
+function readPath(value, path) {
+  let current = value;
+  for (const segment of path.split(".")) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function countTracesByType(traces, types) {
+  const allowedTypes = types ? new Set(types) : null;
+  const counts = {};
+  for (const trace of traces) {
+    if (allowedTypes && !allowedTypes.has(trace.type)) {
+      continue;
+    }
+    counts[trace.type] = (counts[trace.type] ?? 0) + 1;
+  }
+  return counts;
+}
+function findLastTrace(traces, filter) {
+  for (let index = traces.length - 1; index >= 0; index -= 1) {
+    const trace = traces[index];
+    if (trace && matchesTrace(trace, filter)) {
+      return trace;
+    }
+  }
+  return null;
+}
+function includesTraceSequence(traces, filters) {
+  let filterIndex = 0;
+  if (filters.length === 0) {
+    return true;
+  }
+  for (const trace of traces) {
+    const filter = filters[filterIndex];
+    if (!filter || !matchesTrace(trace, filter)) {
+      continue;
+    }
+    filterIndex += 1;
+    if (filterIndex === filters.length) {
+      return true;
+    }
+  }
+  return false;
+}
+function valuesAtPathAreUnique(traces, filter, path) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const trace of traces) {
+    if (!matchesTrace(trace, filter)) {
+      continue;
+    }
+    const value = readPath(trace, path);
+    if (seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+  }
+  return true;
+}
+function matchesValue(actual, expected) {
+  if (expected instanceof RegExp) {
+    return typeof actual === "string" && expected.test(actual);
+  }
+  if (typeof expected === "function") {
+    return Boolean(expected(actual));
+  }
+  if (isRecord(expected)) {
+    return isRecord(actual) && objectContains(actual, expected);
+  }
+  return Object.is(actual, expected);
+}
+function objectContains(actual, expected) {
+  for (const [key, value] of Object.entries(expected)) {
+    if (!matchesValue(actual[key], value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  createTraceQuery,
+  matchesTrace,
+  readPath
+};
+//# sourceMappingURL=trace_query.js.map

package/dist/trace-testing/trace_query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace-testing/trace_query.ts"],"sourcesContent":["import type { TraceEvent } from '../tracing/index.js';\n\nexport type TraceFilter =\n  | ((event: TraceEvent) => boolean)\n  | Record<string, unknown>;\n\nexport type TraceCountSummary = Record<string, number>;\n\nexport type TraceQuery = {\n  all(): TraceEvent[];\n  filter(filter: TraceFilter): TraceEvent[];\n  count(filter: TraceFilter): number;\n  countByType(types?: string[]): TraceCountSummary;\n  payloads(filter: TraceFilter): Record<string, unknown>[];\n  first(filter: TraceFilter): TraceEvent | null;\n  last(filter: TraceFilter): TraceEvent | null;\n  sequence(filters: TraceFilter[]): boolean;\n  none(filter: TraceFilter): boolean;\n  once(filter: TraceFilter): boolean;\n  uniqueBy(filter: TraceFilter, path: string): boolean;\n};\n\ntype TraceSource = TraceEvent[] | (() => TraceEvent[]);\n\nexport function createTraceQuery(source: TraceSource): TraceQuery {\n  const readEvents = () => Array.isArray(source) ? source.slice() : source().slice();\n  return {\n    all: () => readEvents(),\n    filter: (filter) => readEvents().filter((event) => matchesTrace(event, filter)),\n    count: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length,\n    countByType: (types) => countTracesByType(readEvents(), types),\n    payloads: (filter) => readEvents()\n      .filter((event) => matchesTrace(event, filter))\n      .map((event) => event.payload)\n      .filter((payload): payload is Record<string, unknown> => isRecord(payload)),\n    first: (filter) => readEvents().find((event) => matchesTrace(event, filter)) ?? null,\n    last: (filter) => findLastTrace(readEvents(), filter),\n    sequence: (filters) => includesTraceSequence(readEvents(), filters),\n    none: (filter) => readEvents().every((event) => !matchesTrace(event, filter)),\n    once: (filter) => readEvents().filter((event) => matchesTrace(event, filter)).length === 1,\n    uniqueBy: (filter, path) => valuesAtPathAreUnique(readEvents(), filter, path),\n  };\n}\n\nexport function matchesTrace(event: TraceEvent, filter: TraceFilter): boolean {\n  if (typeof filter === 'function') {\n    return filter(event);\n  }\n  for (const [path, expected] of Object.entries(filter)) {\n    const actual = readPath(event, path);\n    if (!matchesValue(actual, expected)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function readPath(value: unknown, path: string): unknown {\n  let current = value;\n  for (const segment of path.split('.')) {\n    if (!isRecord(current)) {\n      return undefined;\n    }\n    current = current[segment];\n  }\n  return current;\n}\n\nfunction countTracesByType(traces: TraceEvent[], types?: string[]): TraceCountSummary {\n  const allowedTypes = types ? new Set(types) : null;\n  const counts: TraceCountSummary = {};\n  for (const trace of traces) {\n    if (allowedTypes && !allowedTypes.has(trace.type)) {\n      continue;\n    }\n    counts[trace.type] = (counts[trace.type] ?? 0) + 1;\n  }\n  return counts;\n}\n\nfunction findLastTrace(traces: TraceEvent[], filter: TraceFilter): TraceEvent | null {\n  for (let index = traces.length - 1; index >= 0; index -= 1) {\n    const trace = traces[index];\n    if (trace && matchesTrace(trace, filter)) {\n      return trace;\n    }\n  }\n  return null;\n}\n\nfunction includesTraceSequence(traces: TraceEvent[], filters: TraceFilter[]): boolean {\n  let filterIndex = 0;\n  if (filters.length === 0) {\n    return true;\n  }\n  for (const trace of traces) {\n    const filter = filters[filterIndex];\n    if (!filter || !matchesTrace(trace, filter)) {\n      continue;\n    }\n    filterIndex += 1;\n    if (filterIndex === filters.length) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction valuesAtPathAreUnique(traces: TraceEvent[], filter: TraceFilter, path: string): boolean {\n  const seen = new Set<unknown>();\n  for (const trace of traces) {\n    if (!matchesTrace(trace, filter)) {\n      continue;\n    }\n    const value = readPath(trace, path);\n    if (seen.has(value)) {\n      return false;\n    }\n    seen.add(value);\n  }\n  return true;\n}\n\nfunction matchesValue(actual: unknown, expected: unknown): boolean {\n  if (expected instanceof RegExp) {\n    return typeof actual === 'string' && expected.test(actual);\n  }\n  if (typeof expected === 'function') {\n    return Boolean((expected as (value: unknown) => boolean)(actual));\n  }\n  if (isRecord(expected)) {\n    return isRecord(actual) && objectContains(actual, expected);\n  }\n  return Object.is(actual, expected);\n}\n\nfunction objectContains(actual: Record<string, unknown>, expected: Record<string, unknown>): boolean {\n  for (const [key, value] of Object.entries(expected)) {\n    if (!matchesValue(actual[key], value)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n"],"mappings":"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","names":[]}

package/dist/trace-testing/trace_scenario.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trace_scenario_exports = {};
+__export(trace_scenario_exports, {
+  createTraceScenario: () => createTraceScenario
+});
+module.exports = __toCommonJS(trace_scenario_exports);
+var import_trace_assertions = require("./trace_assertions.js");
+var import_trace_query = require("./trace_query.js");
+function createTraceScenario(options) {
+  const { trace, artifactPath, ...captureOptions } = options;
+  const capture = trace.capture(captureOptions);
+  const assertions = (0, import_trace_assertions.createTraceAssertions)(() => capture.events());
+  return {
+    capture,
+    trace: assertions,
+    async run(exercise) {
+      try {
+        return await exercise({
+          waitForTrace: (filter, waitOptions) => capture.waitFor((event) => (0, import_trace_query.matchesTrace)(event, filter), waitOptions),
+          trace: assertions
+        });
+      } catch (error) {
+        if (artifactPath) {
+          await capture.writeArtifact(artifactPath).catch(() => void 0);
+        }
+        throw error;
+      }
+    },
+    stop() {
+      capture.stop();
+    },
+    async writeArtifact(targetPath = artifactPath) {
+      if (!targetPath) {
+        throw new Error("Trace artifact path was not provided.");
+      }
+      await capture.writeArtifact(targetPath);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTraceScenario
+});
+//# sourceMappingURL=trace_scenario.cjs.map

package/dist/trace-testing/trace_scenario.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace-testing/trace_scenario.ts"],"sourcesContent":["import type { FrameworkTracer, TraceCapture, TraceCaptureOptions, TraceEvent } from '../tracing/index.js';\nimport { createTraceAssertions, type TraceAssertions } from './trace_assertions.js';\nimport { matchesTrace, type TraceFilter } from './trace_query.js';\n\nexport type TraceScenarioOptions = TraceCaptureOptions & {\n  trace: FrameworkTracer;\n  artifactPath?: string;\n};\n\nexport type TraceScenarioRunContext = {\n  waitForTrace(filter: TraceFilter, options?: { timeoutMs?: number }): Promise<TraceEvent>;\n  trace: TraceAssertions;\n};\n\nexport type TraceScenario = {\n  readonly capture: TraceCapture;\n  readonly trace: TraceAssertions;\n  run<T>(exercise: (context: TraceScenarioRunContext) => T | Promise<T>): Promise<T>;\n  stop(): void;\n  writeArtifact(targetPath?: string): Promise<void>;\n};\n\nexport function createTraceScenario(options: TraceScenarioOptions): TraceScenario {\n  const { trace, artifactPath, ...captureOptions } = options;\n  const capture = trace.capture(captureOptions);\n  const assertions = createTraceAssertions(() => capture.events());\n\n  return {\n    capture,\n    trace: assertions,\n    async run(exercise) {\n      try {\n        return await exercise({\n          waitForTrace: (filter, waitOptions) =>\n            capture.waitFor((event) => matchesTrace(event, filter), waitOptions),\n          trace: assertions,\n        });\n      } catch (error) {\n        if (artifactPath) {\n          await capture.writeArtifact(artifactPath).catch(() => undefined);\n        }\n        throw error;\n      }\n    },\n    stop() {\n      capture.stop();\n    },\n    async writeArtifact(targetPath = artifactPath): Promise<void> {\n      if (!targetPath) {\n        throw new Error('Trace artifact path was not provided.');\n      }\n      await capture.writeArtifact(targetPath);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,8BAA4D;AAC5D,yBAA+C;AAoBxC,SAAS,oBAAoB,SAA8C;AAChF,QAAM,EAAE,OAAO,cAAc,GAAG,eAAe,IAAI;AACnD,QAAM,UAAU,MAAM,QAAQ,cAAc;AAC5C,QAAM,iBAAa,+CAAsB,MAAM,QAAQ,OAAO,CAAC;AAE/D,SAAO;AAAA,IACL;AAAA,IACA,OAAO;AAAA,IACP,MAAM,IAAI,UAAU;AAClB,UAAI;AACF,eAAO,MAAM,SAAS;AAAA,UACpB,cAAc,CAAC,QAAQ,gBACrB,QAAQ,QAAQ,CAAC,cAAU,iCAAa,OAAO,MAAM,GAAG,WAAW;AAAA,UACrE,OAAO;AAAA,QACT,CAAC;AAAA,MACH,SAAS,OAAO;AACd,YAAI,cAAc;AAChB,gBAAM,QAAQ,cAAc,YAAY,EAAE,MAAM,MAAM,MAAS;AAAA,QACjE;AACA,cAAM;AAAA,MACR;AAAA,IACF;AAAA,IACA,OAAO;AACL,cAAQ,KAAK;AAAA,IACf;AAAA,IACA,MAAM,cAAc,aAAa,cAA6B;AAC5D,UAAI,CAAC,YAAY;AACf,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AACA,YAAM,QAAQ,cAAc,UAAU;AAAA,IACxC;AAAA,EACF;AACF;","names":[]}

package/dist/trace-testing/trace_scenario.d.cts

@@ -0,0 +1,27 @@
+import { TraceFilter } from './trace_query.cjs';
+import { TraceAssertions } from './trace_assertions.cjs';
+import { TraceCapture, TraceEvent, TraceCaptureOptions } from '../tracing/trace_hub.cjs';
+import { FrameworkTracer } from '../tracing/trace_provider.cjs';
+import 'rxjs';
+import '@noego/ioc';
+
+type TraceScenarioOptions = TraceCaptureOptions & {
+    trace: FrameworkTracer;
+    artifactPath?: string;
+};
+type TraceScenarioRunContext = {
+    waitForTrace(filter: TraceFilter, options?: {
+        timeoutMs?: number;
+    }): Promise<TraceEvent>;
+    trace: TraceAssertions;
+};
+type TraceScenario = {
+    readonly capture: TraceCapture;
+    readonly trace: TraceAssertions;
+    run<T>(exercise: (context: TraceScenarioRunContext) => T | Promise<T>): Promise<T>;
+    stop(): void;
+    writeArtifact(targetPath?: string): Promise<void>;
+};
+declare function createTraceScenario(options: TraceScenarioOptions): TraceScenario;
+
+export { type TraceScenario, type TraceScenarioOptions, type TraceScenarioRunContext, createTraceScenario };

package/dist/trace-testing/trace_scenario.d.ts

@@ -0,0 +1,27 @@
+import { TraceFilter } from './trace_query.js';
+import { TraceAssertions } from './trace_assertions.js';
+import { TraceCapture, TraceEvent, TraceCaptureOptions } from '../tracing/trace_hub.js';
+import { FrameworkTracer } from '../tracing/trace_provider.js';
+import 'rxjs';
+import '@noego/ioc';
+
+type TraceScenarioOptions = TraceCaptureOptions & {
+    trace: FrameworkTracer;
+    artifactPath?: string;
+};
+type TraceScenarioRunContext = {
+    waitForTrace(filter: TraceFilter, options?: {
+        timeoutMs?: number;
+    }): Promise<TraceEvent>;
+    trace: TraceAssertions;
+};
+type TraceScenario = {
+    readonly capture: TraceCapture;
+    readonly trace: TraceAssertions;
+    run<T>(exercise: (context: TraceScenarioRunContext) => T | Promise<T>): Promise<T>;
+    stop(): void;
+    writeArtifact(targetPath?: string): Promise<void>;
+};
+declare function createTraceScenario(options: TraceScenarioOptions): TraceScenario;
+
+export { type TraceScenario, type TraceScenarioOptions, type TraceScenarioRunContext, createTraceScenario };

package/dist/trace-testing/trace_scenario.js

@@ -0,0 +1,37 @@
+import { createTraceAssertions } from "./trace_assertions.js";
+import { matchesTrace } from "./trace_query.js";
+function createTraceScenario(options) {
+  const { trace, artifactPath, ...captureOptions } = options;
+  const capture = trace.capture(captureOptions);
+  const assertions = createTraceAssertions(() => capture.events());
+  return {
+    capture,
+    trace: assertions,
+    async run(exercise) {
+      try {
+        return await exercise({
+          waitForTrace: (filter, waitOptions) => capture.waitFor((event) => matchesTrace(event, filter), waitOptions),
+          trace: assertions
+        });
+      } catch (error) {
+        if (artifactPath) {
+          await capture.writeArtifact(artifactPath).catch(() => void 0);
+        }
+        throw error;
+      }
+    },
+    stop() {
+      capture.stop();
+    },
+    async writeArtifact(targetPath = artifactPath) {
+      if (!targetPath) {
+        throw new Error("Trace artifact path was not provided.");
+      }
+      await capture.writeArtifact(targetPath);
+    }
+  };
+}
+export {
+  createTraceScenario
+};
+//# sourceMappingURL=trace_scenario.js.map

package/dist/trace-testing/trace_scenario.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace-testing/trace_scenario.ts"],"sourcesContent":["import type { FrameworkTracer, TraceCapture, TraceCaptureOptions, TraceEvent } from '../tracing/index.js';\nimport { createTraceAssertions, type TraceAssertions } from './trace_assertions.js';\nimport { matchesTrace, type TraceFilter } from './trace_query.js';\n\nexport type TraceScenarioOptions = TraceCaptureOptions & {\n  trace: FrameworkTracer;\n  artifactPath?: string;\n};\n\nexport type TraceScenarioRunContext = {\n  waitForTrace(filter: TraceFilter, options?: { timeoutMs?: number }): Promise<TraceEvent>;\n  trace: TraceAssertions;\n};\n\nexport type TraceScenario = {\n  readonly capture: TraceCapture;\n  readonly trace: TraceAssertions;\n  run<T>(exercise: (context: TraceScenarioRunContext) => T | Promise<T>): Promise<T>;\n  stop(): void;\n  writeArtifact(targetPath?: string): Promise<void>;\n};\n\nexport function createTraceScenario(options: TraceScenarioOptions): TraceScenario {\n  const { trace, artifactPath, ...captureOptions } = options;\n  const capture = trace.capture(captureOptions);\n  const assertions = createTraceAssertions(() => capture.events());\n\n  return {\n    capture,\n    trace: assertions,\n    async run(exercise) {\n      try {\n        return await exercise({\n          waitForTrace: (filter, waitOptions) =>\n            capture.waitFor((event) => matchesTrace(event, filter), waitOptions),\n          trace: assertions,\n        });\n      } catch (error) {\n        if (artifactPath) {\n          await capture.writeArtifact(artifactPath).catch(() => undefined);\n        }\n        throw error;\n      }\n    },\n    stop() {\n      capture.stop();\n    },\n    async writeArtifact(targetPath = artifactPath): Promise<void> {\n      if (!targetPath) {\n        throw new Error('Trace artifact path was not provided.');\n      }\n      await capture.writeArtifact(targetPath);\n    },\n  };\n}\n"],"mappings":"AACA,SAAS,6BAAmD;AAC5D,SAAS,oBAAsC;AAoBxC,SAAS,oBAAoB,SAA8C;AAChF,QAAM,EAAE,OAAO,cAAc,GAAG,eAAe,IAAI;AACnD,QAAM,UAAU,MAAM,QAAQ,cAAc;AAC5C,QAAM,aAAa,sBAAsB,MAAM,QAAQ,OAAO,CAAC;AAE/D,SAAO;AAAA,IACL;AAAA,IACA,OAAO;AAAA,IACP,MAAM,IAAI,UAAU;AAClB,UAAI;AACF,eAAO,MAAM,SAAS;AAAA,UACpB,cAAc,CAAC,QAAQ,gBACrB,QAAQ,QAAQ,CAAC,UAAU,aAAa,OAAO,MAAM,GAAG,WAAW;AAAA,UACrE,OAAO;AAAA,QACT,CAAC;AAAA,MACH,SAAS,OAAO;AACd,YAAI,cAAc;AAChB,gBAAM,QAAQ,cAAc,YAAY,EAAE,MAAM,MAAM,MAAS;AAAA,QACjE;AACA,cAAM;AAAA,MACR;AAAA,IACF;AAAA,IACA,OAAO;AACL,cAAQ,KAAK;AAAA,IACf;AAAA,IACA,MAAM,cAAc,aAAa,cAA6B;AAC5D,UAAI,CAAC,YAAY;AACf,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AACA,YAAM,QAAQ,cAAc,UAAU;AAAA,IACxC;AAAA,EACF;AACF;","names":[]}

package/dist/tracing/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/tracing/index.ts"],"sourcesContent":["export {\n  clearTraceHubForTests,\n  createTraceCapture,\n  dispatchRendererTracePayload,\n  emitRendererTrace,\n  getTraceEvents$,\n  publishMainTrace,\n  publishTestTrace,\n  setMainTraceMinLevel,\n  setRendererTraceEnabled,\n  setRendererTraceMinLevel,\n  setRendererTraceTransport,\n  TraceCapture,\n  type TraceCaptureOptions,\n  type TraceDispatchResult,\n  type TraceEvent,\n  type TraceInput,\n  type TraceLevel,\n  type TraceProcess,\n  type TraceWaitOptions,\n} from './trace_hub.js';\n\nexport {\n  FrameworkTracer,\n  MainTracer,\n  RendererTracer,\n  TestTracer,\n  TraceProvider,\n  TraceProviderConfiguration,\n  type TraceContext,\n  type TraceProviderMode,\n  type TraceRuntime,\n} from './trace_provider.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAoBO;AAEP,4BAUO;","names":[]}
+{"version":3,"sources":["../../src/tracing/index.ts"],"sourcesContent":["export {\n  clearTraceHubForTests,\n  createTraceCapture,\n  dispatchRendererTracePayload,\n  emitRendererTrace,\n  getTraceEvents$,\n  publishMainTrace,\n  publishTestTrace,\n  setMainTraceMinLevel,\n  setRendererTraceEnabled,\n  setRendererTraceMinLevel,\n  setRendererTraceTransport,\n  TraceCapture,\n  type TraceCaptureOptions,\n  type TraceDispatchResult,\n  type TraceEvent,\n  type TraceInput,\n  type TraceLevel,\n  type TraceProcess,\n  type TraceRuntimeContext,\n  type TraceWaitOptions,\n} from './trace_hub.js';\n\nexport {\n  FrameworkTracer,\n  MainTracer,\n  RendererTracer,\n  TestTracer,\n  TraceProvider,\n  TraceProviderConfiguration,\n  type TraceContext,\n  type TraceProviderMode,\n  type TraceRuntime,\n} from './trace_provider.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAqBO;AAEP,4BAUO;","names":[]}

package/dist/tracing/index.d.cts

@@ -1,4 +1,4 @@
-export { TraceCapture, TraceCaptureOptions, TraceDispatchResult, TraceEvent, TraceInput, TraceLevel, TraceProcess, TraceWaitOptions, clearTraceHubForTests, createTraceCapture, dispatchRendererTracePayload, emitRendererTrace, getTraceEvents$, publishMainTrace, publishTestTrace, setMainTraceMinLevel, setRendererTraceEnabled, setRendererTraceMinLevel, setRendererTraceTransport } from './trace_hub.cjs';
+export { TraceCapture, TraceCaptureOptions, TraceDispatchResult, TraceEvent, TraceInput, TraceLevel, TraceProcess, TraceRuntimeContext, TraceWaitOptions, clearTraceHubForTests, createTraceCapture, dispatchRendererTracePayload, emitRendererTrace, getTraceEvents$, publishMainTrace, publishTestTrace, setMainTraceMinLevel, setRendererTraceEnabled, setRendererTraceMinLevel, setRendererTraceTransport } from './trace_hub.cjs';
 export { FrameworkTracer, MainTracer, RendererTracer, TestTracer, TraceContext, TraceProvider, TraceProviderConfiguration, TraceProviderMode, TraceRuntime } from './trace_provider.cjs';
 import 'rxjs';
 import '@noego/ioc';

package/dist/tracing/index.d.ts

@@ -1,4 +1,4 @@
-export { TraceCapture, TraceCaptureOptions, TraceDispatchResult, TraceEvent, TraceInput, TraceLevel, TraceProcess, TraceWaitOptions, clearTraceHubForTests, createTraceCapture, dispatchRendererTracePayload, emitRendererTrace, getTraceEvents$, publishMainTrace, publishTestTrace, setMainTraceMinLevel, setRendererTraceEnabled, setRendererTraceMinLevel, setRendererTraceTransport } from './trace_hub.js';
+export { TraceCapture, TraceCaptureOptions, TraceDispatchResult, TraceEvent, TraceInput, TraceLevel, TraceProcess, TraceRuntimeContext, TraceWaitOptions, clearTraceHubForTests, createTraceCapture, dispatchRendererTracePayload, emitRendererTrace, getTraceEvents$, publishMainTrace, publishTestTrace, setMainTraceMinLevel, setRendererTraceEnabled, setRendererTraceMinLevel, setRendererTraceTransport } from './trace_hub.js';
 export { FrameworkTracer, MainTracer, RendererTracer, TestTracer, TraceContext, TraceProvider, TraceProviderConfiguration, TraceProviderMode, TraceRuntime } from './trace_provider.js';
 import 'rxjs';
 import '@noego/ioc';