@swirls/looms 0.1.0 → 0.2.0

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

@@ -1,24 +1,54 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ChevronDown, ChevronRight } from 'lucide-react';
-import { memo, useCallback, useState } from 'react';
+import { useVirtualizer } from '@tanstack/react-virtual';
+import { ChevronRight } from 'lucide-react';
+import { useCallback, useMemo, useRef, 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, }) {
+import { PanelHeader, PanelTitle } from '../ui/panel.js';
+import { ScrollArea } from '../ui/scroll-area.js';
+import { StatusBadge, StatusDot } from './status-dot.js';
+const ROW_HEIGHT = 28;
+const INDENT = 14;
+function flatten(root, collapsed) {
+    const rows = [];
+    if (!root) {
+        return rows;
+    }
+    const stack = [{ node: root, depth: 0 }];
+    while (stack.length > 0) {
+        const next = stack.pop();
+        if (!next) {
+            break;
+        }
+        rows.push(next);
+        if (!collapsed.has(next.node.threadId)) {
+            for (let index = next.node.children.length - 1; index >= 0; index--) {
+                const child = next.node.children[index];
+                if (child) {
+                    stack.push({ node: child, depth: next.depth + 1 });
+                }
+            }
+        }
+    }
+    return rows;
+}
+function NodeRow({ row, selected, count, collapsed, onToggle, onSelect, }) {
+    const { node, depth } = row;
     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] }));
-});
+    return (_jsxs("div", { className: cn('group/row relative flex h-7 items-center rounded-md pr-2 text-xs', selected ? 'bg-accent text-foreground' : 'hover:bg-accent/50'), style: { paddingLeft: 4 + depth * INDENT }, title: `${node.definitionName} · ${node.kind} · ${node.status}`, children: [Array.from({ length: depth }, (_, level) => (_jsx("span", { "aria-hidden": true, className: "bg-border absolute inset-y-0 w-px", style: { left: 12 + level * INDENT } }, level))), hasChildren ? (_jsx("button", { type: "button", className: "text-muted-foreground hover:text-foreground hover:bg-background/40 flex size-4 shrink-0 items-center justify-center rounded-sm", onClick: () => onToggle(node.threadId), "aria-label": collapsed ? 'Expand thread' : 'Collapse thread', "aria-expanded": !collapsed, children: _jsx(ChevronRight, { className: cn('ease-snappy size-3 transition-transform duration-100', !collapsed && 'rotate-90') }) })) : (_jsx("span", { className: "size-4 shrink-0" })), _jsxs("button", { type: "button", className: "flex h-full min-w-0 flex-1 items-center gap-2 pl-1 text-left", onClick: () => onSelect(node.threadId), children: [_jsx(StatusDot, { status: node.status }), _jsxs("span", { className: "min-w-0 truncate", children: [_jsx("span", { className: "font-medium", children: node.definitionName }), _jsx("span", { className: "text-muted-foreground ml-1.5 font-mono text-[10px]", children: node.kind })] }), _jsx("span", { className: "text-muted-foreground ml-auto shrink-0 font-mono text-[10px] tabular-nums", children: count })] })] }));
+}
 export function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, formatRunLabel = shortId, showHeading = true, }) {
-    const [collapsed, setCollapsed] = useState(new Set());
+    const [collapsed, setCollapsed] = useState(() => new Set());
     const runCount = totalEventCount ?? eventCounts.get('run') ?? 0;
+    const rows = useMemo(() => flatten(tree.root, collapsed), [tree.root, collapsed]);
+    const parentRef = useRef(null);
+    const virtualizer = useVirtualizer({
+        count: rows.length,
+        getScrollElement: () => parentRef.current,
+        estimateSize: () => ROW_HEIGHT,
+        overscan: 12,
+        getItemKey: (index) => rows[index]?.node.threadId ?? index,
+        useFlushSync: false,
+    });
     const toggle = useCallback((id) => {
         setCollapsed((prev) => {
             const next = new Set(prev);
@@ -31,8 +61,11 @@ export function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount,
             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" }))] }));
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [showHeading ? (_jsxs(PanelHeader, { children: [_jsx(PanelTitle, { children: "Run tree" }), _jsx(StatusBadge, { status: runStatus, className: "ml-auto" })] })) : null, _jsx("div", { className: "px-2 pt-2", children: _jsxs("button", { type: "button", onClick: () => onSelectThread(undefined), className: cn('flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs', !selectedThread ? 'bg-accent text-foreground' : 'hover:bg-accent/50'), children: [_jsx("span", { className: "text-muted-foreground", children: "All threads" }), _jsx("span", { className: "text-muted-foreground/70 truncate font-mono text-[10px]", children: formatRunLabel(runId) }), _jsx("span", { className: "text-muted-foreground ml-auto font-mono text-[10px] tabular-nums", children: runCount })] }) }), rows.length === 0 ? (_jsx("p", { className: "text-muted-foreground px-4 py-2 text-xs", children: "Waiting for threads\u2026" })) : (_jsx(ScrollArea, { viewportRef: parentRef, className: "min-h-0 flex-1", children: _jsx("div", { className: "relative mx-2 mb-2", style: { height: virtualizer.getTotalSize() }, children: virtualizer.getVirtualItems().map((item) => {
+                        const row = rows[item.index];
+                        if (!row) {
+                            return null;
+                        }
+                        return (_jsx("div", { className: "absolute top-0 left-0 w-full", style: { transform: `translateY(${item.start}px)`, height: ROW_HEIGHT }, children: _jsx(NodeRow, { row: row, selected: selectedThread === row.node.threadId, count: eventCounts.get(row.node.threadId) ?? 0, collapsed: collapsed.has(row.node.threadId), onToggle: toggle, onSelect: onSelectThread }) }, item.key));
+                    }) }) }))] }));
 }

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

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

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

@@ -1,5 +1,9 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { statusDotClass } from '../lib/status.js';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../lib/cn.js';
+import { statusClass, statusDotClass } from '../lib/status.js';
 export function StatusDot({ status }) {
     return _jsx("span", { className: statusDotClass(status), "aria-hidden": true });
 }
+export function StatusBadge({ status, className }) {
+    return (_jsxs("span", { className: cn('inline-flex h-5 shrink-0 items-center gap-1.5 rounded-full bg-current/10 px-2 text-[11px] font-medium', statusClass(status), className), children: [_jsx(StatusDot, { status: status }), status] }));
+}

package/dist/debugger/context.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+import { type LoomsClient } from '@swirls/looms/client';
+import type { DebuggerPlugin } from './plugin';
+export interface DebuggerContextValue {
+    readonly client: LoomsClient;
+    readonly plugins: readonly DebuggerPlugin[];
+}
+/** Supplies one Looms host to both the API client and the run stores. */
+export declare function DebuggerProvider({ endpoint, plugins, children, }: {
+    endpoint?: string;
+    plugins: readonly DebuggerPlugin[];
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useDebugger(): DebuggerContextValue;

package/dist/debugger/context.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { createLoomsClient } from '@swirls/looms/client';
+import { LoomsProvider } from '@swirls/looms/react';
+const DebuggerContext = createContext(null);
+/** Supplies one Looms host to both the API client and the run stores. */
+export function DebuggerProvider({ endpoint = '', plugins, children, }) {
+    const value = useMemo(() => ({ client: createLoomsClient({ baseUrl: endpoint }), plugins }), [endpoint, plugins]);
+    return (_jsx(LoomsProvider, { endpoint: endpoint, children: _jsx(DebuggerContext.Provider, { value: value, children: children }) }));
+}
+export function useDebugger() {
+    const value = useContext(DebuggerContext);
+    if (!value) {
+        throw new Error('useDebugger must be used within DebuggerProvider');
+    }
+    return value;
+}

package/dist/debugger/contracts.d.ts

@@ -1,12 +1,15 @@
 import type { EventEnvelope, JsonValue, ReplayStep, ThreadTree } from '@swirls/looms/core';
-import type { EventFamily, EventSummary } from './events/family';
+export type EventSummary = {
+    title: string;
+    detail?: string;
+};
 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;
+    familyColor: (family: string) => string;
     summarize: (event: TEvent) => EventSummary;
-    searchText?: (event: TEvent) => string;
+    searchText: (event: TEvent) => string;
 };
 export type ReplayLoader = (input: {
     runId: string;
@@ -19,4 +22,4 @@ export type RunTreeModel = {
     eventCounts: Map<string, number>;
     totalEventCount?: number;
 };
-export type { EventFamily, EventSummary, JsonValue, ReplayStep, ThreadTree };
+export type { JsonValue, ReplayStep, ThreadTree };

package/dist/debugger/events/builtin-families.d.ts

@@ -0,0 +1,3 @@
+import type { EventFamilyView } from '../plugin';
+export declare const runtimeFamily: EventFamilyView;
+export declare const builtinFamilies: readonly EventFamilyView[];

package/dist/debugger/events/builtin-families.js

@@ -0,0 +1,9 @@
+export const runtimeFamily = {
+    family: 'runtime',
+    prefix: 'runtime.',
+    color: 'oklch(0.76 0.13 155)',
+};
+export const builtinFamilies = [
+    { family: 'wait', prefix: 'runtime.wait', color: 'oklch(0.8 0.14 85)' },
+    runtimeFamily,
+];

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

@@ -1,6 +1,5 @@
 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>;
+import type { DebuggerPlugin } from '../plugin';
+/** Each event type belongs to the family view with the longest matching prefix. */
+export declare function createEventCatalog<TEvent extends DebuggerEvent = DebuggerEvent>(plugins?: readonly DebuggerPlugin[]): EventStreamCatalog<TEvent>;
 export declare const defaultEventCatalog: EventStreamCatalog;

package/dist/debugger/events/catalog.js

@@ -1,27 +1,37 @@
 import { compactJson } from '../lib/cn.js';
-import { summarizeDomainEvent } from './domain-summarize.js';
-import { DEFAULT_FAMILIES, familyClass, familyFromPrefix } from './family.js';
+import { builtinFamilies, runtimeFamily } from './builtin-families.js';
 import { summarizeProtocolEvent } from './protocol-summarize.js';
-export function summarizeEvent(event) {
-    return (summarizeProtocolEvent(event) ??
-        summarizeDomainEvent(event) ?? {
-        title: event.type,
-        detail: compactJson(event.payload),
-    });
+function prefixOf(view) {
+    return view.prefix ?? `${view.family}.`;
 }
-export function searchText(event, summarize = summarizeEvent) {
-    const summary = summarize(event);
+function searchText(event, summary) {
     return [event.type, event.threadId ?? '', summary.title, summary.detail ?? '', event.id]
         .join(' ')
         .toLowerCase();
 }
-export function createDefaultCatalog() {
+/** Each event type belongs to the family view with the longest matching prefix. */
+export function createEventCatalog(plugins = []) {
+    const views = [...plugins.flatMap((plugin) => plugin.families ?? []), ...builtinFamilies];
+    // ES2022 has no Array#toSorted. `views` is a fresh array.
+    // oxlint-disable-next-line unicorn/no-array-sort
+    const byPrefix = views.sort((left, right) => prefixOf(right).length - prefixOf(left).length);
+    const colors = new Map(views.map((view) => [view.family, view.color]));
+    function viewOf(type) {
+        return byPrefix.find((view) => type.startsWith(prefixOf(view))) ?? runtimeFamily;
+    }
+    function summarize(event) {
+        return (summarizeProtocolEvent(event) ??
+            viewOf(event.type).summarize?.(event) ?? {
+            title: event.type,
+            detail: compactJson(event.payload),
+        });
+    }
     return {
-        families: DEFAULT_FAMILIES,
-        familyOf: familyFromPrefix,
-        familyClass,
-        summarize: (event) => summarizeEvent(event),
-        searchText: (event) => searchText(event),
+        families: [...new Set(views.map((view) => view.family))],
+        familyOf: (type) => viewOf(type).family,
+        familyColor: (family) => colors.get(family) ?? runtimeFamily.color,
+        summarize,
+        searchText: (event) => searchText(event, summarize(event)),
     };
 }
-export const defaultEventCatalog = createDefaultCatalog();
+export const defaultEventCatalog = createEventCatalog();

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

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

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

@@ -1,45 +1,37 @@
-import { isJsonNumber, isJsonObject, isJsonString, isProtocolType, } from '@swirls/looms/core';
+import { isJsonNumber, 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;
-}
+import { jsonFields, jsonNumberText, jsonText } from '../lib/payload.js';
 export function summarizeProtocolEvent(event) {
     if (!isProtocolType(event.type)) {
         return undefined;
     }
-    const payload = obj(event.payload);
+    const payload = jsonFields(event.payload);
     switch (event.type) {
         case 'runtime.run.started':
             return {
                 title: 'run started',
-                detail: `${text(payload.kind) ?? 'run'}:${text(payload.definitionName) ?? 'unknown'}`,
+                detail: `${jsonText(payload.kind) ?? 'run'}:${jsonText(payload.definitionName) ?? 'unknown'}`,
             };
         case 'runtime.run.completed':
             return {
-                title: text(payload.error) ? 'run failed' : 'run completed',
-                detail: text(payload.error) ?? compactJson(payload.output ?? null),
+                title: jsonText(payload.error) ? 'run failed' : 'run completed',
+                detail: jsonText(payload.error) ?? compactJson(payload.output ?? null),
             };
         case 'runtime.run.cancelled':
-            return { title: 'run cancelled', detail: text(payload.reason) };
+            return { title: 'run cancelled', detail: jsonText(payload.reason) };
         case 'runtime.thread.started':
             return {
                 title: 'thread started',
-                detail: `${text(payload.kind) ?? 'thread'}:${text(payload.definitionName) ?? 'unknown'}`,
+                detail: `${jsonText(payload.kind) ?? 'thread'}:${jsonText(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) };
+            return { title: 'thread failed', detail: jsonText(payload.error) };
         case 'runtime.thread.cancelled':
-            return { title: 'thread cancelled', detail: text(payload.reason) };
+            return { title: 'thread cancelled', detail: jsonText(payload.reason) };
         case 'runtime.wait.registered': {
-            const on = obj(payload.on ?? null);
+            const on = jsonFields(payload.on ?? null);
             const type = on.type;
             const detail = isJsonString(type)
                 ? type
@@ -51,46 +43,46 @@ export function summarizeProtocolEvent(event) {
             return { title: 'wait registered', detail };
         }
         case 'runtime.wait.satisfied': {
-            const waited = obj(payload.event ?? null);
-            return { title: 'wait satisfied', detail: text(waited.type) };
+            const waited = jsonFields(payload.event ?? null);
+            return { title: 'wait satisfied', detail: jsonText(waited.type) };
         }
         case 'runtime.timer.set':
-            return { title: 'timer set', detail: numeric(payload.wakeAt) };
+            return { title: 'timer set', detail: jsonNumberText(payload.wakeAt) };
         case 'runtime.timer.fired':
             return { title: 'timer fired' };
         case 'runtime.effect.failed':
-            return { title: 'effect failed', detail: text(payload.error) };
+            return { title: 'effect failed', detail: jsonText(payload.error) };
         case 'runtime.effect.attempt.started':
-            return { title: 'effect attempt started', detail: numeric(payload.attempt) };
+            return { title: 'effect attempt started', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.queued':
-            return { title: 'effect queued', detail: numeric(payload.attempt) };
+            return { title: 'effect queued', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.dispatched':
-            return { title: 'effect dispatched', detail: numeric(payload.attempt) };
+            return { title: 'effect dispatched', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.worker.started':
-            return { title: 'worker started effect', detail: numeric(payload.attempt) };
+            return { title: 'worker started effect', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.heartbeat':
-            return { title: 'effect heartbeat', detail: numeric(payload.attempt) };
+            return { title: 'effect heartbeat', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.completed':
-            return { title: 'effect completed', detail: numeric(payload.attempt) };
+            return { title: 'effect completed', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.cancel.requested':
-            return { title: 'effect cancellation requested', detail: numeric(payload.attempt) };
+            return { title: 'effect cancellation requested', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.cancelled':
-            return { title: 'effect cancelled', detail: numeric(payload.attempt) };
+            return { title: 'effect cancelled', detail: jsonNumberText(payload.attempt) };
         case 'runtime.effect.timed_out':
-            return { title: 'effect timed out', detail: text(payload.timeout) };
+            return { title: 'effect timed out', detail: jsonText(payload.timeout) };
         case 'runtime.effect.ambiguous':
-            return { title: 'effect outcome ambiguous', detail: text(payload.error) };
+            return { title: 'effect outcome ambiguous', detail: jsonText(payload.error) };
         case 'runtime.effect.retry.scheduled':
-            return { title: 'effect retry scheduled', detail: text(payload.error) };
+            return { title: 'effect retry scheduled', detail: jsonText(payload.error) };
         case 'runtime.snapshot.taken':
-            return { title: 'snapshot', detail: `seq ${numeric(payload.seq) ?? ''}` };
+            return { title: 'snapshot', detail: `seq ${jsonNumberText(payload.seq) ?? ''}` };
         case 'runtime.signal.received':
             return { title: 'signal', detail: compactJson(event.payload) };
         case 'runtime.thread.cancel.requested':
-            return { title: 'thread cancellation requested', detail: text(payload.threadId) };
+            return { title: 'thread cancellation requested', detail: jsonText(payload.threadId) };
         default: {
             const exhaustiveType = event.type;
-            return { title: 'event', detail: compactJson(obj(exhaustiveType)) };
+            return { title: 'event', detail: compactJson(jsonFields(exhaustiveType)) };
         }
     }
 }

package/dist/debugger/index.d.ts

@@ -1,17 +1,31 @@
-export type { DebuggerEvent, EventFamily, EventStreamCatalog, EventSummary, ReplayLoader, ReplayStep, RunTreeModel, ThreadTree, } from './contracts';
-export { DEFAULT_FAMILIES, familyClass, familyFromPrefix } from './events/family';
+export type { DebuggerEvent, EventStreamCatalog, EventSummary, ReplayLoader, ReplayStep, RunTreeModel, ThreadTree, } from './contracts';
+export { createEventCatalog, defaultEventCatalog } from './events/catalog';
 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 { DebuggerProvider, useDebugger, type DebuggerContextValue } from './context';
+export { projectionFor, workspaceFor, type DebuggerPlugin, type EventFamilyView, type ProjectionView, type WorkspaceContext, type WorkspaceView, } from './plugin';
+export { DebuggerShell, type DebuggerSelection } from './shell/debugger-shell';
+export { StartForm } from './shell/start-form';
+export { useStartRun, type StartRun } from './shell/use-start-run';
+export { formInput, inputForm, messageInput, type FormField, type FormValues, type InputForm, } from './shell/schema-form';
+export { cn, compactJson, errorMessage, shortId } from './lib/cn';
+export { jsonFields, jsonNumberText, jsonText } from './lib/payload';
 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 { StatusBadge, StatusDot } from './components/status-dot';
 export { JsonView } from './components/json-view';
+export { JsonTree } from './components/json-tree';
+export { parseStructuredJson } from './lib/json';
+export { FollowList } from './components/follow-list';
+export { Composer } from './components/composer';
 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 { Button, type ButtonSize, type ButtonVariant } from './ui/button';
 export { Checkbox } from './ui/checkbox';
+export { Input } from './ui/input';
+export { Textarea } from './ui/textarea';
+export { EmptyState, Kbd, PanelHeader, PanelTitle } from './ui/panel';
+export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from './ui/select';
 export { ScrollArea, ScrollBar } from './ui/scroll-area';

package/dist/debugger/index.js

@@ -1,16 +1,30 @@
-export { DEFAULT_FAMILIES, familyClass, familyFromPrefix } from './events/family.js';
+export { createEventCatalog, defaultEventCatalog } from './events/catalog.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 { DebuggerProvider, useDebugger } from './context.js';
+export { projectionFor, workspaceFor, } from './plugin.js';
+export { DebuggerShell } from './shell/debugger-shell.js';
+export { StartForm } from './shell/start-form.js';
+export { useStartRun } from './shell/use-start-run.js';
+export { formInput, inputForm, messageInput, } from './shell/schema-form.js';
+export { cn, compactJson, errorMessage, shortId } from './lib/cn.js';
+export { jsonFields, jsonNumberText, jsonText } from './lib/payload.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 { StatusBadge, StatusDot } from './components/status-dot.js';
 export { JsonView } from './components/json-view.js';
+export { JsonTree } from './components/json-tree.js';
+export { parseStructuredJson } from './lib/json.js';
+export { FollowList } from './components/follow-list.js';
+export { Composer } from './components/composer.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 { Button } from './ui/button.js';
 export { Checkbox } from './ui/checkbox.js';
+export { Input } from './ui/input.js';
+export { Textarea } from './ui/textarea.js';
+export { EmptyState, Kbd, PanelHeader, PanelTitle } from './ui/panel.js';
+export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from './ui/select.js';
 export { ScrollArea, ScrollBar } from './ui/scroll-area.js';

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

@@ -3,3 +3,4 @@ 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;
+export declare function errorMessage(cause: unknown): string;

package/dist/debugger/lib/cn.js

@@ -15,3 +15,6 @@ export function compactJson(value) {
     }
     return text.length > 96 ? `${text.slice(0, 93)}…` : text;
 }
+export function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}

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

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

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

@@ -1,19 +1,14 @@
-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, {
-        catalog,
-        meta,
-    });
+    const meta = {
+        summary: catalog.summarize(event),
+        searchText: catalog.searchText(event),
+        family: catalog.familyOf(event.type),
+    };
+    metaCache.set(event, { catalog, meta });
     return meta;
 }

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

@@ -0,0 +1,25 @@
+import { type JsonObject, type JsonValue } from '@swirls/looms/core';
+export type JsonNode = {
+    readonly kind: 'object';
+    readonly value: JsonObject;
+} | {
+    readonly kind: 'array';
+    readonly value: readonly JsonValue[];
+} | {
+    readonly kind: 'string';
+    readonly value: string;
+} | {
+    readonly kind: 'number';
+    readonly value: number;
+} | {
+    readonly kind: 'boolean';
+    readonly value: boolean;
+} | {
+    readonly kind: 'null';
+};
+export declare function jsonNode(value: JsonValue): JsonNode;
+/** Parses text that holds a JSON object or array; plain strings and scalars stay text. */
+export declare function parseStructuredJson(text: string): JsonObject | readonly JsonValue[] | undefined;
+export declare function jsonEntries(node: JsonNode): readonly (readonly [string, JsonValue])[];
+/** One-line summary shown beside a collapsed object or array. */
+export declare function jsonPreview(node: JsonNode, budget?: number): string;