@dxos/react-ui-trace 0.11.1

package/dist/types/src/execution-graph/index.d.ts

@@ -0,0 +1,4 @@
+export { type BuildExecutionGraphParams, type CollectProcessActivityOptions, CommitSelector, type ExecutionGraph, type ExecutionGraphDetailsMap, buildExecutionGraph, collectProcessActivityLines, deriveInFlightActivityLine, } from './execution-graph.ts';
+export { type EphemeralStatusUpdate, estimateTokenCount, formatPendingBlockStatus, pendingStatusFromEphemeralMessage, resolveEphemeralStatusUpdate, } from './pending-block-status.ts';
+export { BEGIN_EVENT_TYPES, type BuildSpanTreeOptions, DEFAULT_SPAN_TIMEOUT_MS, END_EVENT_TYPES, ROOT_SPAN_ID, type Span, type SpanMeta, buildSpanTree, flattenSpanTree, isSpanBeginEvent, isSpanEndEvent, walkSpanTree, } from './span-tree.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/execution-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,6BAA6B,EAClC,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,qBAAqB,EAC1B,kBAAkB,EAClB,wBAAwB,EACxB,iCAAiC,EACjC,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,uBAAuB,EACvB,eAAe,EACf,YAAY,EACZ,KAAK,IAAI,EACT,KAAK,QAAQ,EACb,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,YAAY,GACb,MAAM,gBAAgB,CAAC"}

package/dist/types/src/execution-graph/pending-block-status.d.ts

@@ -0,0 +1,26 @@
+import * as Trace from '@dxos/compute/Trace';
+import { type ContentBlock } from '@dxos/types';
+/**
+ * Approximate streamed token count from partial text (UTF-8 length / 4).
+ */
+export declare const estimateTokenCount: (text: string) => number;
+/**
+ * Formats a pending assistant block for the delegated-task status line.
+ */
+export declare const formatPendingBlockStatus: (block: ContentBlock.Any) => string | undefined;
+/**
+ * Reads the latest pending partial block from an ephemeral trace message.
+ */
+export declare const pendingStatusFromEphemeralMessage: (message: Trace.Message) => string | undefined;
+export type EphemeralStatusUpdate = 'unchanged' | {
+    readonly line: string;
+};
+/**
+ * Maps an ephemeral trace message to a task-status update.
+ *
+ * The status line is "sticky": a message without a pending line (e.g. a completed block during an
+ * LLM-thinking gap) leaves the previous line in place rather than clearing it, so the row keeps
+ * showing the latest meaningful activity until a new line arrives or the subscription ends.
+ */
+export declare const resolveEphemeralStatusUpdate: (message: Trace.Message) => EphemeralStatusUpdate;
+//# sourceMappingURL=pending-block-status.d.ts.map

package/dist/types/src/execution-graph/pending-block-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-block-status.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/pending-block-status.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,KAAG,MACiB,CAAC;AAWpE;;GAEG;AACH,eAAO,MAAM,wBAAwB,UAAW,YAAY,CAAC,GAAG,KAAG,MAAM,GAAG,SAgB3E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,YAAa,KAAK,CAAC,OAAO,KAAG,MAAM,GAAG,SAwBnF,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,YAAa,KAAK,CAAC,OAAO,KAAG,qBAMrE,CAAC"}

package/dist/types/src/execution-graph/pending-block-status.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pending-block-status.test.d.ts.map

package/dist/types/src/execution-graph/pending-block-status.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-block-status.test.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/pending-block-status.test.ts"],"names":[],"mappings":""}

package/dist/types/src/execution-graph/remote-snapshot.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=remote-snapshot.test.d.ts.map

package/dist/types/src/execution-graph/remote-snapshot.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-snapshot.test.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/remote-snapshot.test.ts"],"names":[],"mappings":""}

package/dist/types/src/execution-graph/span-tree.d.ts

@@ -0,0 +1,106 @@
+import * as Trace from '@dxos/compute/Trace';
+/**
+ * Default duration a span may sit open with no new events before it's considered abandoned
+ * (the runtime crashed, lost connectivity, or otherwise never wrote the closing event).
+ */
+export declare const DEFAULT_SPAN_TIMEOUT_MS: number;
+/**
+ * Synthetic id assigned to the root span.
+ * The root is a virtual container for top-level spans (those without a parent in the captured trace).
+ */
+export declare const ROOT_SPAN_ID = "<main>";
+/**
+ * Computed metadata for a span.
+ * Derived from the meta of the begin event that opened the span.
+ */
+export interface SpanMeta {
+    readonly pid?: string;
+    readonly parentPid?: string;
+    readonly processName?: string;
+    readonly conversationId?: string;
+    readonly triggerId?: string;
+    readonly toolCallId?: string;
+    readonly runtimeName?: string;
+}
+/**
+ * A span in the trace hierarchy.
+ *
+ * Each span represents a single bounded unit of work — an operation invocation or an
+ * agent request. Spans are opened by `OperationStart` / `Trace.AgentRequestBegin` events and
+ * closed by their matching `OperationEnd` / `Trace.AgentRequestEnd` events. A single process
+ * (pid) may produce multiple sequential spans (for example, an agent session that serves
+ * three prompts produces three sibling spans sharing the agent's pid).
+ *
+ * `events` contains the bounded events for this span only — child spans' events are not
+ * duplicated here. `children` contains sub-spans that opened while this span was active.
+ */
+export interface Span {
+    readonly id: string;
+    readonly meta: SpanMeta;
+    readonly events: Trace.FlatEvent[];
+    readonly children: Span[];
+}
+export declare const BEGIN_EVENT_TYPES: Set<string>;
+export declare const END_EVENT_TYPES: Set<string>;
+export declare const isSpanBeginEvent: (event: Trace.FlatEvent) => boolean;
+export declare const isSpanEndEvent: (event: Trace.FlatEvent) => boolean;
+export interface BuildSpanTreeOptions {
+    /**
+     * If provided, caps how many *non-boundary* events (status updates, partial blocks, etc.)
+     * are retained — only the most recent `eventLimit` of them survive. Span boundary events
+     * (`OperationStart` / `OperationEnd` / `Trace.AgentRequestBegin` / `Trace.AgentRequestEnd`) are *always*
+     * retained regardless of the limit, because dropping them would orphan their child spans
+     * and collapse them onto the root branch.
+     */
+    eventLimit?: number;
+    /**
+     * Duration a span may sit open with no new events before it's force-closed with a synthetic
+     * end event. Only takes effect when `now` is also provided. Defaults to
+     * `DEFAULT_SPAN_TIMEOUT_MS`.
+     */
+    spanTimeoutMs?: number;
+    /**
+     * Reference time used to detect abandoned spans. Force-closing is skipped entirely when this
+     * is omitted, so callers that don't pass it (tests, deterministic snapshots) keep the prior
+     * behavior of leaving unterminated spans open regardless of their fixture timestamps.
+     */
+    now?: number;
+}
+/**
+ * Builds a hierarchical span tree from a list of trace messages.
+ *
+ * Algorithm:
+ *   1. Flatten messages into events and sort them chronologically.
+ *   2. For each event:
+ *      - Begin events (`OperationStart`, `Trace.AgentRequestBegin`) open a new span whose parent
+ *        is the currently-open span of the event's `meta.parentPid`, or the root if there is
+ *        none. The begin event itself becomes the first event of the new span.
+ *      - End events (`OperationEnd`, `Trace.AgentRequestEnd`) close the currently-open span for
+ *        the event's `meta.pid` and become its last event.
+ *      - Other events attach to the currently-open span for their `meta.pid`, or to the
+ *        root span if no span is currently open for that pid (or the event has no pid).
+ *   3. Sort each span's children by their earliest event timestamp.
+ */
+export declare const buildSpanTree: (messages: readonly Trace.Message[], options?: BuildSpanTreeOptions) => Span;
+/**
+ * A single event positioned within the span tree for commit emission.
+ */
+export interface SpanEventCursor {
+    readonly span: Span;
+    readonly event: Trace.FlatEvent;
+    readonly eventIndex: number;
+}
+/**
+ * Flattens span-tree events in categorical (depth-first) order: each span's begin events, its
+ * child subtrees in sibling order, then its remaining events (middle and end).
+ */
+export declare const collectSpanTreeEventsCategorically: (root: Span) => SpanEventCursor[];
+/**
+ * Walks the span tree in depth-first pre-order, invoking `visit` for each span (root included).
+ */
+export declare const walkSpanTree: (root: Span, visit: (span: Span, depth: number) => void, depth?: number) => void;
+/**
+ * Returns all spans in the tree in depth-first pre-order, root first.
+ */
+export declare const flattenSpanTree: (root: Span) => Span[];
+//# sourceMappingURL=span-tree.d.ts.map

package/dist/types/src/execution-graph/span-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-tree.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/span-tree.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAC;AAG7C;;;GAGG;AACH,eAAO,MAAM,uBAAuB,QAAkB,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;CAC3B;AAED,eAAO,MAAM,iBAAiB,aAA2E,CAAC;AAC1G,eAAO,MAAM,eAAe,aAAuE,CAAC;AAEpG,eAAO,MAAM,gBAAgB,UAAW,KAAK,CAAC,SAAS,KAAG,OAA4C,CAAC;AACvG,eAAO,MAAM,cAAc,UAAW,KAAK,CAAC,SAAS,KAAG,OAA0C,CAAC;AAmCnG,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,aAAc,SAAS,KAAK,CAAC,OAAO,EAAE,YAAW,oBAAoB,KAAQ,IA8HtG,CAAC;AAsFF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,eAAO,MAAM,kCAAkC,SAAU,IAAI,KAAG,eAAe,EAyB9E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,SAAU,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,qBAAc,IAKhG,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAAI,EAIhD,CAAC"}

package/dist/types/src/execution-graph/span-tree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=span-tree.test.d.ts.map

package/dist/types/src/execution-graph/span-tree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-tree.test.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/span-tree.test.ts"],"names":[],"mappings":""}

package/dist/types/src/execution-graph/sub-agent-delegation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sub-agent-delegation.test.d.ts.map

package/dist/types/src/execution-graph/sub-agent-delegation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub-agent-delegation.test.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/sub-agent-delegation.test.ts"],"names":[],"mappings":""}

package/dist/types/src/execution-graph/testing/collect-trace-events.d.ts

@@ -0,0 +1,40 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Trace from '@dxos/compute/Trace';
+declare const TestClock_base: Context.ServiceClass<TestClock, "@dxos/plugin-assistant/CollectTraceEvents/TestClock", () => number>;
+/**
+ * Internal tag carrying the monotonic clock created by {@link collectTraceEvents}. Nested
+ * {@link withMeta} scopes read it so every emitted message gets a strictly increasing
+ * timestamp regardless of how many writes happened in the same wall-clock millisecond.
+ */
+declare class TestClock extends TestClock_base {
+}
+/**
+ * Runs the given Effect with a mock {@link Trace.TraceService} and {@link Trace.TraceSink}
+ * whose writes accumulate into an in-memory list of {@link Trace.Message}s.
+ *
+ * Each `Trace.write(...)` call inside the effect produces one `Trace.Message` carrying the
+ * meta of the innermost {@link withMeta} scope (or empty meta if none is provided). Useful
+ * for building deterministic span fixtures without spinning up a feed sink.
+ *
+ * Timestamps are produced by an internal monotonic counter so multiple synchronous writes
+ * are ordered in insertion order — wall-clock `Date.now()` would otherwise tie and corrupt
+ * the resulting graph for fast tests.
+ *
+ * The effect is run synchronously; any failure is rethrown so callers don't pay error
+ * boilerplate in tests.
+ */
+export declare const collectTraceEvents: <A, E>(effect: Effect.Effect<A, E, Trace.TraceService | Trace.TraceSink | TestClock>) => Trace.Message[];
+/**
+ * Wraps an effect so that {@link Trace.write} calls inside it tag their messages with the
+ * given {@link Trace.Meta}. Nested `withMeta` scopes shadow the outer meta for their inner
+ * effect — exactly the pattern needed to fixture multi-process traces (e.g. an agent
+ * process containing nested operation processes).
+ *
+ * Implemented by re-providing a fresh {@link Trace.TraceService} layer over the existing
+ * {@link Trace.TraceSink} and shared monotonic clock, so all messages still flow into the
+ * same accumulator with monotonically increasing timestamps.
+ */
+export declare const withMeta: <A, E, R>(meta: Trace.Meta, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Trace.TraceService> | Trace.TraceSink | TestClock>;
+export {};
+//# sourceMappingURL=collect-trace-events.d.ts.map

package/dist/types/src/execution-graph/testing/collect-trace-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-trace-events.d.ts","sourceRoot":"","sources":["../../../../../src/execution-graph/testing/collect-trace-events.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAC;2HAOY,MAAM;AAL/D;;;;GAIG;AACH,cAAM,SAAU,SAAQ,cAEvB;CAAG;AAEJ;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,UAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,KAC5E,KAAK,CAAC,OAAO,EAsBf,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,QACxB,KAAK,CAAC,IAAI,UACR,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,SAAS,GAAG,SAAS,CACoB,CAAC"}

package/dist/types/src/execution-graph/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { collectTraceEvents, withMeta } from './collect-trace-events.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/execution-graph/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/execution-graph/testing/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useExecutionGraph.ts';
+export * from './useSessionTimeline.ts';
+export * from './useTraceMessages.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/index.ts"],"names":[],"mappings":"AAIA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC"}

package/dist/types/src/hooks/useExecutionGraph.d.ts

@@ -0,0 +1,17 @@
+import * as Atom from 'effect/unstable/reactivity/Atom';
+import * as Process from '@dxos/compute/Process';
+import { type Space } from '@dxos/react-client/echo';
+import { type ExecutionGraph } from '../execution-graph/index.ts';
+export type UseExecutionGraphOptions = {
+    collapseCompletedSpans?: boolean;
+    eventLimit?: number;
+    /** Pids to narrow the graph to (with their descendants); empty shows everything. */
+    selectedPids?: readonly string[];
+};
+/**
+ * The commit graph of a space's trace, rebuilt as messages land and as the process tree changes.
+ * `processesAtom` is the host's live process tree (a running agent draws a spinner commit); without
+ * it the graph is the durable trace alone.
+ */
+export declare const useExecutionGraph: (space: Space, processesAtom: Atom.Atom<readonly Process.Info[]> | undefined, { collapseCompletedSpans, eventLimit, selectedPids }?: UseExecutionGraphOptions) => ExecutionGraph;
+//# sourceMappingURL=useExecutionGraph.d.ts.map

package/dist/types/src/hooks/useExecutionGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecutionGraph.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useExecutionGraph.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,IAAI,MAAM,iCAAiC,CAAC;AAGxD,OAAO,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAE,KAAK,cAAc,EAAuB,MAAM,6BAA6B,CAAC;AAavF,MAAM,MAAM,wBAAwB,GAAG;IACrC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oFAAoF;IACpF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,UACrB,KAAK,iBACG,IAAI,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,yDACG,wBAAwB,KACvF,cAkBF,CAAC"}

package/dist/types/src/hooks/useSessionTimeline.d.ts

@@ -0,0 +1,17 @@
+import type * as Process from '@dxos/compute/Process';
+import { type Space } from '@dxos/react-client/echo';
+import { type Task } from '@dxos/types';
+import { type Session, type SessionTimeline } from '../session-timeline/index.ts';
+export type UseSessionTimelineOptions = {
+    /** The sessions shown; each contributes a session lane and its checklist's task lanes. */
+    sessions: readonly Session[];
+    tasks?: readonly Task.Task[];
+    /** The live process tree, from whichever monitor the host has; without it a session's liveness is read from the trace alone. */
+    processes?: readonly Process.Info[];
+};
+/**
+ * The live gantt-shaped view of the given sessions: rebuilt as trace events land on the space's
+ * trace feed and as the process tree changes, and ticked so open lanes keep extending.
+ */
+export declare const useSessionTimeline: (space: Space | undefined, { sessions, tasks, processes }: UseSessionTimelineOptions) => SessionTimeline;
+//# sourceMappingURL=useSessionTimeline.d.ts.map

package/dist/types/src/hooks/useSessionTimeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSessionTimeline.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useSessionTimeline.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,8BAA8B,CAAC;AAaxG,MAAM,MAAM,yBAAyB,GAAG;IACtC,0FAA0F;IAC1F,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,KAAK,CAAC,EAAE,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;IAC7B,gIAAgI;IAChI,SAAS,CAAC,EAAE,SAAS,OAAO,CAAC,IAAI,EAAE,CAAC;CACrC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,UACtB,KAAK,GAAG,SAAS,kCACuB,yBAAyB,KACvE,eAaF,CAAC"}

package/dist/types/src/hooks/useTraceMessages.d.ts

@@ -0,0 +1,17 @@
+import * as Duration from 'effect/Duration';
+import * as Atom from 'effect/unstable/reactivity/Atom';
+import * as Trace from '@dxos/compute/Trace';
+import { type Space } from '@dxos/react-client/echo';
+/**
+ * Atom of raw trace messages for a space — the input to `buildExecutionGraph`.
+ */
+export declare const getTraceMessagesAtom: (space: Space) => Atom.Atom<readonly Trace.Message[]>;
+export type UseTraceMessagesOptions = {
+    /** Caps the re-render rate; the feed emits per message, which is far faster than a reader can read. */
+    debounce?: Duration.Duration;
+};
+/**
+ * Subscribes to the space invocation trace feed.
+ */
+export declare const useTraceMessages: (space?: Space, { debounce }?: UseTraceMessagesOptions) => readonly Trace.Message[];
+//# sourceMappingURL=useTraceMessages.d.ts.map

package/dist/types/src/hooks/useTraceMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTraceMessages.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useTraceMessages.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,IAAI,MAAM,iCAAiC,CAAC;AAIxD,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAIrD;;GAEG;AACH,eAAO,MAAM,oBAAoB,UAAW,KAAK,KAAG,IAAI,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,OAAO,EAAE,CAenF,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG;IACpC,uGAAuG;IACvG,QAAQ,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC;CAC9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,WACnB,KAAK,iBACC,uBAAuB,KACpC,SAAS,KAAK,CAAC,OAAO,EASxB,CAAC"}

package/dist/types/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './components/index.ts';
+export * from './execution-graph/index.ts';
+export * from './hooks/index.ts';
+export * from './session-timeline/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC"}

package/dist/types/src/session-timeline/index.d.ts

@@ -0,0 +1,3 @@
+export * from './session-timeline.ts';
+export * from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/session-timeline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/session-timeline/index.ts"],"names":[],"mappings":"AAIA,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC"}

package/dist/types/src/session-timeline/session-timeline.d.ts

@@ -0,0 +1,19 @@
+import * as Process from '@dxos/compute/Process';
+import * as Trace from '@dxos/compute/Trace';
+import { Task } from '@dxos/types';
+import { type Session, type SessionTimeline } from './types.ts';
+export interface BuildSessionTimelineInput {
+    traceMessages: readonly Trace.Message[];
+    processes?: readonly Process.Info[];
+    /** The sessions to draw; each contributes a lane and its checklist's task lanes. */
+    sessions?: readonly Session[];
+    tasks?: readonly Task.Task[];
+    /** Reference time; extends the range past open lanes. */
+    now?: number;
+}
+/**
+ * Builds the gantt-shaped view of one or more assistant sessions from their trace: session lanes
+ * (supervisors and the sub-agents they delegate to), task lanes, and the markers on each.
+ */
+export declare const buildSessionTimeline: ({ traceMessages, processes, sessions, tasks, now, }: BuildSessionTimelineInput) => SessionTimeline;
+//# sourceMappingURL=session-timeline.d.ts.map

package/dist/types/src/session-timeline/session-timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-timeline.d.ts","sourceRoot":"","sources":["../../../../src/session-timeline/session-timeline.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAC;AAG7C,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAInC,OAAO,EAIL,KAAK,OAAO,EACZ,KAAK,eAAe,EAErB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,SAAS,KAAK,CAAC,OAAO,EAAE,CAAC;IACxC,SAAS,CAAC,EAAE,SAAS,OAAO,CAAC,IAAI,EAAE,CAAC;IACpC,oFAAoF;IACpF,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,SAAS,IAAI,CAAC,IAAI,EAAE,CAAC;IAC7B,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAgJD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,wDAM9B,yBAAyB,KAAG,eAsV9B,CAAC"}

package/dist/types/src/session-timeline/session-timeline.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-timeline.test.d.ts.map

package/dist/types/src/session-timeline/session-timeline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-timeline.test.d.ts","sourceRoot":"","sources":["../../../../src/session-timeline/session-timeline.test.ts"],"names":[],"mappings":""}

package/dist/types/src/session-timeline/types.d.ts

@@ -0,0 +1,129 @@
+import * as Schema from 'effect/Schema';
+export declare const LaneKind: Schema.Literals<readonly ["session", "task"]>;
+export type LaneKind = Schema.Schema.Type<typeof LaneKind>;
+export declare const LaneStatus: Schema.Literals<readonly ["pending", "blocked", "running", "review", "done", "failed"]>;
+export type LaneStatus = Schema.Schema.Type<typeof LaneStatus>;
+export declare const TokenUsage: Schema.Struct<{
+    readonly input: Schema.Number;
+    readonly output: Schema.Number;
+    readonly total: Schema.Number;
+}>;
+export type TokenUsage = Schema.Schema.Type<typeof TokenUsage>;
+/**
+ * A conversation the timeline draws as a session lane: the chat, reduced to what the join needs so
+ * the builder does not depend on the chat's schema. `uri` is what the agent process targets and
+ * `feedId` what its trace meta names; `taskIds` is the checklist.
+ */
+export declare const Session: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly label: Schema.optional<Schema.String>;
+    readonly uri: Schema.String;
+    readonly feedId: Schema.optional<Schema.String>;
+    readonly taskIds: Schema.$Array<Schema.String>;
+}>;
+export type Session = Schema.Schema.Type<typeof Session>;
+/**
+ * Node in the supervisor lane a child session was spawned from, so the connector can start at the
+ * exact marker rather than at the lane's edge.
+ */
+export declare const DelegationSource: Schema.Struct<{
+    readonly laneId: Schema.String;
+    readonly markerId: Schema.String;
+}>;
+export type DelegationSource = Schema.Schema.Type<typeof DelegationSource>;
+/**
+ * One row of the timeline: a session (supervisor or delegated sub-agent) rendered as a box spanning
+ * `start`..`end`, or a task rendered as a thin line grouped under its session.
+ */
+export declare const Lane: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["session", "task"]>;
+    readonly label: Schema.String;
+    readonly status: Schema.Literals<readonly ["pending", "blocked", "running", "review", "done", "failed"]>;
+    /** Epoch ms. */
+    readonly start: Schema.optional<Schema.Number>;
+    readonly end: Schema.optional<Schema.Number>;
+    readonly parentId: Schema.optional<Schema.String>;
+    readonly sessionId: Schema.optional<Schema.String>;
+    readonly taskId: Schema.optional<Schema.String>;
+    readonly pid: Schema.optional<Schema.String>;
+    /** Lane ids this lane waits on (task dependencies). */
+    readonly blockedOn: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly delegatedFrom: Schema.optional<Schema.Struct<{
+        readonly laneId: Schema.String;
+        readonly markerId: Schema.String;
+    }>>;
+    readonly tokens: Schema.optional<Schema.Struct<{
+        readonly input: Schema.Number;
+        readonly output: Schema.Number;
+        readonly total: Schema.Number;
+    }>>;
+    readonly toolCalls: Schema.optional<Schema.Number>;
+}>;
+export type Lane = Schema.Schema.Type<typeof Lane>;
+export declare const MarkerKind: Schema.Literals<readonly ["request", "operation", "tool", "message", "error", "delegation", "task"]>;
+export type MarkerKind = Schema.Schema.Type<typeof MarkerKind>;
+export declare const MarkerLevel: Schema.Literals<readonly ["info", "warn", "error"]>;
+export type MarkerLevel = Schema.Schema.Type<typeof MarkerLevel>;
+/**
+ * A point event on a lane, rendered as a node inside the session box.
+ */
+export declare const Marker: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly laneId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "operation", "tool", "message", "error", "delegation", "task"]>;
+    readonly timestamp: Schema.Number;
+    readonly label: Schema.String;
+    readonly level: Schema.optional<Schema.Literals<readonly ["info", "warn", "error"]>>;
+    readonly pid: Schema.optional<Schema.String>;
+    readonly detail: Schema.optional<Schema.Unknown>;
+}>;
+export type Marker = Schema.Schema.Type<typeof Marker>;
+export declare const TimeRange: Schema.Struct<{
+    readonly start: Schema.Number;
+    readonly end: Schema.Number;
+}>;
+export type TimeRange = Schema.Schema.Type<typeof TimeRange>;
+export declare const SessionTimeline: Schema.Struct<{
+    readonly lanes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["session", "task"]>;
+        readonly label: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "blocked", "running", "review", "done", "failed"]>;
+        /** Epoch ms. */
+        readonly start: Schema.optional<Schema.Number>;
+        readonly end: Schema.optional<Schema.Number>;
+        readonly parentId: Schema.optional<Schema.String>;
+        readonly sessionId: Schema.optional<Schema.String>;
+        readonly taskId: Schema.optional<Schema.String>;
+        readonly pid: Schema.optional<Schema.String>;
+        /** Lane ids this lane waits on (task dependencies). */
+        readonly blockedOn: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly delegatedFrom: Schema.optional<Schema.Struct<{
+            readonly laneId: Schema.String;
+            readonly markerId: Schema.String;
+        }>>;
+        readonly tokens: Schema.optional<Schema.Struct<{
+            readonly input: Schema.Number;
+            readonly output: Schema.Number;
+            readonly total: Schema.Number;
+        }>>;
+        readonly toolCalls: Schema.optional<Schema.Number>;
+    }>>;
+    readonly markers: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly laneId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["request", "operation", "tool", "message", "error", "delegation", "task"]>;
+        readonly timestamp: Schema.Number;
+        readonly label: Schema.String;
+        readonly level: Schema.optional<Schema.Literals<readonly ["info", "warn", "error"]>>;
+        readonly pid: Schema.optional<Schema.String>;
+        readonly detail: Schema.optional<Schema.Unknown>;
+    }>>;
+    readonly range: Schema.Struct<{
+        readonly start: Schema.Number;
+        readonly end: Schema.Number;
+    }>;
+}>;
+export type SessionTimeline = Schema.Schema.Type<typeof SessionTimeline>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/src/session-timeline/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/session-timeline/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,QAAQ,+CAAuC,CAAC;AAC7D,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE3D,eAAO,MAAM,UAAU,yFAAiF,CAAC;AACzG,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;EAIrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,OAAO;;;;;;EAMlB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;EAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3E;;;GAGG;AACH,eAAO,MAAM,IAAI;;;;;IAKf,gBAAgB;;;;;;;IAOhB,uDAAuD;;;;;;;;;;;;EAKvD,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnD,eAAO,MAAM,UAAU,sGAA8F,CAAC;AACtH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,WAAW,qDAA6C,CAAC;AACtE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;;;EASjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,CAAC;AAEvD,eAAO,MAAM,SAAS;;;EAGpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D,eAAO,MAAM,eAAe;;;;;;QA1C1B,gBAAgB;;;;;;;QAOhB,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCvD,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/types/src/testing/index.d.ts

@@ -0,0 +1,5 @@
+export * from './simulated-agent.ts';
+export * from './snapshot-playback.ts';
+export * from './test-trace.ts';
+export { default as subAgentDelegationFixture } from '../execution-graph/testing/sub-agent-delegation.json';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,sDAAsD,CAAC"}

package/dist/types/src/testing/simulated-agent.d.ts

@@ -0,0 +1,63 @@
+import * as Effect from 'effect/Effect';
+import { type ProcessManager } from '@dxos/compute-runtime';
+import * as Process from '@dxos/compute/Process';
+import * as Trace from '@dxos/compute/Trace';
+/**
+ * One simulated operation. Rendered as a child process in the tree and as an `operation.start`/
+ * `operation.end` span on the timeline.
+ */
+export interface SimulatedTool {
+    readonly key: string;
+    readonly name: string;
+    readonly icon?: string;
+    readonly durationMs: number;
+    /** Nested operations, spawned under this one so the tree exercises more than one level. */
+    readonly children?: readonly SimulatedTool[];
+    /** Run `children` concurrently, producing parallel lanes on the timeline. */
+    readonly concurrent?: boolean;
+    /** End with `outcome: 'failure'` and fail the process. */
+    readonly fail?: boolean;
+}
+export interface AgentScenario {
+    readonly name: string;
+    readonly prompt: string;
+    readonly tools: readonly SimulatedTool[];
+}
+export declare const agentScenarios: readonly AgentScenario[];
+/**
+ * Storybook fixture: a {@link Process} standing in for a conversational agent. Each input advances
+ * it one step, so the caller can interleave the agent's own trace events with the child operation
+ * processes that {@link runScenario} spawns beneath it.
+ */
+export declare const SimulatedAgent: Process.Process<{
+    readonly _tag: "begin";
+    readonly prompt: string;
+} | {
+    readonly _tag: "toolCall";
+    readonly toolCallId: string;
+    readonly name: string;
+} | {
+    readonly _tag: "toolResult";
+    readonly toolCallId: string;
+    readonly name: string;
+} | {
+    readonly _tag: "end";
+    readonly status: "error" | "success";
+}, void, Trace.TraceService, never>;
+/**
+ * Storybook fixture: a {@link Process} that emits the `operation.start`/`operation.end` pair a real
+ * operation process emits, with a simulated execution time in between.
+ */
+export declare const SimulatedOperation: Process.Process<{
+    readonly key: string;
+    readonly name: string;
+    readonly icon?: string | undefined;
+    readonly durationMs: number;
+    readonly fail?: boolean | undefined;
+}, void, Trace.TraceService, never>;
+/**
+ * Runs one {@link agentScenarios} entry end to end: an agent process with a child operation process
+ * per tool, so the panel has both a populated process tree and a timeline with nested spans.
+ */
+export declare const runScenario: (manager: ProcessManager.Manager, index: number, environment: Process.Environment) => Effect.Effect<void>;
+//# sourceMappingURL=simulated-agent.d.ts.map

package/dist/types/src/testing/simulated-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulated-agent.d.ts","sourceRoot":"","sources":["../../../../src/testing/simulated-agent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,OAAO,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,KAAK,MAAM,qBAAqB,CAAC;AAG7C;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC7C,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;CAC1C;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,aAAa,EA0ClD,CAAC;AA0BF;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;mCAsE1B,CAAC;AAgBF;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;mCA8B9B,CAAC;AAqCF;;;GAGG;AACH,eAAO,MAAM,WAAW,YACb,cAAc,CAAC,OAAO,SACxB,MAAM,eACA,OAAO,CAAC,WAAW,KAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,CAmBE,CAAC"}

package/dist/types/src/testing/snapshot-playback.d.ts

@@ -0,0 +1,12 @@
+import { type Dispatch, type SetStateAction } from 'react';
+/**
+ * Interval (ms) between auto-played trace messages in the snapshot playback story.
+ */
+export declare const PLAYBACK_INTERVAL_MS = 250;
+export declare const STEP_STORAGE_KEY = "plugin-assistant.trace-panel.snapshot.step";
+/**
+ * `useState<number>` that hydrates from and persists to `localStorage`.
+ * The third tuple member is `true` iff a valid value was loaded on first render.
+ */
+export declare const useLocalStorageNumber: (key: string, initial: number) => [number, Dispatch<SetStateAction<number>>, boolean];
+//# sourceMappingURL=snapshot-playback.d.ts.map

package/dist/types/src/testing/snapshot-playback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-playback.d.ts","sourceRoot":"","sources":["../../../../src/testing/snapshot-playback.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAA+B,MAAM,OAAO,CAAC;AAExF;;GAEG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,eAAO,MAAM,gBAAgB,+CAA+C,CAAC;AAE7E;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAC3B,MAAM,WACF,MAAM,KACd,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAwBpD,CAAC"}

package/dist/types/src/testing/test-trace.d.ts

@@ -0,0 +1,5 @@
+import * as Process from '@dxos/compute/Process';
+export declare const makeProcess: (overrides: Partial<Process.Info> & Pick<Process.Info, 'pid' | 'state'> & {
+    name: string;
+}) => Process.Info;
+//# sourceMappingURL=test-trace.d.ts.map

package/dist/types/src/testing/test-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-trace.d.ts","sourceRoot":"","sources":["../../../../src/testing/test-trace.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,OAAO,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,WAAW,cACX,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,KACxF,OAAO,CAAC,IAUT,CAAC"}