@proj-airi/trace-kit 0.0.0-stage → 0.15.3

package/dist/types-Fp54Yi6b.d.mts

@@ -0,0 +1,319 @@
+import { n as SeriesRetention, r as SeriesRing } from "./series-ring-DCb7czkl.mjs";
+import { A as TraceAttributes, D as TraceAnnotation, F as TraceIds, L as TraceLink, U as TraceRef, g as TraceMetricDefinition, n as ClockGraph, o as TraceFeedMessage, tt as TraceStatus, u as TraceAggregate, w as TraceTrackDefinition, z as TraceRecord } from "./clock-CewQJzn8.mjs";
+//#region src/projections/reader.d.ts
+/**
+ * Records by source, epoch, and seq.
+ *
+ * A map from `source/epoch` to a map from `seq` keeps one number per record. A map with `source/epoch/seq` strings as
+ * keys keeps one string per record, and costs about five times the memory for the same lookups.
+ */
+declare class RecordIndex {
+  private readonly epochs;
+  private count;
+  get size(): number;
+  get(ref: TraceRef): TraceRecord | undefined;
+  has(ref: TraceRef): boolean;
+  /** Adds a record. A record with the same source, epoch, and seq stays, and the call returns false. */
+  add(record: TraceRecord): boolean;
+  clear(): void;
+}
+/** The index key of a link target. */
+declare function linkTargetKey(to: TraceRef | {
+  spanId: string;
+} | {
+  key: string;
+  id: string | number;
+}): string;
+/**
+ * Feeds collector messages to projections in apply order.
+ *
+ * Apply order is the arrival order of the feed. For one epoch, it is the `seq` order, as the transports deliver it.
+ * Display order is the converted time, which each projection reads from the context.
+ *
+ * The reader keeps its own clock graph from the snapshot records in the feed, so a replay of a file converts times in
+ * the same way as the live view. `version` changes on each handled message. A view reads through selectors keyed on it.
+ */
+declare class TraceReader {
+  private readonly projections;
+  readonly clocks: ClockGraph;
+  readonly indexes: TraceIndexes;
+  version: number;
+  caughtUp: boolean;
+  private readonly states;
+  constructor(projections: AnyTraceProjection[], traceClock?: string);
+  handle(message: TraceFeedMessage): void;
+  /** Feeds records without a collector, for example the lines of a file or the records of a test. */
+  handleRecords(records: Iterable<TraceRecord>): void;
+  /** The view of a projection of this reader. */
+  view<State, View>(projection: TraceProjection<State, View>): View;
+  /** The state of a projection, typed for the call. Each state was created by the same projection. */
+  private stateOf;
+  reset(): void;
+  /** The event time of a record on the trace clock. */
+  timeOf(record: TraceRecord): {
+    time: number;
+    estimated: boolean;
+  };
+  private apply;
+}
+//#endregion
+//#region src/projections/types.d.ts
+/** Indexes that every projection of one reader shares. The reader fills them before the projections run. */
+interface TraceIndexes {
+  /** Records by source, epoch, and seq. */
+  byKey: RecordIndex;
+  /** The `span.begin` or `span.complete` record of each span ID. */
+  bySpanId: Map<string, TraceRecord>;
+  /** Records that link to a target, by target key: a record key, `span:<id>`, or `id:<key>=<value>`. */
+  linksTo: Map<string, TraceRecord[]>;
+  /** Records by `<id key>=<value>`. */
+  byId: Map<string, TraceRecord[]>;
+}
+interface TraceApplyContext {
+  /** The record came from the pinned set. */
+  pinned: boolean;
+  /** The record arrived after the watermark of its source. */
+  late: boolean;
+  /** The event time on the trace clock. Without a clock path, the observed time. */
+  time: number;
+  /** The time is estimated: a clock on the path has no measured latency, or no clock path exists. */
+  estimated: boolean;
+  indexes: TraceIndexes;
+}
+/**
+ * Turns records into view state.
+ *
+ * `handleRecord` is pure: no I/O, no clock, and no Vue refs. It tolerates orphans and duplicates. The state is plain
+ * objects and typed arrays, and `handleRecord` can mutate it in place for speed. A reader owns the state.
+ */
+interface TraceProjection<State, View = State> {
+  /** A stable key, for example `timeline`, `event-log`, or `voice.floor-transfer`. */
+  key: string;
+  reset: () => State;
+  handleRecord: (state: State, record: TraceRecord, context: TraceApplyContext) => State;
+  /** Points of a series from the collector backlog, on the trace clock. */
+  handleSeries?: (state: State, series: Extract<TraceFeedMessage, {
+    kind: 'series';
+  }>) => State;
+  /** The collector evicted records in this range of the trace clock. */
+  evict?: (state: State, range: {
+    from: number;
+    to: number;
+  }) => State;
+  finalize?: (state: State) => State;
+  select: (state: State) => View;
+}
+/**
+ * A projection whose state the reader treats as opaque, so one reader holds projections of different states.
+ *
+ * The state parameters are `never`: under `strictFunctionTypes`, a function of any state can stand in for them. The
+ * reader only passes a state back to the projection that created it.
+ */
+interface AnyTraceProjection {
+  key: string;
+  reset: () => unknown;
+  handleRecord: (state: never, record: TraceRecord, context: TraceApplyContext) => unknown;
+  handleSeries?: (state: never, series: Extract<TraceFeedMessage, {
+    kind: 'series';
+  }>) => unknown;
+  evict?: (state: never, range: {
+    from: number;
+    to: number;
+  }) => unknown;
+  finalize?: (state: never) => unknown;
+  select: (state: never) => unknown;
+}
+interface TimelineInstant {
+  /** `source/epoch/seq` of the record. */
+  key: string;
+  name: string;
+  track: string;
+  time: number;
+  spanKey?: string;
+  ids?: TraceIds;
+  attrs?: TraceAttributes;
+  links?: TraceLink[];
+  /** The time was moved after its cause in the view. The stored record keeps its value. */
+  reordered?: boolean;
+  estimated?: boolean;
+  late?: boolean;
+  level?: 'debug' | 'info' | 'warn' | 'error';
+}
+interface TimelineSpan {
+  /** `source/epoch/spanId`. */
+  key: string;
+  spanId: string;
+  source: string;
+  epoch: string;
+  track: string;
+  name: string;
+  parentKey?: string;
+  /** Nesting depth among spans of the same track. */
+  depth: number;
+  /** Sub-lane at this depth. Assigned once, at begin. */
+  lane: number;
+  ids?: TraceIds;
+  /** Merged attributes of begin, updates, and end. Spans without attributes share one frozen empty object. */
+  attrs: TraceAttributes;
+  /** Spans without links share one frozen empty list. The projection replaces a list when it adds to it. */
+  links: readonly TraceLink[];
+  start: number;
+  end?: number;
+  status?: TraceStatus;
+  reason?: string;
+  message?: string;
+  deadlineMs?: number;
+  /** The source of the span stopped, was lost, or started a new epoch before the span ended. */
+  abandoned?: boolean;
+  /** The begin is missing. The span starts at the left edge of the reader window. */
+  startMissing?: boolean;
+  estimated?: boolean;
+  reordered?: boolean;
+  late?: boolean;
+  instants: readonly TimelineInstant[];
+  annotations: readonly TraceAnnotation[];
+}
+interface TimelineStateChange {
+  key: string;
+  track: string;
+  time: number;
+  value: string;
+  from?: string;
+  /** The `rule` attribute: the rule that decided the change. */
+  rule?: string;
+  links?: TraceLink[];
+  source: string;
+  /** A record from a source that does not own the state of the track. */
+  foreignOwner?: boolean;
+}
+/**
+ * The points of one series. `times` and `values` are views of its ring. Read them again after the reader handles more
+ * records, because an append or a compaction replaces them.
+ */
+interface TimelineSeries {
+  readonly times: Float64Array;
+  readonly values: Float32Array;
+  /**
+   * Changes when points that a reader saw before change: a compaction, an expiry, or a late point. A cache that
+   * appends only new points starts again after a change.
+   */
+  readonly revision: number;
+}
+/** Options of the timeline projection. */
+interface TimelineProjectionOptions {
+  /**
+   * The retention of the series. A live viewer keeps the default, so a long session stays bounded. A file replay
+   * passes `false` and keeps every point.
+   * @default DEFAULT_SERIES_RETENTION
+   */
+  seriesRetention?: SeriesRetention | false;
+}
+interface TimelineTrack {
+  path: string;
+  /** The track definition whose path pattern matches, if any. */
+  definition?: TraceTrackDefinition;
+  /** The `{key}` values of the matched pattern. */
+  params: Record<string, string>;
+  spans: TimelineSpan[];
+  instants: TimelineInstant[];
+  states: TimelineStateChange[];
+  /** Series points by value key, on the trace clock, in time order. */
+  series: Record<string, TimelineSeries>;
+  /** The busy end of each sub-lane at each depth. An open span keeps its lane busy until `Infinity`. */
+  lanes: number[][];
+  /** A span of the track ended with an error. The viewer keeps the track visible. */
+  hasError: boolean;
+  /** The source that owns the state of the track: the first source that wrote a state. */
+  stateOwner?: string;
+}
+/** A global marker: a lost source or a clock discontinuity. */
+interface TimelineMarker {
+  kind: 'source-lost' | 'clock-discontinuity';
+  time: number;
+  label: string;
+  /** The end of a shaded band. A discontinuity without a later snapshot has none. */
+  until?: number;
+}
+interface TimelineSource {
+  source: string;
+  epoch: string;
+  runtime?: string;
+  live: boolean;
+  /** The newest event time. The watermark of the source trails it by the allowed lateness. */
+  newestTime: number;
+}
+interface TimelineState {
+  tracks: Map<string, TimelineTrack>;
+  spans: Map<string, TimelineSpan>;
+  definitions: Map<string, unknown>;
+  trackDefinitions: TraceTrackDefinition[];
+  markers: TimelineMarker[];
+  gaps: {
+    from: number;
+    to: number;
+  }[];
+  sources: Map<string, TimelineSource>;
+  /** Annotations whose target is a set of IDs, such as a conversation or a topic. */
+  annotations: TraceAnnotation[];
+  start: number;
+  end: number;
+  counters: {
+    records: number;
+    late: number;
+    orphanUpdates: number;
+    reordered: number;
+  };
+  /**
+   * Updates without their begin, by span key, with the time of the newest update. They wait for the begin for the
+   * allowed lateness, then they go. `counters.orphanUpdates` counts them.
+   */
+  pendingUpdates: Map<string, {
+    attrs: TraceAttributes;
+    time: number;
+  }>;
+  /** The ring of each series, by track path and value key. `TimelineTrack.series` reads them. */
+  seriesRings: Map<string, SeriesRing>;
+  seriesRetention: SeriesRetention | false;
+  /** The `end` of the last series compaction. */
+  seriesCompactedAt: number;
+}
+interface EventLogEntry {
+  key: string;
+  time: number;
+  record: TraceRecord;
+  late?: boolean;
+  pinned?: boolean;
+  estimated?: boolean;
+}
+interface EventLogState {
+  entries: EventLogEntry[];
+  /** Keys of the entries, so a pinned copy and its buffered copy show once. */
+  keys: Set<string>;
+  /** Entries that the limit dropped. */
+  dropped: number;
+}
+/** One measurement. Censored, warm-up, and failed measurements are counted, but percentiles leave them out. */
+interface MetricSample {
+  time: number;
+  value: number;
+  /** Dimension values, for example `{ from: 'user', to: 'airi' }`. */
+  dimensions?: Record<string, string>;
+  excluded?: 'censored' | 'warmup' | 'failed';
+}
+/** The samples of each metric key. A derived projection selects this shape too. */
+type MetricSamples = Record<string, MetricSample[]>;
+interface MetricSummary {
+  key: string;
+  definition?: TraceMetricDefinition;
+  values: Partial<Record<TraceAggregate, number>>;
+  count: number;
+  excluded: {
+    censored: number;
+    warmup: number;
+    failed: number;
+  };
+  /** The summary of each dimension combination, keyed by `value|value`. */
+  byDimension?: Record<string, Partial<Record<TraceAggregate, number>>>;
+}
+//#endregion
+export { TraceIndexes as _, MetricSamples as a, TraceReader as b, TimelineMarker as c, TimelineSource as d, TimelineSpan as f, TraceApplyContext as g, TimelineTrack as h, MetricSample as i, TimelineProjectionOptions as l, TimelineStateChange as m, EventLogEntry as n, MetricSummary as o, TimelineState as p, EventLogState as r, TimelineInstant as s, AnyTraceProjection as t, TimelineSeries as u, TraceProjection as v, linkTargetKey as x, RecordIndex as y };

package/dist/views/index.d.mts

@@ -0,0 +1,97 @@
+import { L as TraceLink, b as TracePresetDefinition, v as TracePipelineDefinition, z as TraceRecord } from "../clock-CewQJzn8.mjs";
+import { _ as TraceIndexes, a as MetricSamples, b as TraceReader, f as TimelineSpan, h as TimelineTrack, l as TimelineProjectionOptions, m as TimelineStateChange, p as TimelineState, r as EventLogState, s as TimelineInstant } from "../types-Fp54Yi6b.mjs";
+//#region src/views/types.d.ts
+/** What a click, a hover, or a selection points to: a span, an instant, or a state change, by its key. */
+interface TraceItemRef {
+  kind: 'span' | 'instant' | 'state';
+  key: string;
+}
+/** The state of a pipeline stage instance at a time. */
+type StageStatus = 'idle' | 'busy' | 'error' | string;
+interface PipelineNode {
+  key: string;
+  stage: string;
+  /** The stage label of the profile in the requested locale, or the stage key. */
+  label: string;
+  instance?: string;
+  status: StageStatus;
+  /** Open spans of the stage at the time. */
+  open: TimelineSpan[];
+  /** The trace has a track of the stage. Without one, the status says nothing. */
+  observed: boolean;
+}
+//#endregion
+//#region src/views/lookup.d.ts
+/** The span that a span ID names. The ID index gives its source and epoch. */
+declare function spanOfId(state: TimelineState, indexes: TraceIndexes, spanId: string): TimelineSpan | undefined;
+/** The spans of records, once each, in record order. A record without a span ID adds nothing. */
+declare function spansOfRecords(state: TimelineState, records: readonly TraceRecord[]): TimelineSpan[];
+/** The spans that a link points to: the span of a span ID, or every span with a domain ID value. */
+declare function spansOfLink(link: TraceLink, state: TimelineState, indexes: TraceIndexes): TimelineSpan[];
+/** The selection key of the item that a record belongs to: its span, or the record itself for an instant or a state. */
+declare function itemOfRecord(record: TraceRecord): TraceItemRef | undefined;
+/** The item of a reference and its track. Instants and states need a scan of the tracks. */
+declare function findItem(state: TimelineState, ref: TraceItemRef): {
+  track?: TimelineTrack;
+  span?: TimelineSpan;
+  instant?: TimelineInstant;
+  change?: TimelineStateChange;
+};
+/** The spans that a span encloses, in start order. Only direct children. */
+declare function childSpans(state: TimelineState, span: TimelineSpan): TimelineSpan[];
+/** The input and output tokens of a model span. 0 for any other span. */
+declare function spanTokens(span: TimelineSpan): number;
+/**
+ * Keys of the records that relate to a span: spans that it links to, spans that link to it, and spans that share one
+ * of its narrow ID values, such as a turn or an input. The view dims every other item.
+ */
+declare function relatedSpanKeys(state: TimelineState, selected: TimelineSpan): Set<string>;
+//#endregion
+//#region src/views/pipeline.d.ts
+/**
+ * The nodes of a pipeline at time `at`: one node for each stage instance.
+ *
+ * A stage with a state track takes its latest state at or before `at`. Otherwise it is `busy` while a span is open,
+ * `error` when its latest span before `at` ended with an error, and `idle` otherwise.
+ */
+declare function pipelineNodes(state: TimelineState, pipeline: TracePipelineDefinition, at: number, locale: string): PipelineNode[];
+//#endregion
+//#region src/views/reader.d.ts
+/**
+ * A reader with the projections that the trace views read: the timeline, the event log, and the metrics. The IO tracer
+ * store and the stories read traces the same way.
+ *
+ * A live view keeps the default series retention. A file replay passes `{ seriesRetention: false }`.
+ */
+declare function createTraceViewReader(traceClock: string, options?: TimelineProjectionOptions): {
+  reader: TraceReader;
+  timelineView: () => TimelineState;
+  eventLogView: () => EventLogState;
+  metricSamples: () => MetricSamples;
+};
+//#endregion
+//#region src/views/tracks.d.ts
+/**
+ * A stable color for a track path without a defined color.
+ *
+ * @example
+ * hashColor('plugin:minecraft/bots/b_2/planner')
+ * // => 'hsl(295 60% 55%)'
+ */
+declare function hashColor(text: string): string;
+/** Whether a track matches a preset. A preset without tracks shows every track. */
+declare function presetMatches(preset: TracePresetDefinition | undefined, path: string): boolean;
+/**
+ * What a track holds, for its label: the count of its items, and how many of its spans failed. An item is a span, or
+ * an instant or a state change on a track without spans.
+ *
+ * @example
+ * trackSummary(asrTrack)
+ * // => { items: 2, failed: 1 }
+ */
+declare function trackSummary(track: TimelineTrack): {
+  items: number;
+  failed: number;
+};
+//#endregion
+export { PipelineNode, StageStatus, TraceItemRef, childSpans, createTraceViewReader, findItem, hashColor, itemOfRecord, pipelineNodes, presetMatches, relatedSpanKeys, spanOfId, spanTokens, spansOfLink, spansOfRecords, trackSummary };

package/dist/views/index.mjs

@@ -0,0 +1,219 @@
+import { K as localize, q as matchTrackPath } from "../conventions-DLiC8rkL.mjs";
+import "../semconv.mjs";
+import { n as recordKey, r as spanKeyOf } from "../keys-DD_VE8Fk.mjs";
+import { a as TraceReader, l as createEventLogProjection, s as createAttributeMetricsProjection, t as createTimelineProjection } from "../timeline-B4Vc6qQf.mjs";
+import { createFloorTransferProjection } from "../profiles/voice.mjs";
+//#region src/views/lookup.ts
+/** The span that a span ID names. The ID index gives its source and epoch. */
+function spanOfId(state, indexes, spanId) {
+	const begin = indexes.bySpanId.get(spanId);
+	return begin ? state.spans.get(spanKeyOf(begin.source, begin.epoch, spanId)) : void 0;
+}
+/** The spans of records, once each, in record order. A record without a span ID adds nothing. */
+function spansOfRecords(state, records) {
+	const spans = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (!("spanId" in record) || !record.spanId) continue;
+		const span = state.spans.get(spanKeyOf(record.source, record.epoch, record.spanId));
+		if (span) spans.set(span.key, span);
+	}
+	return [...spans.values()];
+}
+/** The spans that a link points to: the span of a span ID, or every span with a domain ID value. */
+function spansOfLink(link, state, indexes) {
+	if ("spanId" in link.to) {
+		const span = spanOfId(state, indexes, link.to.spanId);
+		return span ? [span] : [];
+	}
+	if ("key" in link.to) return spansOfRecords(state, indexes.byId.get(`${link.to.key}=${link.to.id}`) ?? []);
+	return [];
+}
+/** The selection key of the item that a record belongs to: its span, or the record itself for an instant or a state. */
+function itemOfRecord(record) {
+	if (record.type === "span.begin" || record.type === "span.end" || record.type === "span.update" || record.type === "span.complete") return {
+		kind: "span",
+		key: spanKeyOf(record.source, record.epoch, record.spanId)
+	};
+	if (record.type === "instant" || record.type === "log") return {
+		kind: "instant",
+		key: recordKey(record)
+	};
+	if (record.type === "state") return {
+		kind: "state",
+		key: recordKey(record)
+	};
+}
+/** The item of a reference and its track. Instants and states need a scan of the tracks. */
+function findItem(state, ref) {
+	if (ref.kind === "span") {
+		const span = state.spans.get(ref.key);
+		return {
+			span,
+			track: span ? state.tracks.get(span.track) : void 0
+		};
+	}
+	for (const track of state.tracks.values()) if (ref.kind === "instant") {
+		const instant = track.instants.find((candidate) => candidate.key === ref.key);
+		if (instant) return {
+			track,
+			instant
+		};
+	} else {
+		const change = track.states.find((candidate) => candidate.key === ref.key);
+		if (change) return {
+			track,
+			change
+		};
+	}
+	return {};
+}
+/** The spans that a span encloses, in start order. Only direct children. */
+function childSpans(state, span) {
+	const children = [];
+	for (const candidate of state.spans.values()) if (candidate.parentKey === span.key) children.push(candidate);
+	return children.sort((a, b) => a.start - b.start);
+}
+/** The input and output tokens of a model span. 0 for any other span. */
+function spanTokens(span) {
+	return Number(span.attrs["gen_ai.usage.input_tokens"] ?? 0) + Number(span.attrs["gen_ai.usage.output_tokens"] ?? 0);
+}
+/** ID keys that many unrelated spans share. They do not make two spans related. */
+const BROAD_ID_KEYS = /* @__PURE__ */ new Set([
+	"actor",
+	"conversation",
+	"agent",
+	"topic"
+]);
+/**
+* Keys of the records that relate to a span: spans that it links to, spans that link to it, and spans that share one
+* of its narrow ID values, such as a turn or an input. The view dims every other item.
+*/
+function relatedSpanKeys(state, selected) {
+	const related = /* @__PURE__ */ new Set([selected.key]);
+	const targetIds = /* @__PURE__ */ new Set();
+	for (const [key, value] of Object.entries(selected.ids ?? {})) if (!BROAD_ID_KEYS.has(key)) targetIds.add(`${key}=${value}`);
+	for (const link of selected.links) if ("key" in link.to) targetIds.add(`${link.to.key}=${link.to.id}`);
+	for (const span of state.spans.values()) {
+		if (span.key === selected.key) continue;
+		const linksToSelected = span.links.some((link) => "spanId" in link.to && link.to.spanId === selected.spanId);
+		const selectedLinksTo = selected.links.some((link) => "spanId" in link.to && link.to.spanId === span.spanId);
+		const sharesId = Object.entries(span.ids ?? {}).some(([key, value]) => !BROAD_ID_KEYS.has(key) && targetIds.has(`${key}=${value}`));
+		if (linksToSelected || selectedLinksTo || sharesId || span.parentKey === selected.key || selected.parentKey === span.key) related.add(span.key);
+	}
+	return related;
+}
+//#endregion
+//#region src/views/pipeline.ts
+/**
+* The nodes of a pipeline at time `at`: one node for each stage instance.
+*
+* A stage with a state track takes its latest state at or before `at`. Otherwise it is `busy` while a span is open,
+* `error` when its latest span before `at` ended with an error, and `idle` otherwise.
+*/
+function pipelineNodes(state, pipeline, at, locale) {
+	const nodes = [];
+	for (const stage of pipeline.stages) {
+		const instances = /* @__PURE__ */ new Map();
+		for (const track of state.tracks.values()) for (const pattern of stage.tracks) {
+			const params = matchTrackPath(pattern, track.path);
+			if (!params) continue;
+			const instance = Object.values(params)[0] ?? "";
+			const list = instances.get(instance) ?? [];
+			list.push(track);
+			instances.set(instance, list);
+		}
+		if (instances.size === 0) instances.set("", []);
+		for (const [instance, tracks] of instances) {
+			let status = "idle";
+			const open = [];
+			let latestEnded;
+			let latestState;
+			for (const track of tracks) {
+				for (const change of track.states) if (change.time <= at && (!latestState || change.time >= latestState.time)) latestState = change;
+				for (const span of track.spans) {
+					if (span.start > at) continue;
+					if (span.end === void 0 || span.end > at) {
+						if (!span.abandoned) open.push(span);
+					} else if (!latestEnded || span.end > (latestEnded.end ?? 0)) latestEnded = span;
+				}
+			}
+			if (latestState) status = latestState.value;
+			else if (open.length > 0) status = "busy";
+			else if (latestEnded?.status === "error") status = "error";
+			nodes.push({
+				key: `${stage.key}:${instance}`,
+				stage: stage.key,
+				label: localize(stage.label, locale) ?? stage.key,
+				instance: instance || void 0,
+				status,
+				open,
+				observed: tracks.length > 0
+			});
+		}
+	}
+	return nodes;
+}
+//#endregion
+//#region src/views/reader.ts
+/**
+* A reader with the projections that the trace views read: the timeline, the event log, and the metrics. The IO tracer
+* store and the stories read traces the same way.
+*
+* A live view keeps the default series retention. A file replay passes `{ seriesRetention: false }`.
+*/
+function createTraceViewReader(traceClock, options = {}) {
+	const timeline = createTimelineProjection(options);
+	const eventLog = createEventLogProjection();
+	const attributeMetrics = createAttributeMetricsProjection();
+	const floorTransfer = createFloorTransferProjection();
+	const reader = new TraceReader([
+		timeline,
+		eventLog,
+		attributeMetrics,
+		floorTransfer
+	], traceClock);
+	return {
+		reader,
+		timelineView: () => reader.view(timeline),
+		eventLogView: () => reader.view(eventLog),
+		metricSamples: () => ({
+			...reader.view(attributeMetrics),
+			...reader.view(floorTransfer)
+		})
+	};
+}
+//#endregion
+//#region src/views/tracks.ts
+/**
+* A stable color for a track path without a defined color.
+*
+* @example
+* hashColor('plugin:minecraft/bots/b_2/planner')
+* // => 'hsl(295 60% 55%)'
+*/
+function hashColor(text) {
+	let hash = 0;
+	for (const char of text) hash = hash * 31 + char.charCodeAt(0) | 0;
+	return `hsl(${25 + Math.abs(hash) % 300} 60% 55%)`;
+}
+/** Whether a track matches a preset. A preset without tracks shows every track. */
+function presetMatches(preset, path) {
+	if (!preset || preset.tracks.length === 0) return true;
+	return preset.tracks.some((pattern) => matchTrackPath(pattern, path) !== void 0);
+}
+/**
+* What a track holds, for its label: the count of its items, and how many of its spans failed. An item is a span, or
+* an instant or a state change on a track without spans.
+*
+* @example
+* trackSummary(asrTrack)
+* // => { items: 2, failed: 1 }
+*/
+function trackSummary(track) {
+	return {
+		items: track.spans.length || track.instants.length || track.states.length,
+		failed: track.spans.reduce((count, span) => count + (span.status === "error" ? 1 : 0), 0)
+	};
+}
+//#endregion
+export { childSpans, createTraceViewReader, findItem, hashColor, itemOfRecord, pipelineNodes, presetMatches, relatedSpanKeys, spanOfId, spanTokens, spansOfLink, spansOfRecords, trackSummary };