@swirls/looms 0.0.1

package/dist/debugger/components/json-view.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from '@swirls/looms/core';
+export declare function JsonView({ value, className }: {
+    value: JsonValue;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/debugger/components/json-view.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../lib/cn.js';
+export function JsonView({ value, className }) {
+    return (_jsx("pre", { className: cn('text-muted-foreground overflow-auto font-mono text-[11px] leading-relaxed wrap-break-word whitespace-pre-wrap', className), children: JSON.stringify(value, null, 2) }));
+}

package/dist/debugger/components/run-tree.d.ts

@@ -0,0 +1,14 @@
+import type { ThreadNode } from '@swirls/looms/core';
+export declare function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, formatRunLabel, showHeading, }: {
+    runId: string;
+    runStatus: string;
+    tree: {
+        root: ThreadNode | null;
+    };
+    eventCounts: ReadonlyMap<string, number> | Map<string, number>;
+    totalEventCount?: number;
+    selectedThread?: string;
+    onSelectThread: (threadId: string | undefined) => void;
+    formatRunLabel?: (runId: string) => string;
+    showHeading?: boolean;
+}): import("react").JSX.Element;

package/dist/debugger/components/run-tree.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChevronDown, ChevronRight } from 'lucide-react';
+import { memo, useCallback, useState } from 'react';
+import { cn, shortId } from '../lib/cn.js';
+import { statusClass } from '../lib/status.js';
+import { StatusDot } from './status-dot.js';
+const NodeRow = memo(function NodeRow({ node, depth, selected, counts, collapsed, onToggle, onSelect, }) {
+    const hasChildren = node.children.length > 0;
+    const isCollapsed = collapsed.has(node.threadId);
+    const count = counts.get(node.threadId) ?? 0;
+    const handleToggle = useCallback(() => {
+        onToggle(node.threadId);
+    }, [onToggle, node.threadId]);
+    const handleSelect = useCallback(() => {
+        onSelect(node.threadId);
+    }, [onSelect, node.threadId]);
+    return (_jsxs("li", { className: "relative", children: [_jsxs("div", { className: cn('flex items-center gap-1 rounded-md py-0.5 pr-1 text-xs transition-colors', selected === node.threadId ? 'bg-accent font-medium' : 'hover:bg-accent/50'), style: { paddingLeft: 8 + depth * 14 }, children: [hasChildren ? (_jsx("button", { type: "button", className: "text-muted-foreground hover:text-foreground size-4 shrink-0", onClick: handleToggle, "aria-label": isCollapsed ? 'Expand thread' : 'Collapse thread', children: isCollapsed ? _jsx(ChevronRight, { className: "size-3" }) : _jsx(ChevronDown, { className: "size-3" }) })) : (_jsx("span", { className: "size-4 shrink-0" })), _jsxs("button", { type: "button", className: "flex min-w-0 flex-1 items-center gap-1.5 text-left", onClick: handleSelect, children: [_jsx(StatusDot, { status: node.status }), _jsxs("span", { className: "truncate", children: [_jsx("span", { className: "text-foreground font-medium", children: node.definitionName }), _jsxs("span", { className: "text-muted-foreground ml-1 font-mono text-[10px]", children: ["(", node.kind, ")"] })] }), _jsx("span", { className: cn('shrink-0 text-[10px]', statusClass(node.status)), children: node.status }), _jsx("span", { className: "text-muted-foreground ml-auto shrink-0 font-mono text-[10px]", children: count })] })] }), hasChildren && !isCollapsed ? (_jsx("ul", { className: "relative", children: node.children.map((child) => (_jsx(NodeRow, { node: child, depth: depth + 1, selected: selected, counts: counts, collapsed: collapsed, onToggle: onToggle, onSelect: onSelect }, child.threadId))) })) : null] }));
+});
+export function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, formatRunLabel = shortId, showHeading = true, }) {
+    const [collapsed, setCollapsed] = useState(new Set());
+    const runCount = totalEventCount ?? eventCounts.get('run') ?? 0;
+    const toggle = useCallback((id) => {
+        setCollapsed((prev) => {
+            const next = new Set(prev);
+            if (next.has(id)) {
+                next.delete(id);
+            }
+            else {
+                next.add(id);
+            }
+            return next;
+        });
+    }, []);
+    const handleSelectRoot = useCallback(() => {
+        onSelectThread(undefined);
+    }, [onSelectThread]);
+    return (_jsxs("div", { children: [showHeading && (_jsx("h2", { className: "text-muted-foreground px-2 pb-1 text-[11px] font-medium tracking-wide uppercase", children: "Run tree" })), _jsxs("button", { type: "button", onClick: handleSelectRoot, className: cn('mb-0.5 flex w-full items-center gap-1.5 rounded-md px-2 py-1 text-left text-xs', !selectedThread ? 'bg-accent' : 'hover:bg-accent/50'), children: [_jsx(StatusDot, { status: runStatus }), _jsx("span", { className: "truncate font-mono", children: formatRunLabel(runId) }), _jsx("span", { className: cn('ml-auto', statusClass(runStatus)), children: runStatus }), _jsx("span", { className: "text-muted-foreground font-mono text-[10px]", children: runCount })] }), tree.root ? (_jsx("ul", { children: _jsx(NodeRow, { node: tree.root, depth: 0, selected: selectedThread, counts: eventCounts, collapsed: collapsed, onToggle: toggle, onSelect: onSelectThread }) })) : (_jsx("p", { className: "text-muted-foreground px-2 text-xs", children: "Waiting for threads\u2026" }))] }));
+}

package/dist/debugger/components/status-dot.d.ts

@@ -0,0 +1,3 @@
+export declare function StatusDot({ status }: {
+    status: string;
+}): import("react").JSX.Element;

package/dist/debugger/components/status-dot.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { statusDotClass } from '../lib/status.js';
+export function StatusDot({ status }) {
+    return _jsx("span", { className: statusDotClass(status), "aria-hidden": true });
+}

package/dist/debugger/contracts.d.ts

@@ -0,0 +1,22 @@
+import type { EventEnvelope, JsonValue, ReplayStep, ThreadTree } from '@swirls/looms/core';
+import type { EventFamily, EventSummary } from './events/family';
+export type DebuggerEvent<TType extends string = string> = Pick<EventEnvelope<TType>, 'id' | 'runId' | 'seq' | 'ts' | 'type' | 'payload' | 'threadId' | 'causationId' | 'ephemeral'> & Partial<Pick<EventEnvelope<TType>, 'parentThreadId' | 'correlationId' | 'effectId' | 'origin'>>;
+export type EventStreamCatalog<TEvent extends DebuggerEvent = DebuggerEvent> = {
+    families: readonly string[];
+    familyOf: (type: string) => string;
+    familyClass: (family: string) => string;
+    summarize: (event: TEvent) => EventSummary;
+    searchText?: (event: TEvent) => string;
+};
+export type ReplayLoader = (input: {
+    runId: string;
+    seq: number;
+}) => Promise<ReplayStep | null>;
+export type RunTreeModel = {
+    runId: string;
+    runStatus: string;
+    tree: ThreadTree;
+    eventCounts: Map<string, number>;
+    totalEventCount?: number;
+};
+export type { EventFamily, EventSummary, JsonValue, ReplayStep, ThreadTree };

package/dist/debugger/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/debugger/events/catalog.d.ts

@@ -0,0 +1,6 @@
+import type { DebuggerEvent, EventStreamCatalog } from '../contracts';
+import { type EventSummary } from './family';
+export declare function summarizeEvent(event: DebuggerEvent): EventSummary;
+export declare function searchText<TEvent extends DebuggerEvent>(event: TEvent, summarize?: (event: TEvent) => EventSummary): string;
+export declare function createDefaultCatalog<TEvent extends DebuggerEvent = DebuggerEvent>(): EventStreamCatalog<TEvent>;
+export declare const defaultEventCatalog: EventStreamCatalog;

package/dist/debugger/events/catalog.js

@@ -0,0 +1,27 @@
+import { compactJson } from '../lib/cn.js';
+import { summarizeDomainEvent } from './domain-summarize.js';
+import { DEFAULT_FAMILIES, familyClass, familyFromPrefix } from './family.js';
+import { summarizeProtocolEvent } from './protocol-summarize.js';
+export function summarizeEvent(event) {
+    return (summarizeProtocolEvent(event) ??
+        summarizeDomainEvent(event) ?? {
+        title: event.type,
+        detail: compactJson(event.payload),
+    });
+}
+export function searchText(event, summarize = summarizeEvent) {
+    const summary = summarize(event);
+    return [event.type, event.threadId ?? '', summary.title, summary.detail ?? '', event.id]
+        .join(' ')
+        .toLowerCase();
+}
+export function createDefaultCatalog() {
+    return {
+        families: DEFAULT_FAMILIES,
+        familyOf: familyFromPrefix,
+        familyClass,
+        summarize: (event) => summarizeEvent(event),
+        searchText: (event) => searchText(event),
+    };
+}
+export const defaultEventCatalog = createDefaultCatalog();

package/dist/debugger/events/domain-summarize.d.ts

@@ -0,0 +1,3 @@
+import type { DebuggerEvent } from '../contracts';
+import type { EventSummary } from './family';
+export declare function summarizeDomainEvent(event: DebuggerEvent): EventSummary | undefined;

package/dist/debugger/events/domain-summarize.js

@@ -0,0 +1,107 @@
+import { isJsonNumber, isJsonObject, isJsonString } from '@swirls/looms/core';
+import { compactJson } from '../lib/cn.js';
+function obj(value) {
+    return isJsonObject(value) ? value : {};
+}
+function text(value) {
+    return isJsonString(value) ? value : undefined;
+}
+function numeric(value) {
+    return isJsonNumber(value) ? String(value) : undefined;
+}
+function messageContent(payload) {
+    const message = obj(payload ?? null).message;
+    return isJsonObject(message) && isJsonString(message.content) ? message.content : undefined;
+}
+function toolCallSummary(payload) {
+    const call = obj(payload ?? null).toolCall;
+    if (!isJsonObject(call)) {
+        return { name: 'tool', args: null };
+    }
+    const summary = {
+        name: isJsonString(call.name) ? call.name : 'tool',
+        args: call.arguments ?? null,
+    };
+    return summary;
+}
+export function summarizeDomainEvent(event) {
+    const payload = obj(event.payload);
+    switch (event.type) {
+        case 'agent.message.received':
+            return { title: 'user message', detail: messageContent(event.payload) };
+        case 'agent.turn.started':
+            return { title: 'turn started', detail: `turn ${numeric(payload.turn) ?? ''}` };
+        case 'agent.turn.text_delta':
+            return { title: 'text delta', detail: text(payload.delta) };
+        case 'agent.message':
+            return { title: 'agent message', detail: messageContent(event.payload) };
+        case 'agent.tool_call.requested': {
+            const call = toolCallSummary(event.payload);
+            return { title: `tool ${call.name}`, detail: compactJson(call.args) };
+        }
+        case 'agent.tool.result':
+            return {
+                title: text(payload.error)
+                    ? `tool error ${text(payload.name)}`
+                    : `tool result ${text(payload.name)}`,
+                detail: text(payload.error) ?? compactJson(payload.result ?? null),
+            };
+        case 'agent.steered':
+            return { title: 'steered', detail: messageContent(event.payload) };
+        case 'agent.spawn.requested':
+            return {
+                title: 'agent spawn',
+                detail: `${text(payload.kind) ?? 'agent'}:${text(payload.definitionName) ?? 'unknown'}`,
+            };
+        case 'agent.effects.requested':
+            return { title: 'agent effects', detail: text(payload.toolCallId) };
+        case 'workflow.node.started':
+            return { title: 'node started', detail: text(payload.nodeId) };
+        case 'workflow.node.finished':
+            return {
+                title: text(payload.error) ? 'node failed' : 'node finished',
+                detail: text(payload.error) ??
+                    `${text(payload.nodeId) ?? ''} ${compactJson(payload.result ?? null)}`,
+            };
+        case 'workflow.node.skipped':
+            return {
+                title: 'node skipped',
+                detail: `${text(payload.nodeId) ?? ''} · ${text(payload.reason) ?? ''}`,
+            };
+        case 'workflow.spawn.requested':
+            return {
+                title: 'workflow spawn',
+                detail: `${text(payload.definitionName) ?? 'unknown'} from ${text(payload.nodeId) ?? ''}`,
+            };
+        case 'workflow.sleep.requested':
+            return { title: 'sleep', detail: text(payload.nodeId) };
+        case 'workflow.effects.requested':
+            return { title: 'workflow effects', detail: text(payload.nodeId) };
+        case 'approval.requested':
+            return { title: 'approval requested', detail: text(payload.title) };
+        case 'approval.decided':
+            return {
+                title: `approval ${text(payload.outcome) ?? 'decided'}`,
+                detail: text(payload.approvalId),
+            };
+        case 'approval.timed_out':
+            return { title: 'approval timed out', detail: text(payload.approvalId) };
+        case 'payments.charge.requested':
+            return {
+                title: 'charge requested',
+                detail: `${numeric(payload.amount) ?? ''} ${text(payload.currency) ?? ''}`.trim(),
+            };
+        case 'payments.charge.authorized':
+            return {
+                title: 'charge authorized',
+                detail: `${numeric(payload.amount) ?? ''} ${text(payload.currency) ?? ''}`.trim(),
+            };
+        case 'payments.charge.declined':
+            return {
+                title: 'charge declined',
+                detail: `${numeric(payload.amount) ?? ''} ${text(payload.currency) ?? ''} · ${text(payload.reason) ?? ''}`.trim(),
+            };
+        default:
+            return undefined;
+    }
+}

package/dist/debugger/events/family.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_FAMILIES: readonly ['runtime', 'agent', 'workflow', 'approval', 'payments', 'wait'];
+export type EventFamily = (typeof DEFAULT_FAMILIES)[number];
+export type EventSummary = {
+    title: string;
+    detail?: string;
+};
+export declare function familyFromPrefix(type: string): EventFamily;
+export declare function familyClass(family: string): string;

package/dist/debugger/events/family.js

@@ -0,0 +1,44 @@
+export const DEFAULT_FAMILIES = [
+    'runtime',
+    'agent',
+    'workflow',
+    'approval',
+    'payments',
+    'wait',
+];
+export function familyFromPrefix(type) {
+    if (type.startsWith('agent.')) {
+        return 'agent';
+    }
+    if (type.startsWith('workflow.')) {
+        return 'workflow';
+    }
+    if (type.startsWith('approval.')) {
+        return 'approval';
+    }
+    if (type.startsWith('payments.')) {
+        return 'payments';
+    }
+    if (type.startsWith('runtime.wait')) {
+        return 'wait';
+    }
+    return 'runtime';
+}
+export function familyClass(family) {
+    switch (family) {
+        case 'agent':
+            return 'bg-family-agent';
+        case 'workflow':
+            return 'bg-family-workflow';
+        case 'approval':
+            return 'bg-family-approval';
+        case 'payments':
+            return 'bg-family-payments';
+        case 'wait':
+            return 'bg-family-wait';
+        case 'runtime':
+            return 'bg-family-runtime';
+        default:
+            return 'bg-family-runtime';
+    }
+}

package/dist/debugger/events/protocol-summarize.d.ts

@@ -0,0 +1,3 @@
+import type { DebuggerEvent } from '../contracts';
+import type { EventSummary } from './family';
+export declare function summarizeProtocolEvent(event: DebuggerEvent): EventSummary | undefined;

package/dist/debugger/events/protocol-summarize.js

@@ -0,0 +1,70 @@
+import { isJsonNumber, isJsonObject, isJsonString, isProtocolType, } from '@swirls/looms/core';
+import { compactJson } from '../lib/cn.js';
+function obj(value) {
+    return isJsonObject(value) ? value : {};
+}
+function text(value) {
+    return isJsonString(value) ? value : undefined;
+}
+function numeric(value) {
+    return isJsonNumber(value) ? String(value) : undefined;
+}
+export function summarizeProtocolEvent(event) {
+    if (!isProtocolType(event.type)) {
+        return undefined;
+    }
+    const payload = obj(event.payload);
+    switch (event.type) {
+        case 'runtime.run.started':
+            return {
+                title: 'run started',
+                detail: `${text(payload.kind) ?? 'run'}:${text(payload.definitionName) ?? 'unknown'}`,
+            };
+        case 'runtime.run.completed':
+            return {
+                title: text(payload.error) ? 'run failed' : 'run completed',
+                detail: text(payload.error) ?? compactJson(payload.output ?? null),
+            };
+        case 'runtime.thread.started':
+            return {
+                title: 'thread started',
+                detail: `${text(payload.kind) ?? 'thread'}:${text(payload.definitionName) ?? 'unknown'}`,
+            };
+        case 'runtime.thread.completed':
+            return { title: 'thread completed', detail: compactJson(payload.output ?? null) };
+        case 'runtime.thread.failed':
+            return { title: 'thread failed', detail: text(payload.error) };
+        case 'runtime.thread.cancelled':
+            return { title: 'thread cancelled', detail: text(payload.reason) };
+        case 'runtime.wait.registered': {
+            const on = obj(payload.on ?? null);
+            const type = on.type;
+            const detail = isJsonString(type)
+                ? type
+                : Array.isArray(type)
+                    ? type.filter(isJsonString).join(', ')
+                    : isJsonNumber(on.timerAt)
+                        ? `timer ${on.timerAt}`
+                        : undefined;
+            return { title: 'wait registered', detail };
+        }
+        case 'runtime.wait.satisfied': {
+            const waited = obj(payload.event ?? null);
+            return { title: 'wait satisfied', detail: text(waited.type) };
+        }
+        case 'runtime.timer.set':
+            return { title: 'timer set', detail: numeric(payload.wakeAt) };
+        case 'runtime.timer.fired':
+            return { title: 'timer fired' };
+        case 'runtime.effect.failed':
+            return { title: 'effect failed', detail: text(payload.error) };
+        case 'runtime.snapshot.taken':
+            return { title: 'snapshot', detail: `seq ${numeric(payload.seq) ?? ''}` };
+        case 'runtime.signal.received':
+            return { title: 'signal', detail: compactJson(event.payload) };
+        default: {
+            const exhaustiveType = event.type;
+            return { title: 'event', detail: compactJson(obj(exhaustiveType)) };
+        }
+    }
+}

package/dist/debugger/index.d.ts

@@ -0,0 +1,17 @@
+export type { DebuggerEvent, EventFamily, EventStreamCatalog, EventSummary, ReplayLoader, ReplayStep, RunTreeModel, ThreadTree, } from './contracts';
+export { DEFAULT_FAMILIES, familyClass, familyFromPrefix } from './events/family';
+export { summarizeProtocolEvent } from './events/protocol-summarize';
+export { summarizeDomainEvent } from './events/domain-summarize';
+export { createDefaultCatalog, defaultEventCatalog, searchText, summarizeEvent, } from './events/catalog';
+export { cn, compactJson, shortId } from './lib/cn';
+export { statusClass, statusDotClass, type StatusKind } from './lib/status';
+export { countEventsByThread, runStatusFromEvents, startedAtFromEvents } from './lib/event-counts';
+export { projectRunView, type ProjectedRunView } from './lib/project-run';
+export { StatusDot } from './components/status-dot';
+export { JsonView } from './components/json-view';
+export { RunTree } from './components/run-tree';
+export { EventStream } from './components/event-stream';
+export { EventInspector } from './components/event-inspector';
+export { DebuggerSplit } from './components/debugger-split';
+export { Checkbox } from './ui/checkbox';
+export { ScrollArea, ScrollBar } from './ui/scroll-area';

package/dist/debugger/index.js

@@ -0,0 +1,16 @@
+export { DEFAULT_FAMILIES, familyClass, familyFromPrefix } from './events/family.js';
+export { summarizeProtocolEvent } from './events/protocol-summarize.js';
+export { summarizeDomainEvent } from './events/domain-summarize.js';
+export { createDefaultCatalog, defaultEventCatalog, searchText, summarizeEvent, } from './events/catalog.js';
+export { cn, compactJson, shortId } from './lib/cn.js';
+export { statusClass, statusDotClass } from './lib/status.js';
+export { countEventsByThread, runStatusFromEvents, startedAtFromEvents } from './lib/event-counts.js';
+export { projectRunView } from './lib/project-run.js';
+export { StatusDot } from './components/status-dot.js';
+export { JsonView } from './components/json-view.js';
+export { RunTree } from './components/run-tree.js';
+export { EventStream } from './components/event-stream.js';
+export { EventInspector } from './components/event-inspector.js';
+export { DebuggerSplit } from './components/debugger-split.js';
+export { Checkbox } from './ui/checkbox.js';
+export { ScrollArea, ScrollBar } from './ui/scroll-area.js';

package/dist/debugger/lib/cn.d.ts

@@ -0,0 +1,5 @@
+import { type ClassValue } from 'clsx';
+import type { JsonValue } from '@swirls/looms/core';
+export declare function cn(...inputs: ClassValue[]): string;
+export declare function shortId(id: string): string;
+export declare function compactJson(value: JsonValue): string;

package/dist/debugger/lib/cn.js

@@ -0,0 +1,17 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+export function shortId(id) {
+    const cut = id.lastIndexOf('_');
+    const tail = cut >= 0 ? id.slice(cut + 1) : id;
+    return tail.length > 8 ? tail.slice(0, 8) : tail;
+}
+export function compactJson(value) {
+    const text = JSON.stringify(value);
+    if (text === undefined) {
+        return '';
+    }
+    return text.length > 96 ? `${text.slice(0, 93)}…` : text;
+}

package/dist/debugger/lib/event-counts.d.ts

@@ -0,0 +1,5 @@
+import { type EventEnvelope } from '@swirls/looms/core';
+/** Build thread→count map via the shared EventIndex. */
+export declare function countEventsByThread(events: readonly EventEnvelope[]): Map<string, number>;
+export declare function runStatusFromEvents(events: readonly EventEnvelope[]): string;
+export declare function startedAtFromEvents(events: readonly EventEnvelope[]): number | undefined;

package/dist/debugger/lib/event-counts.js

@@ -0,0 +1,23 @@
+import { EventIndex, isJsonObject, isJsonString } from '@swirls/looms/core';
+/** Build thread→count map via the shared EventIndex. */
+export function countEventsByThread(events) {
+    const index = new EventIndex();
+    index.append(events);
+    return new Map(index.getCounts());
+}
+export function runStatusFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (!event || event.type !== 'runtime.run.completed') {
+            continue;
+        }
+        const payload = isJsonObject(event.payload) ? event.payload : {};
+        return isJsonString(payload.error) && payload.error.length > 0 ? 'failed' : 'completed';
+    }
+    return 'running';
+}
+export function startedAtFromEvents(events) {
+    const index = new EventIndex();
+    index.append(events);
+    return index.getStartedAt();
+}

package/dist/debugger/lib/event-meta.d.ts

@@ -0,0 +1,8 @@
+import type { DebuggerEvent, EventStreamCatalog } from '../contracts';
+import type { EventSummary } from '../events/family';
+export interface CachedEventMeta {
+    summary: EventSummary;
+    searchText: string;
+    family: string;
+}
+export declare function getEventMeta<TEvent extends DebuggerEvent>(event: TEvent, catalog?: EventStreamCatalog<TEvent>): CachedEventMeta;

package/dist/debugger/lib/event-meta.js

@@ -0,0 +1,20 @@
+import { searchText, summarizeEvent } from '../events/catalog.js';
+const metaCache = new WeakMap();
+export function getEventMeta(event, catalog) {
+    const existing = metaCache.get(event);
+    if (existing && existing.catalog === catalog) {
+        return existing.meta;
+    }
+    const family = catalog ? catalog.familyOf(event.type) : 'runtime';
+    const summary = catalog ? catalog.summarize(event) : summarizeEvent(event);
+    const text = catalog?.searchText
+        ? catalog.searchText(event)
+        : searchText(event, catalog ? catalog.summarize : summarizeEvent);
+    const meta = { summary, searchText: text, family };
+    metaCache.set(event, {
+        // SAFETY: EventStreamCatalog is covariant over event for cache identity compares.
+        catalog: catalog,
+        meta,
+    });
+    return meta;
+}

package/dist/debugger/lib/project-run.d.ts

@@ -0,0 +1,9 @@
+import { type EventEnvelope, type ThreadTree } from '@swirls/looms/core';
+export type ProjectedRunView = {
+    runId: string;
+    tree: ThreadTree;
+    eventCounts: Map<string, number>;
+    runStatus: string;
+    startedAt?: number;
+};
+export declare function projectRunView(events: readonly EventEnvelope[]): ProjectedRunView;

package/dist/debugger/lib/project-run.js

@@ -0,0 +1,14 @@
+import { EventIndex, project, threadTree, toThreadTree, } from '@swirls/looms/core';
+import { runStatusFromEvents } from './event-counts.js';
+export function projectRunView(events) {
+    const index = new EventIndex();
+    index.append(events);
+    const tree = toThreadTree(project(threadTree, events));
+    return {
+        runId: events[0]?.runId ?? tree.runId,
+        tree,
+        eventCounts: new Map(index.getCounts()),
+        runStatus: runStatusFromEvents(events),
+        startedAt: index.getStartedAt(),
+    };
+}

package/dist/debugger/lib/status.d.ts

@@ -0,0 +1,3 @@
+export type StatusKind = 'running' | 'waiting' | 'completed' | 'failed' | 'cancelled';
+export declare function statusClass(status: string): string;
+export declare function statusDotClass(status: string): string;

package/dist/debugger/lib/status.js

@@ -0,0 +1,31 @@
+import { cn } from './cn.js';
+export function statusClass(status) {
+    switch (status) {
+        case 'running':
+            return 'text-status-running';
+        case 'waiting':
+            return 'text-status-waiting';
+        case 'completed':
+        case 'approved':
+        case 'authorized':
+            return 'text-status-completed';
+        case 'failed':
+        case 'rejected':
+        case 'declined':
+            return 'text-status-failed';
+        default:
+            return 'text-status-cancelled';
+    }
+}
+export function statusDotClass(status) {
+    return cn('inline-block size-1.5 shrink-0 rounded-full', status === 'running' && 'bg-status-running animate-pulse', status === 'waiting' && 'bg-status-waiting', (status === 'completed' || status === 'approved' || status === 'authorized') &&
+        'bg-status-completed', (status === 'failed' || status === 'rejected' || status === 'declined') && 'bg-status-failed', status !== 'running' &&
+        status !== 'waiting' &&
+        status !== 'completed' &&
+        status !== 'approved' &&
+        status !== 'authorized' &&
+        status !== 'failed' &&
+        status !== 'rejected' &&
+        status !== 'declined' &&
+        'bg-status-cancelled');
+}

package/dist/debugger/lib/visible-events.d.ts

@@ -0,0 +1,8 @@
+import type { DebuggerEvent, EventStreamCatalog } from '../contracts';
+export declare function useVisibleEvents<TEvent extends DebuggerEvent>({ events, query, families, threadId, catalog, }: {
+    events: readonly TEvent[];
+    query: string;
+    families: ReadonlySet<string>;
+    threadId?: string;
+    catalog: EventStreamCatalog<TEvent>;
+}): readonly TEvent[];

package/dist/debugger/lib/visible-events.js

@@ -0,0 +1,21 @@
+import { useDeferredValue, useMemo } from 'react';
+import { getEventMeta } from './event-meta.js';
+export function useVisibleEvents({ events, query, families, threadId, catalog, }) {
+    const deferredQuery = useDeferredValue(query);
+    const q = deferredQuery.trim().toLowerCase();
+    return useMemo(() => {
+        return events.filter((event) => {
+            if (threadId && event.threadId !== threadId) {
+                return false;
+            }
+            const meta = getEventMeta(event, catalog);
+            if (!families.has(meta.family)) {
+                return false;
+            }
+            if (q && !meta.searchText.includes(q)) {
+                return false;
+            }
+            return true;
+        });
+    }, [events, q, families, threadId, catalog]);
+}