@vibesdotdev/runnable 0.0.0-stage → 1.0.0-rc.1

package/dist/svelte/components/records/RunList.svelte

@@ -0,0 +1,190 @@
+<!--
+  Presents owner-supplied RunnableCatalogRun rows. No store, fetch, or watch.
+  Parent links are the row's parentRunId. This list does not branch on runnable type or id.
+-->
+<script lang="ts">
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import { Progress } from '@vibesdotdev/kit/components/ui/progress';
+	import { Badge } from '@vibesdotdev/kit/components/ui/badge';
+	import type { RunnableCatalogRun } from '../../../schemas/runs.js';
+	import { isActiveRunStatus } from '../../lib/status.js';
+	import RunStatusBadge from '../RunStatusBadge.svelte';
+	import RunOutcomeBadge from '../RunOutcomeBadge.svelte';
+	import RunActivity from '../RunActivity.svelte';
+	import RunContext from '../RunContext.svelte';
+	import { formatDuration, formatRunTime, outcomeReason, shortRunId, runTitle } from '../../lib/run-presentation.js';
+
+	interface Props {
+		runs: RunnableCatalogRun[];
+		selected?: string | null;
+		onselect: (runId: string) => void;
+		/** Hide a row whose parent is also in `runs`. */
+		rootsOnly?: boolean;
+		/** Group by a value the owner reads off the record. */
+		groupBy?: (run: RunnableCatalogRun) => string;
+	}
+
+	let {
+		runs,
+		selected = null,
+		onselect,
+		rootsOnly = false,
+		groupBy,
+	}: Props = $props();
+
+	function uniqueRuns(records: RunnableCatalogRun[]): RunnableCatalogRun[] {
+		const seen = new Set<string>();
+		const unique: RunnableCatalogRun[] = [];
+		for (const run of records) {
+			if (seen.has(run.id)) continue;
+			seen.add(run.id);
+			unique.push(run);
+		}
+		return unique;
+	}
+
+	function compareRuns(left: RunnableCatalogRun, right: RunnableCatalogRun): number {
+		const active = Number(isActiveRunStatus(right.status)) - Number(isActiveRunStatus(left.status));
+		if (active !== 0) return active;
+		return right.startedAt - left.startedAt || left.id.localeCompare(right.id);
+	}
+
+	function visibleRuns(records: RunnableCatalogRun[], onlyRoots: boolean): RunnableCatalogRun[] {
+		const unique = uniqueRuns(records);
+		const ids = new Set(unique.map((run) => run.id));
+		const visible = onlyRoots
+			? unique.filter((run) => !run.parentRunId || run.parentRunId === run.id || !ids.has(run.parentRunId))
+			: unique;
+		return [...visible].sort(compareRuns);
+	}
+
+	function countChildren(records: RunnableCatalogRun[]): Map<string, number> {
+		const counts = new Map<string, number>();
+		for (const run of uniqueRuns(records)) {
+			const parent = run.parentRunId;
+			if (!parent || parent === run.id) continue;
+			counts.set(parent, (counts.get(parent) ?? 0) + 1);
+		}
+		return counts;
+	}
+
+	function groupRows(
+		records: RunnableCatalogRun[],
+		by: ((run: RunnableCatalogRun) => string) | undefined,
+	): Array<{ key: string; runs: RunnableCatalogRun[] }> {
+		if (!by) return [{ key: '', runs: records }];
+		const groups: Array<{ key: string; runs: RunnableCatalogRun[] }> = [];
+		const index = new Map<string, RunnableCatalogRun[]>();
+		for (const run of records) {
+			const key = by(run);
+			let bucket = index.get(key);
+			if (!bucket) {
+				bucket = [];
+				index.set(key, bucket);
+				groups.push({ key, runs: bucket });
+			}
+			bucket.push(run);
+		}
+		return groups;
+	}
+
+	const childCount = $derived.by(() => countChildren(runs));
+	const groups = $derived.by(() => groupRows(visibleRuns(runs, rootsOnly), groupBy));
+	const ordered = $derived(groups.flatMap((group) => group.runs));
+
+	let listEl: HTMLDivElement | undefined = $state();
+
+	function fraction(value: number): number {
+		if (!Number.isFinite(value)) return 0;
+		if (value < 0) return 0;
+		if (value > 1) return 1;
+		return value;
+	}
+
+	function focusRun(id: string) {
+		const selector = `[role="option"][data-run-id="${CSS.escape(id)}"]`;
+		listEl?.querySelector<HTMLElement>(selector)?.focus();
+	}
+
+	function move(index: number) {
+		const run = ordered[Math.max(0, Math.min(ordered.length - 1, index))];
+		if (!run) return;
+		onselect(run.id);
+		focusRun(run.id);
+	}
+
+	function onArrow(event: KeyboardEvent, id: string) {
+		const index = ordered.findIndex((run) => run.id === id);
+		if (index < 0) return;
+		if (event.key === 'ArrowDown') move(index + 1);
+		else if (event.key === 'ArrowUp') move(index - 1);
+		else if (event.key === 'Home') move(0);
+		else if (event.key === 'End') move(ordered.length - 1);
+		else return;
+		event.preventDefault();
+	}
+
+	function tabIndex(id: string): 0 | -1 {
+		const current = selected && ordered.some((run) => run.id === selected) ? selected : ordered[0]?.id;
+		return id === current ? 0 : -1;
+	}
+</script>
+
+{#snippet options(items: RunnableCatalogRun[])}
+	{#each items as run (run.id)}
+		<Button
+			type="button"
+			variant="ghost"
+			class="grid h-auto w-full min-w-0 items-stretch justify-stretch gap-1 whitespace-normal rounded-md border border-transparent px-3 py-2.5 text-left aria-selected:border-border aria-selected:bg-accent"
+			role="option"
+			data-run-id={run.id}
+			aria-selected={run.id === selected}
+			tabindex={tabIndex(run.id)}
+			onclick={() => onselect(run.id)}
+			onkeydown={(event) => onArrow(event, run.id)}
+		>
+			<span class="flex min-w-0 items-start justify-between gap-2">
+				<span class="min-w-0 break-words text-sm font-medium text-foreground">{runTitle(run)}</span>
+				{#if run.outcome}<RunOutcomeBadge {run} />{:else}<RunStatusBadge status={run.status} />{/if}
+			</span>
+			<div><Badge variant="secondary">{run.context?.kindLabel ?? run.runnableType}</Badge></div>
+			<RunContext {run} compact />
+			<span class="flex min-w-0 flex-wrap gap-x-3 gap-y-1 text-xs font-normal text-muted-foreground"><time datetime={new Date(run.startedAt).toISOString()}>{formatRunTime(run.startedAt)}</time>{#if run.endedAt != null}<span>{formatDuration(run.endedAt - run.startedAt)}</span>{/if}{#if run.outcome}<span>{run.status === 'completed' ? 'Execution finished' : run.status}</span>{/if}</span>
+			<RunActivity run={run} compact latest />
+			{#if outcomeReason(run)}
+				<span class="line-clamp-2 text-xs font-normal text-muted-foreground" title={outcomeReason(run)}>{outcomeReason(run)}</span>
+			{/if}
+			<span class="flex min-w-0 flex-wrap gap-x-3 text-xs font-normal text-muted-foreground"><code title={run.id}>{shortRunId(run.id)}</code>{#if childCount.get(run.id)}<span>{childCount.get(run.id)} {childCount.get(run.id) === 1 ? 'child' : 'children'}</span>{/if}{#if run.hostId}<span class="truncate" title={run.hostId}>{run.hostId}</span>{/if}</span>
+			{#if run.progress !== undefined && isActiveRunStatus(run.status)}
+			<Progress
+				class="mt-1 h-0.5"
+				max={1}
+				value={fraction(run.progress)}
+				aria-label={`Progress ${run.progress} of 1`}
+			/>
+			{/if}
+			{#if run.parentRunId && run.parentRunId !== run.id}
+				<span class="truncate text-xs font-normal text-muted-foreground" title={`Parent ${run.parentRunId}`}>↳ {shortRunId(run.parentRunId)}</span>
+			{/if}
+		</Button>
+	{/each}
+{/snippet}
+
+<div class="flex flex-col gap-1" bind:this={listEl}>
+	{#if ordered.length === 0}
+		<p class="px-4 py-8 text-center text-sm text-muted-foreground">No recorded runs in this delivery.</p>
+	{:else}
+		<div role="listbox" aria-label="Runs">
+			{#each groups as group (group.key)}
+				{#if group.key}
+					<div role="group" aria-label={group.key}>
+						<div class="px-3 pb-1 pt-4 text-xs font-medium text-muted-foreground" aria-hidden="true">{group.key}</div>
+						{@render options(group.runs)}
+					</div>
+				{:else}
+					{@render options(group.runs)}
+				{/if}
+			{/each}
+		</div>
+	{/if}
+</div>

package/dist/svelte/components/records/RunList.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { RunnableCatalogRun } from '../../../schemas/runs.ts';
+interface Props {
+    runs: RunnableCatalogRun[];
+    selected?: string | null;
+    onselect: (runId: string) => void;
+    /** Hide a row whose parent is also in `runs`. */
+    rootsOnly?: boolean;
+    /** Group by a value the owner reads off the record. */
+    groupBy?: (run: RunnableCatalogRun) => string;
+}
+declare const RunList: import("svelte").Component<Props, {}, "">;
+type RunList = ReturnType<typeof RunList>;
+export default RunList;
+//# sourceMappingURL=RunList.svelte.d.ts.map

package/dist/svelte/components/records/RunList.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunList.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/records/RunList.svelte.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AASlE,UAAU,KAAK;IACd,IAAI,EAAE,kBAAkB,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,iDAAiD;IACjD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,MAAM,CAAC;CAC9C;AAuKF,QAAA,MAAM,OAAO,2CAAwC,CAAC;AACtD,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAC1C,eAAe,OAAO,CAAC"}

package/dist/svelte/components/records/RunTree.svelte

@@ -0,0 +1,186 @@
+<!--
+  Presents owner-supplied RunnableCatalogRun rows as a parentRunId tree. No store, fetch, or watch.
+  A run already on the parent chain is not expanded again, so a cycle cannot recurse.
+-->
+<script lang="ts">
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import * as Pagination from '@vibesdotdev/kit/components/ui/pagination';
+	import { Progress } from '@vibesdotdev/kit/components/ui/progress';
+	import { Icon } from '@vibesdotdev/kit/components/icon';
+	import { Badge } from '@vibesdotdev/kit/components/ui/badge';
+	import { buildForest, runAncestors, runTreeReports, type RunTreeNode } from './tree-projection.js';
+	import type { RunTreeProps as Props } from '../../../schemas/projection.js';
+	import { fraction } from './tree-projection.js';
+	import { runTreeKeyIntent } from './tree-navigation.js';
+	import RunStatusBadge from '../RunStatusBadge.svelte';
+	import RunOutcomeBadge from '../RunOutcomeBadge.svelte';
+	import RunActivity from '../RunActivity.svelte';
+	import RunContext from '../RunContext.svelte';
+	import { isActiveRunStatus } from '../../lib/status.js';
+	import { outcomeReason, formatRunTime, runTreeTitle } from '../../lib/run-presentation.js';
+
+	let { runs, selected = null, onselect, rootId, matchedIds }: Props = $props();
+
+	const branchesPerPage = 40;
+	let requestedPage = $state(1);
+	let openOverride = $state<Record<string, boolean>>({});
+	let treeEl: HTMLUListElement | undefined = $state();
+
+	const selectedAncestors = $derived(runAncestors(runs, selected ? [selected] : []));
+	const matchAncestors = $derived(runAncestors(runs, matchedIds ?? []));
+	const forest = $derived(buildForest(runs, rootId));
+	const reports = $derived(runTreeReports(forest));
+	const pageCount = $derived(Math.max(1, Math.ceil(forest.length / branchesPerPage)));
+	const currentPage = $derived(Math.min(requestedPage, pageCount));
+	const pageStart = $derived((currentPage - 1) * branchesPerPage);
+	const pageForest = $derived(forest.slice(pageStart, pageStart + branchesPerPage));
+	const rootPositions = $derived(new Map(forest.map((node, index) => [node.run.id, index + 1])));
+	const selectedRootIndex = $derived(forest.findIndex(node => node.run.id === selected || selectedAncestors.has(node.run.id)));
+	const selectedPage = $derived(selectedRootIndex < 0 ? null : Math.floor(selectedRootIndex / branchesPerPage) + 1);
+	const byId = $derived(new Map(runs.map(run => [run.id, run])));
+	const visible = $derived.by(() => {
+		const flat: RunTreeNode[] = [];
+		function walk(nodes: RunTreeNode[]) {
+			for (const node of nodes) {
+				flat.push(node);
+				if (node.children.length > 0 && isOpen(node)) walk(node.children);
+			}
+		}
+		walk(pageForest);
+		return flat;
+	});
+
+	const visibleIds = $derived(new Set(visible.map(node => node.run.id)));
+	const tabbableId = $derived(selected && visibleIds.has(selected) ? selected : visible[0]?.run.id);
+
+	function changePage(next: number) {
+		requestedPage = next;
+		treeEl?.scrollIntoView({ block: 'start' });
+	}
+
+	function revealSelection() {
+		if (selectedPage !== null) changePage(selectedPage);
+	}
+
+	function isOpen(node: RunTreeNode): boolean {
+		if (selectedAncestors.has(node.run.id)) return true;
+		const override = openOverride[node.run.id];
+		if (override !== undefined) return override;
+		return node.active || matchAncestors.has(node.run.id) || Boolean(rootId && node.depth === 0);
+	}
+
+	function setOpen(id: string, open: boolean) {
+		if (!open && selectedAncestors.has(id)) onselect(id);
+		openOverride = { ...openOverride, [id]: open };
+	}
+
+	function focusRun(id: string) {
+		const selector = `[role="treeitem"][data-run-id="${CSS.escape(id)}"]`;
+		const element = treeEl?.querySelector<HTMLElement>(selector);
+		element?.focus({ preventScroll: true });
+		element?.scrollIntoView({ block: 'nearest' });
+	}
+
+    function onItemKey(event: KeyboardEvent, node: RunTreeNode) {
+        const intent = runTreeKeyIntent(event.key, node, visible, isOpen(node));
+        if (intent === null) return;
+        if (intent.kind === 'open') setOpen(intent.id, intent.open);
+        else {
+            onselect(intent.id);
+            if (intent.focus) focusRun(intent.id);
+        }
+        event.preventDefault();
+    }
+
+
+</script>
+
+{#snippet branch(nodes: RunTreeNode[])}
+	{#each nodes as node (node.run.id)}
+		<li
+			class="scroll-mt-16 rounded-md outline-none focus-visible:ring-2 focus-visible:ring-ring"
+			role="treeitem"
+			data-run-id={node.run.id}
+			aria-level={node.depth + 1}
+			aria-posinset={node.depth === 0 ? rootPositions.get(node.run.id) : undefined}
+			aria-setsize={node.depth === 0 ? forest.length : undefined}
+			aria-selected={node.run.id === selected}
+			aria-expanded={node.children.length > 0 ? isOpen(node) : undefined}
+			tabindex={node.run.id === tabbableId ? 0 : -1}
+			onclick={(event) => {
+				event.stopPropagation();
+				onselect(node.run.id);
+			}}
+			onkeydown={(event) => {
+				event.stopPropagation();
+				onItemKey(event, node);
+			}}
+		>
+			<div class={['flex min-w-0 items-start gap-2 rounded-md px-2 py-2.5 hover:bg-accent/60', node.run.id === selected && 'bg-accent']} role="none" style:padding-inline-start={`${0.5 + Math.min(node.depth, 12) * 1}rem`}>
+				{#if node.children.length > 0}
+					<Button
+						type="button"
+						variant="ghost" size="icon" class="mt-0.5 size-5 shrink-0"
+						tabindex={-1}
+						aria-label={isOpen(node) ? `Collapse ${runTreeTitle(node.run, byId.get(node.parentId ?? ''))}` : `Expand ${runTreeTitle(node.run, byId.get(node.parentId ?? ''))}`}
+						onclick={(event) => {
+							event.stopPropagation();
+							setOpen(node.run.id, !isOpen(node));
+							focusRun(node.run.id);
+						}}
+						onkeydown={(event) => event.stopPropagation()}
+					>
+						<Icon icon={isOpen(node) ? 'lucide:chevron-down' : 'lucide:chevron-right'} class="size-3.5" />
+					</Button>
+				{:else}
+					<span class="mt-0.5 size-5 shrink-0" aria-hidden="true"></span>
+				{/if}
+				<Icon icon={node.children.length ? (isOpen(node) ? 'lucide:folder-open' : 'lucide:folder') : 'lucide:file-text'} class="mt-1 size-4 shrink-0 text-muted-foreground" />
+				<div class="grid min-w-0 flex-1 gap-1">
+					<span title={runTreeTitle(node.run, byId.get(node.parentId ?? ''))} class={['line-clamp-2 break-words text-sm font-medium leading-snug', matchedIds && !matchedIds.has(node.run.id) && 'text-muted-foreground']}>{runTreeTitle(node.run, byId.get(node.parentId ?? ''))}</span>
+					<RunContext run={node.run} parent={byId.get(node.parentId ?? '')} compact />
+					<span class="flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground"><Badge variant="secondary" class="text-xs">{node.run.context?.kindLabel ?? node.run.runnableType}</Badge><time datetime={new Date(node.run.startedAt).toISOString()} title={node.run.id}>{formatRunTime(node.run.startedAt)}</time>{#if node.children.length}<span>{node.children.length} child {node.children.length === 1 ? 'run' : 'runs'}</span>{/if}</span>
+					<RunActivity run={node.run} compact latest related={reports.get(node.run.id)} {onselect} />
+			{#if outcomeReason(node.run)}<span class="line-clamp-2 break-words text-xs leading-relaxed text-muted-foreground" title={outcomeReason(node.run)}>{outcomeReason(node.run)}</span>{/if}
+				</div>
+				{#if node.run.outcome}<RunOutcomeBadge run={node.run} />{:else}<RunStatusBadge status={node.run.status} />{/if}
+				{#if node.run.progress !== undefined && isActiveRunStatus(node.run.status)}
+				<Progress
+					class="mt-2 h-1 w-12 shrink-0"
+					max={1}
+					value={fraction(node.run.progress)}
+					aria-label={`Progress ${node.run.progress} of 1`}
+				/>
+				{/if}
+			</div>
+			{#if node.children.length > 0 && isOpen(node)}
+				<ul role="group" class="m-0 list-none p-0">
+					{@render branch(node.children)}
+				</ul>
+			{/if}
+		</li>
+	{/each}
+{/snippet}
+
+{#if forest.length === 0}
+	<p class="p-8 text-center text-sm text-muted-foreground">No runs</p>
+{:else}
+	{#if pageCount > 1}
+		<div class="sticky top-0 z-10 flex flex-wrap items-center justify-between gap-2 border-b border-border bg-background px-2 py-2">
+			<span class="text-xs tabular-nums text-muted-foreground">Branches {pageStart + 1}–{Math.min(pageStart + branchesPerPage, forest.length)} of {forest.length}</span>
+			<Pagination.Root count={forest.length} perPage={branchesPerPage} page={currentPage} onPageChange={changePage} aria-label="Run branch pages" class="m-0 w-auto">
+				<Pagination.Content>
+					<Pagination.Item><Pagination.PrevButton class="h-8" /></Pagination.Item>
+					<Pagination.Item><span class="px-1 text-xs tabular-nums text-muted-foreground">{currentPage} / {pageCount}</span></Pagination.Item>
+					<Pagination.Item><Pagination.NextButton class="h-8" /></Pagination.Item>
+				</Pagination.Content>
+			</Pagination.Root>
+			{#if selectedPage !== null && selectedPage !== currentPage}
+				<Button variant="ghost" size="sm" onclick={revealSelection}>Show selected run</Button>
+			{/if}
+		</div>
+	{/if}
+	<ul class="m-0 scroll-mt-16 list-none p-0" role="tree" aria-label="Runs" bind:this={treeEl}>
+		{@render branch(pageForest)}
+	</ul>
+{/if}

package/dist/svelte/components/records/RunTree.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { RunTreeProps as Props } from '../../../schemas/projection.ts';
+declare const RunTree: import("svelte").Component<Props, {}, "">;
+type RunTree = ReturnType<typeof RunTree>;
+export default RunTree;
+//# sourceMappingURL=RunTree.svelte.d.ts.map

package/dist/svelte/components/records/RunTree.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunTree.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/records/RunTree.svelte.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,IAAI,KAAK,EAAE,MAAM,gCAAgC,CAAC;AA4K5E,QAAA,MAAM,OAAO,2CAAwC,CAAC;AACtD,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAC1C,eAAe,OAAO,CAAC"}

package/dist/svelte/components/records/tree-navigation.d.ts

@@ -0,0 +1,3 @@
+import type { RunTreeNode, RunTreeKeyIntent } from '../../../schemas/projection.ts';
+export declare function runTreeKeyIntent(key: string, node: RunTreeNode, visible: RunTreeNode[], open: boolean): RunTreeKeyIntent | null;
+//# sourceMappingURL=tree-navigation.d.ts.map

package/dist/svelte/components/records/tree-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-navigation.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/records/tree-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACpF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CA4B/H"}

package/dist/svelte/components/records/tree-navigation.js

@@ -0,0 +1,29 @@
+export function runTreeKeyIntent(key, node, visible, open) {
+    const index = visible.findIndex(item => item.run.id === node.run.id);
+    if (index < 0)
+        return null;
+    const move = (target) => {
+        const next = visible[Math.max(0, Math.min(visible.length - 1, target))];
+        return next ? { kind: 'select', id: next.run.id, focus: true } : null;
+    };
+    if (key === 'ArrowDown')
+        return move(index + 1);
+    if (key === 'ArrowUp')
+        return move(index - 1);
+    if (key === 'Home')
+        return move(0);
+    if (key === 'End')
+        return move(visible.length - 1);
+    if (key === 'ArrowRight' && node.children.length > 0)
+        return open ? move(index + 1) : { kind: 'open', id: node.run.id, open: true };
+    if (key === 'ArrowLeft') {
+        if (node.children.length > 0 && open)
+            return { kind: 'open', id: node.run.id, open: false };
+        if (node.parentId)
+            return { kind: 'select', id: node.parentId, focus: true };
+        return null;
+    }
+    if (key === 'Enter' || key === ' ')
+        return { kind: 'select', id: node.run.id, focus: false };
+    return null;
+}

package/dist/svelte/components/records/tree-projection.d.ts

@@ -0,0 +1,16 @@
+import type { RunnableCatalogRun } from '../../../schemas/runs.ts';
+import type { RunTreeNode, RunTreeReport } from '../../../schemas/projection.ts';
+export type { RunTreeNode, RunTreeReport } from '../../../schemas/projection.ts';
+/** Keep recorded ancestors when a child matches, without inventing missing parents. */
+export declare function withRunAncestors(runs: readonly RunnableCatalogRun[], matches: readonly RunnableCatalogRun[]): RunnableCatalogRun[];
+export declare function runAncestors(runs: readonly RunnableCatalogRun[], ids: Iterable<string>): Set<string>;
+/** One node per record, including orphans and cycles; active branches come first. */
+export declare function buildForest(records: readonly RunnableCatalogRun[], rootId?: string): RunTreeNode[];
+/** One postorder pass; descendant facts retain their source and never become parent activity. */
+export declare function runTreeReports(forest: readonly RunTreeNode[]): Map<string, RunTreeReport>;
+export declare function fraction(value: number): number;
+export declare function outcomeText(run: RunnableCatalogRun): string | null;
+export declare function isRunTreeOpen(node: RunTreeNode, overrides: Record<string, boolean>): boolean;
+export declare function visibleRunTree(forest: RunTreeNode[], overrides: Record<string, boolean>): RunTreeNode[];
+export declare function runTreeTabIndex(id: string, selected: string | null, visible: RunTreeNode[]): 0 | -1;
+//# sourceMappingURL=tree-projection.d.ts.map

package/dist/svelte/components/records/tree-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-projection.d.ts","sourceRoot":"","sources":["../../../../src/svelte/components/records/tree-projection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAInE,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACjF,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEjF,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,EAAE,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,kBAAkB,EAAE,CAWlI;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAapG;AAED,qFAAqF;AACrF,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CA6BlG;AAID,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAoBzF;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ9C;AACD,wBAAgB,WAAW,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CASlE;AACD,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAK5F;AACD,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,WAAW,EAAE,CASvG;AACD,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAGnG"}

package/dist/svelte/components/records/tree-projection.js

@@ -0,0 +1,134 @@
+import { isActiveRunStatus } from "../../lib/status.js";
+import { runTitle } from "../../lib/run-presentation.js";
+/** Keep recorded ancestors when a child matches, without inventing missing parents. */
+export function withRunAncestors(runs, matches) {
+    const byId = new Map(runs.map(run => [run.id, run]));
+    const included = new Set();
+    for (const match of matches) {
+        let run = match;
+        while (run && !included.has(run.id)) {
+            included.add(run.id);
+            run = run.parentRunId ? byId.get(run.parentRunId) : undefined;
+        }
+    }
+    return [...byId.values()].filter(run => included.has(run.id));
+}
+export function runAncestors(runs, ids) {
+    const byId = new Map(runs.map(run => [run.id, run]));
+    const ancestors = new Set();
+    for (const id of ids) {
+        const visited = new Set([id]);
+        let parent = byId.get(id)?.parentRunId;
+        while (parent && byId.has(parent) && !visited.has(parent)) {
+            visited.add(parent);
+            ancestors.add(parent);
+            parent = byId.get(parent)?.parentRunId;
+        }
+    }
+    return ancestors;
+}
+/** One node per record, including orphans and cycles; active branches come first. */
+export function buildForest(records, rootId) {
+    const byId = new Map();
+    for (const run of records)
+        if (!byId.has(run.id))
+            byId.set(run.id, run);
+    const childrenOf = new Map();
+    for (const run of byId.values()) {
+        const parent = run.parentRunId;
+        if (!parent || parent === run.id || !byId.has(parent))
+            continue;
+        const children = childrenOf.get(parent) ?? [];
+        children.push(run);
+        childrenOf.set(parent, children);
+    }
+    for (const children of childrenOf.values())
+        children.sort((left, right) => left.startedAt - right.startedAt || left.id.localeCompare(right.id));
+    const placed = new Set();
+    function walk(run, depth, parentId) {
+        placed.add(run.id);
+        const children = [];
+        for (const child of childrenOf.get(run.id) ?? []) {
+            if (!placed.has(child.id))
+                children.push(walk(child, depth + 1, run.id));
+        }
+        return { run, depth, parentId, children, active: isActiveRunStatus(run.status) || children.some(child => child.active) };
+    }
+    if (rootId) {
+        const root = byId.get(rootId);
+        return root ? [walk(root, 0, null)] : [];
+    }
+    const roots = [...byId.values()].filter(run => !run.parentRunId || run.parentRunId === run.id || !byId.has(run.parentRunId));
+    const nodes = roots.map(run => walk(run, 0, null));
+    for (const run of byId.values())
+        if (!placed.has(run.id))
+            nodes.push(walk(run, 0, null));
+    return nodes.sort((left, right) => Number(right.active) - Number(left.active) || right.run.startedAt - left.run.startedAt || left.run.id.localeCompare(right.run.id));
+}
+/** One postorder pass; descendant facts retain their source and never become parent activity. */
+export function runTreeReports(forest) {
+    const reports = new Map();
+    function walk(node) {
+        const run = node.run;
+        let latest = { run, ts: run.startedAt, label: 'Run recorded', message: runTitle(run) };
+        if (run.endedAt != null && ['completed', 'error', 'stopped'].includes(run.status)) {
+            const label = run.status === 'error' ? 'Execution failed' : run.status === 'stopped' ? 'Execution stopped' : 'Execution finished';
+            latest = { run, ts: run.endedAt, label, message: runTitle(run) };
+        }
+        if (run.activity && run.activity.ts >= latest.ts)
+            latest = { run, ...run.activity, label: 'Last report' };
+        if (run.observation && run.observation.ts >= latest.ts)
+            latest = { run, ...run.observation, label: run.observation.label ?? 'Last observed' };
+        for (const child of node.children) {
+            const report = walk(child);
+            if (report.ts > latest.ts)
+                latest = report;
+        }
+        reports.set(run.id, latest);
+        return latest;
+    }
+    for (const node of forest)
+        walk(node);
+    return reports;
+}
+export function fraction(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+export function outcomeText(run) {
+    const outcome = run.outcome;
+    if (!outcome)
+        return null;
+    if (outcome.status === 'disputed')
+        return outcome.why ? `disputed: ${outcome.why}` : 'disputed';
+    if (outcome.status === 'done')
+        return 'done';
+    return outcome.reason ? `${outcome.status}: ${outcome.reason}` : outcome.status;
+}
+export function isRunTreeOpen(node, overrides) {
+    const override = overrides[node.run.id];
+    if (override !== undefined)
+        return override;
+    return node.depth === 0 && node.children.length > 0;
+}
+export function visibleRunTree(forest, overrides) {
+    const flat = [];
+    function walk(nodes) {
+        for (const node of nodes) {
+            flat.push(node);
+            if (node.children.length > 0 && isRunTreeOpen(node, overrides))
+                walk(node.children);
+        }
+    }
+    walk(forest);
+    return flat;
+}
+export function runTreeTabIndex(id, selected, visible) {
+    const current = selected && visible.some(node => node.run.id === selected) ? selected : visible[0]?.run.id;
+    return id === current ? 0 : -1;
+}

package/dist/svelte/index.d.ts

@@ -0,0 +1,27 @@
+export type { ArtifactDownloadHref, MetricCardProps, RunnableArtifactEntry, RunnableLogEntry, RunnableMetricSeriesPoint, RunnableRunStatus, RunnableTypeSummary, } from './types.ts';
+export { getRunStatusDisplay, getRunnableTypeAccent, isActiveRunStatus, normalizeRunStatus, } from './lib/status.ts';
+export type { RunStatusDisplay, RunStatusTone, } from './lib/status.ts';
+export { default as RunStatusBadge } from './components/RunStatusBadge.svelte';
+export { default as MetricCard } from './components/MetricCard.svelte';
+export { default as LogViewer } from './components/LogViewer.svelte';
+export { default as ArtifactList } from './components/ArtifactList.svelte';
+export { default as TypePicker } from './components/TypePicker.svelte';
+export { default as RunList } from './components/records/RunList.svelte';
+export { default as RunTree } from './components/records/RunTree.svelte';
+export { RunsStore } from './runs.store.svelte.ts';
+export type { RunsSource, RunsConnection, RunsOpenOptions, RunRow } from './runs.store.svelte.ts';
+export { default as RunEvidence } from './components/RunEvidence.svelte';
+export { default as RunDetail } from './components/records/RunDetail.svelte';
+export { default as RunPanels } from './components/RunPanels.svelte';
+export { default as RunsView } from './components/RunsView.svelte';
+export { default as FleetRuns } from './components/FleetRuns.svelte';
+export { default as RunActivity } from './components/RunActivity.svelte';
+export { default as RunContext } from './components/RunContext.svelte';
+export { default as RunObservation } from './components/RunObservation.svelte';
+export { default as RunIssues } from './components/RunIssues.svelte';
+export { default as RunSummary } from './components/RunSummary.svelte';
+export { default as RunComparison } from './components/RunComparison.svelte';
+export type { RunEvidenceTarget } from './lib/run-investigation.ts';
+export { runnableQueryForm, RunnableQueryFormSchema } from './query-form.ts';
+export { default as ArtifactPreview } from './components/ArtifactPreview.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/svelte/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACX,oBAAoB,EACpB,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACX,gBAAgB,EAChB,aAAa,GACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAErE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,YAAY,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE7E,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC"}