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

package/dist/svelte/runs.store.svelte.d.ts

@@ -0,0 +1,427 @@
+import type { RunnableVisualizationQuery } from "../client/client.ts";
+import type { RunnableControlInput } from "../schemas/contracts/index.ts";
+import type { RunnableReadQuery, RunnableSnapshot } from "../schemas/runs.ts";
+import { RunsData } from "./runs/data.svelte.ts";
+import type { RunsSource, RunsOpenOptions, RunRow } from "../schemas/contracts/watch.ts";
+export type { RunsSource, RunsConnection, RunsOpenOptions, RunRow } from '../schemas/contracts/watch.ts';
+export declare class RunsStore {
+    #private;
+    readonly projection: 'catalog' | 'records' | 'snapshot';
+    constructor(source: RunsSource, query?: RunnableReadQuery, projection?: 'catalog' | 'records' | 'snapshot');
+    get source(): RunsSource;
+    get catalogSnapshot(): RunsData['catalogSnapshot'];
+    get lastReceivedAt(): number | null;
+    get detailLoading(): boolean;
+    listRows: {
+        metrics: {
+            kind: "metric";
+            key: string;
+            value: number;
+            ts: number;
+            dimensions?: import("@vibesdotdev/kernel/schemas/json").JsonObject | undefined;
+        }[];
+        logs: {
+            kind: "log";
+            level: "error" | "info" | "warn" | "debug";
+            message: string;
+            ts: number;
+            data?: import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined;
+        }[];
+        artifacts: {
+            kind: "artifact";
+            id: string;
+            artifactKind: string;
+            name: string;
+            mimeType: string;
+            ts: number;
+            version?: string | undefined;
+            sequenceNo?: number | undefined;
+            hash?: string | undefined;
+            size?: number | undefined;
+            path?: string | undefined;
+            data?: string | undefined;
+            metadata?: import("@vibesdotdev/kernel/schemas/json").JsonObject | undefined;
+        }[];
+        run: {
+            id: string;
+            status: string;
+            runnableType: string;
+            startedAt: number;
+            config: import("@vibesdotdev/kernel/schemas/json").JsonObject;
+            metadata: import("@vibesdotdev/kernel/schemas/json").JsonObject;
+            runnableId: string;
+            name?: string | undefined;
+            progress?: number | undefined;
+            endedAt?: number | null | undefined;
+            hostId?: string | undefined;
+            scope?: string | undefined;
+            inputDigest?: string | undefined;
+            parentRunId?: string | undefined;
+            outcome?: {
+                status: "done";
+                value: import("@vibesdotdev/kernel/bootstrap").JsonValue;
+            } | {
+                status: "not-done";
+                reason: string;
+                value?: import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined;
+                failure?: {
+                    code: string;
+                    message: string;
+                    name?: string | undefined;
+                    reason?: string | undefined;
+                    retryable?: boolean | undefined;
+                    recoveryHint?: string | undefined;
+                    details?: import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined;
+                } | undefined;
+            } | {
+                status: "disputed";
+                why: string;
+                claims: {
+                    id: string;
+                    statement: string;
+                    quote: {
+                        link: {
+                            kind: string;
+                            id: string;
+                            source: string;
+                            role: string;
+                        };
+                        scope: string;
+                        revision: {
+                            scheme: string;
+                            value: string;
+                        };
+                        text: string;
+                        anchor?: {
+                            kind: "code";
+                            path: string;
+                            startLine: number;
+                            endLine: number;
+                        } | {
+                            kind: "region";
+                            start: number;
+                            end: number;
+                        } | {
+                            kind: "fragment";
+                            id: string;
+                        } | {
+                            kind: "heading";
+                            slug: string;
+                        } | undefined;
+                        freshness?: {
+                            modifiedAt?: string | undefined;
+                            stale?: boolean | undefined;
+                        } | undefined;
+                    };
+                    via: string[];
+                    stale?: boolean | undefined;
+                }[];
+            } | {
+                status: "skipped";
+                reason: string;
+                cause: {
+                    kind: "cancelled";
+                    provenance: import("@vibesdotdev/kernel/bootstrap").JsonValue;
+                } | {
+                    kind: "explicit";
+                } | {
+                    kind: "dependency";
+                    blockedBy: string[];
+                };
+            } | undefined;
+            resultMode?: "void" | "value" | "outcome" | undefined;
+            ref?: {
+                jobId?: string | undefined;
+                aiCallRunId?: string | undefined;
+                ciRunId?: string | undefined;
+                executionReference?: string | undefined;
+            } | undefined;
+            rankReason?: {
+                named: true;
+            } | {
+                coldStart: true;
+                cost: number;
+            } | undefined;
+            approval?: "approved" | "assumed" | undefined;
+            activity?: {
+                message: string;
+                ts: number;
+            } | undefined;
+            context?: {
+                kindLabel?: string | undefined;
+                title?: string | undefined;
+                subject?: string | undefined;
+                target?: string | undefined;
+                phase?: string | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        };
+        children: {
+            id: string;
+            status: string;
+            runnableType: string;
+            startedAt: number;
+            config: import("@vibesdotdev/kernel/schemas/json").JsonObject;
+            metadata: import("@vibesdotdev/kernel/schemas/json").JsonObject;
+            runnableId: string;
+            name?: string | undefined;
+            progress?: number | undefined;
+            endedAt?: number | null | undefined;
+            hostId?: string | undefined;
+            scope?: string | undefined;
+            inputDigest?: string | undefined;
+            parentRunId?: string | undefined;
+            outcome?: {
+                status: "done";
+                value: import("@vibesdotdev/kernel/bootstrap").JsonValue;
+            } | {
+                status: "not-done";
+                reason: string;
+                value?: import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined;
+                failure?: {
+                    code: string;
+                    message: string;
+                    name?: string | undefined;
+                    reason?: string | undefined;
+                    retryable?: boolean | undefined;
+                    recoveryHint?: string | undefined;
+                    details?: import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined;
+                } | undefined;
+            } | {
+                status: "disputed";
+                why: string;
+                claims: {
+                    id: string;
+                    statement: string;
+                    quote: {
+                        link: {
+                            kind: string;
+                            id: string;
+                            source: string;
+                            role: string;
+                        };
+                        scope: string;
+                        revision: {
+                            scheme: string;
+                            value: string;
+                        };
+                        text: string;
+                        anchor?: {
+                            kind: "code";
+                            path: string;
+                            startLine: number;
+                            endLine: number;
+                        } | {
+                            kind: "region";
+                            start: number;
+                            end: number;
+                        } | {
+                            kind: "fragment";
+                            id: string;
+                        } | {
+                            kind: "heading";
+                            slug: string;
+                        } | undefined;
+                        freshness?: {
+                            modifiedAt?: string | undefined;
+                            stale?: boolean | undefined;
+                        } | undefined;
+                    };
+                    via: string[];
+                    stale?: boolean | undefined;
+                }[];
+            } | {
+                status: "skipped";
+                reason: string;
+                cause: {
+                    kind: "cancelled";
+                    provenance: import("@vibesdotdev/kernel/bootstrap").JsonValue;
+                } | {
+                    kind: "explicit";
+                } | {
+                    kind: "dependency";
+                    blockedBy: string[];
+                };
+            } | undefined;
+            resultMode?: "void" | "value" | "outcome" | undefined;
+            ref?: {
+                jobId?: string | undefined;
+                aiCallRunId?: string | undefined;
+                ciRunId?: string | undefined;
+                executionReference?: string | undefined;
+            } | undefined;
+            rankReason?: {
+                named: true;
+            } | {
+                coldStart: true;
+                cost: number;
+            } | undefined;
+            approval?: "approved" | "assumed" | undefined;
+            activity?: {
+                message: string;
+                ts: number;
+            } | undefined;
+            context?: {
+                kindLabel?: string | undefined;
+                title?: string | undefined;
+                subject?: string | undefined;
+                target?: string | undefined;
+                phase?: string | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+        }[];
+        observation?: {
+            message: string;
+            ts: number;
+            logIndex: number;
+            label?: string | undefined;
+        } | undefined;
+    }[] | {
+        run: {
+            id: string;
+            status: string;
+            startedAt: number;
+            runnableId: string;
+            runnableType: string;
+            name?: string | undefined;
+            scope?: string | undefined;
+            context?: {
+                kindLabel?: string | undefined;
+                title?: string | undefined;
+                subject?: string | undefined;
+                target?: string | undefined;
+                phase?: string | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+            ref?: {
+                jobId?: string | undefined;
+                aiCallRunId?: string | undefined;
+                ciRunId?: string | undefined;
+                executionReference?: string | undefined;
+            } | undefined;
+            activity?: {
+                message: string;
+                ts: number;
+            } | undefined;
+            progress?: number | undefined;
+            endedAt?: number | null | undefined;
+            hostId?: string | undefined;
+            parentRunId?: string | undefined;
+            inputDigest?: string | undefined;
+            rankReason?: {
+                named: true;
+            } | {
+                coldStart: true;
+                cost: number;
+            } | undefined;
+            approval?: "approved" | "assumed" | undefined;
+            resultMode?: "void" | "value" | "outcome" | undefined;
+            outcome?: {
+                status: "done";
+            } | {
+                reason: string;
+                status: "not-done";
+            } | {
+                status: "disputed";
+                why: string;
+            } | {
+                reason: string;
+                status: "skipped";
+            } | undefined;
+            observation?: {
+                message: string;
+                ts: number;
+                logIndex: number;
+                label?: string | undefined;
+            } | undefined;
+        };
+        children: {
+            id: string;
+            status: string;
+            startedAt: number;
+            runnableId: string;
+            runnableType: string;
+            name?: string | undefined;
+            scope?: string | undefined;
+            context?: {
+                kindLabel?: string | undefined;
+                title?: string | undefined;
+                subject?: string | undefined;
+                target?: string | undefined;
+                phase?: string | undefined;
+                paths?: string[] | undefined;
+            } | undefined;
+            ref?: {
+                jobId?: string | undefined;
+                aiCallRunId?: string | undefined;
+                ciRunId?: string | undefined;
+                executionReference?: string | undefined;
+            } | undefined;
+            activity?: {
+                message: string;
+                ts: number;
+            } | undefined;
+            progress?: number | undefined;
+            endedAt?: number | null | undefined;
+            hostId?: string | undefined;
+            parentRunId?: string | undefined;
+            inputDigest?: string | undefined;
+            rankReason?: {
+                named: true;
+            } | {
+                coldStart: true;
+                cost: number;
+            } | undefined;
+            approval?: "approved" | "assumed" | undefined;
+            resultMode?: "void" | "value" | "outcome" | undefined;
+            outcome?: {
+                status: "done";
+            } | {
+                reason: string;
+                status: "not-done";
+            } | {
+                status: "disputed";
+                why: string;
+            } | {
+                reason: string;
+                status: "skipped";
+            } | undefined;
+            observation?: {
+                message: string;
+                ts: number;
+                logIndex: number;
+                label?: string | undefined;
+            } | undefined;
+        }[];
+    }[];
+    get query(): RunnableReadQuery;
+    get snapshot(): RunsData['snapshot'];
+    set snapshot(value: RunsData['snapshot']);
+    get connection(): RunsData['connection'];
+    set connection(value: RunsData['connection']);
+    get loading(): RunsData['loading'];
+    set loading(value: RunsData['loading']);
+    get error(): RunsData['error'];
+    set error(value: RunsData['error']);
+    get selectedId(): RunsData['selectedId'];
+    set selectedId(value: RunsData['selectedId']);
+    /** Owner revision, or null when no delivery has been accepted. */
+    revision: number | null;
+    /** Rows follow `snapshot.runs`. Children stay on each owner snapshot. */
+    rows: readonly RunRow[];
+    /**
+     * Full snapshot for `selectedId` when this list delivery still names it.
+     * Telemetry comes from that run's own watch, not from the list rows.
+     */
+    selected: RunnableSnapshot | null;
+    select(runId: string | null): Promise<void>;
+    open(options?: RunsOpenOptions): Promise<void>;
+    close(): Promise<void>;
+    dispose(): Promise<void>;
+    visualizations(query: RunnableVisualizationQuery): ReturnType<RunsSource['visualizations']>;
+    /** Current selected owner description; recorded values remain on the snapshot. */
+    describe(id: string): ReturnType<RunsSource['describe']>;
+    /** Delegates to the client. Does not write a local status or outcome. */
+    control(input: RunnableControlInput): ReturnType<RunsSource['control']>;
+}
+//# sourceMappingURL=runs.store.svelte.d.ts.map

package/dist/svelte/runs.store.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.store.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/runs.store.svelte.ts"],"names":[],"mappings":"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"}

package/dist/svelte/runs.store.svelte.js

@@ -0,0 +1,90 @@
+import { RunsData } from "./runs/data.svelte.js";
+import { admitQuery } from "./runs/query.js";
+import { openRunsWatch } from "./runs/opening.js";
+import { closeRunsWatch } from "./runs/shutdown.js";
+import { followSelectedRun } from "./runs/selection.js";
+export class RunsStore {
+    projection;
+    #data;
+    constructor(source, query = {}, projection = 'records') {
+        this.projection = projection;
+        this.#data = new RunsData(source, admitQuery(query), projection);
+    }
+    get source() { return this.#data.source; }
+    get catalogSnapshot() { return this.#data.catalogSnapshot; }
+    get lastReceivedAt() { return this.#data.lastReceivedAt; }
+    get detailLoading() { return this.#data.detailLoading; }
+    listRows = $derived(this.catalogSnapshot?.runs ?? this.snapshot?.runs ?? []);
+    get query() { return this.#data.query; }
+    get snapshot() { return this.#data.snapshot; }
+    set snapshot(value) { this.#data.snapshot = value; }
+    get connection() { return this.#data.connection; }
+    set connection(value) { this.#data.connection = value; }
+    get loading() { return this.#data.loading; }
+    set loading(value) { this.#data.loading = value; }
+    get error() { return this.#data.error; }
+    set error(value) { this.#data.error = value; }
+    get selectedId() { return this.#data.selectedId; }
+    set selectedId(value) { this.#data.selectedId = value; }
+    /** Owner revision, or null when no delivery has been accepted. */
+    revision = $derived(this.catalogSnapshot?.revision ?? this.snapshot?.revision ?? null);
+    /** Rows follow `snapshot.runs`. Children stay on each owner snapshot. */
+    rows = $derived.by(() => {
+        const delivered = this.snapshot;
+        if (delivered === null)
+            return [];
+        return delivered.runs.map((snapshot) => ({
+            id: snapshot.run.id,
+            run: snapshot.run,
+            snapshot,
+        }));
+    });
+    /**
+     * Full snapshot for `selectedId` when this list delivery still names it.
+     * Telemetry comes from that run's own watch, not from the list rows.
+     */
+    selected = $derived.by(() => {
+        const selectedId = this.selectedId;
+        const detail = this.#data.detail;
+        if (selectedId === null || detail === null || detail.run.id !== selectedId)
+            return null;
+        if (!this.listRows.some((snapshot) => snapshot.run.id === selectedId))
+            return null;
+        return detail;
+    });
+    async select(runId) {
+        this.selectedId = runId;
+        this.#data.detail = null;
+        this.#data.detailLoading = runId !== null;
+        const attempt = followSelectedRun(this.#data, this.#data.lifetime.epoch);
+        const generation = this.#data.lifetime.detailEpoch;
+        this.#data.lifetime.detailAttempts.add(attempt);
+        try {
+            await attempt;
+        }
+        catch (cause) {
+            if (generation === this.#data.lifetime.detailEpoch) {
+                this.error = cause;
+                this.#data.detailLoading = false;
+            }
+            throw cause;
+        }
+        finally {
+            this.#data.lifetime.detailAttempts.delete(attempt);
+        }
+    }
+    async open(options) { return openRunsWatch(this.#data, options); }
+    async close() { return closeRunsWatch(this.#data); }
+    async dispose() { await this.close(); }
+    async visualizations(query) {
+        return this.#data.source.visualizations(query);
+    }
+    /** Current selected owner description; recorded values remain on the snapshot. */
+    async describe(id) {
+        return this.#data.source.describe(id);
+    }
+    /** Delegates to the client. Does not write a local status or outcome. */
+    async control(input) {
+        return this.#data.source.control(input);
+    }
+}

package/dist/svelte/styles.css

@@ -0,0 +1,16 @@
+@source "./";
+
+:root {
+	--runnable-color-live: #34d399;
+	--runnable-color-warning: #f59e0b;
+	--runnable-color-danger: #ef4444;
+	--runnable-color-info: #60a5fa;
+	--runnable-color-accent: #14b8a6;
+	--runnable-type-train: var(--runnable-color-warning);
+	--runnable-type-benchmark: var(--runnable-color-live);
+	--runnable-type-sweep: #06b6d4;
+	--runnable-type-eval: var(--runnable-color-info);
+	--runnable-type-test: var(--muted-foreground, #64748b);
+	--runnable-type-research: var(--runnable-color-accent);
+	--runnable-terminal-background: color-mix(in srgb, #000 90%, var(--card, #0f172a));
+}

package/dist/svelte/types.d.ts

@@ -0,0 +1,29 @@
+import type { MetricSeriesPoint, RunLogEntry, RunStatus } from '@vibesdotdev/runnable';
+import type { RunArtifactWrite } from '@vibesdotdev/runnable/events';
+export type RunnableRunStatus = RunStatus;
+export interface RunnableTypeSummary {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    parallelizable?: boolean;
+    origin?: string;
+}
+export type RunnableMetricSeriesPoint = MetricSeriesPoint;
+export type RunnableLogEntry = Omit<RunLogEntry, 'level'> & {
+    level: string;
+    id?: string | number;
+};
+export type RunnableArtifactEntry = Pick<RunArtifactWrite, 'id' | 'name' | 'mimeType' | 'size' | 'ts' | 'metadata'> & {
+    path?: string | null;
+    data?: string | null;
+    downloadUrl?: string | null;
+};
+export type ArtifactDownloadHref = (artifact: RunnableArtifactEntry) => string | null | undefined;
+export interface MetricCardProps {
+    label: string;
+    unit?: string;
+    values: number[];
+    color?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/svelte/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,iBAAiB,EACjB,WAAW,EACX,SAAS,EACT,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;AAK1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,GAAG;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,gBAAgB,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC,GAAG;IACrH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAClC,QAAQ,EAAE,qBAAqB,KAC3B,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAE/B,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/svelte/types.js

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

package/dist/svelte/viz/DescriptorPanel.svelte

@@ -0,0 +1,104 @@
+<script lang="ts">
+	import { UserComponent } from '@vibesdotdev/kit/components/user-component';
+	import { RunnableVisualizationDescriptorSchema } from '@vibesdotdev/runnable/schemas';
+	import { bindRunPanel, type RunPanelSource } from '@vibesdotdev/runnable/panels';
+	import { JsonObjectSchema, type JsonValue } from '@vibesdotdev/kernel/schemas/json';
+	import type { RunArtifactWrite } from '@vibesdotdev/runnable/events';
+	import { RunArtifactWriteSchema } from '@vibesdotdev/runnable/events';
+	import * as z from 'zod/v4';
+	import type { CrystalBonds } from './crystal/types';
+	import { resolvePanelType } from './registry';
+	import { mfd as getMfd } from './mfd/pipeline/store.svelte';
+
+	let { descriptor, runId, source, metrics = {}, artifacts = [], liveCrystalBonds = null, runIsActive = false, origin }: {
+		descriptor: object;
+		runId: string;
+		source?: RunPanelSource;
+		/** Legacy metric-only callers remain supported during shared-source cutover. */
+		metrics?: Record<string, number[]>;
+		artifacts?: RunArtifactWrite[];
+		liveCrystalBonds?: CrystalBonds | null;
+		runIsActive?: boolean;
+		origin?: string;
+	} = $props();
+
+	const mfd = getMfd();
+	const parsed = $derived(RunnableVisualizationDescriptorSchema.safeParse(descriptor));
+	const visualization = $derived(parsed.success ? parsed.data : null);
+	const parameters = $derived(visualization?.componentParams ?? {});
+	const binding = $derived(parameters.bind);
+	const bound = $derived(bindRunPanel(parameters, source ?? {
+		run: { id: runId }, metrics: {}, logs: [], children: [], artifacts
+	}));
+	const panelArtifacts = $derived(z.array(RunArtifactWriteSchema).parse(bound.ok && bound.value.artifacts !== undefined
+		? bound.value.artifacts : source?.artifacts ?? artifacts));
+	const metric = $derived(binding && 'metric' in binding ? binding.metric : null);
+	const samples = $derived(metric === null ? [] : source
+		? (bound.ok ? z.array(z.number()).parse(bound.value.values ?? []) : [])
+		: (binding && 'dimensions' in binding && binding.dimensions !== undefined ? []
+			: Object.hasOwn(metrics, metric) ? metrics[metric] ?? [] : []));
+	const rows = $derived(bound.ok && Array.isArray(bound.value.rows)
+		? bound.value.rows.flatMap(row => { const parsedRow = JsonObjectSchema.safeParse(row); return parsedRow.success ? [parsedRow.data] : []; })
+		: []);
+	const columns = $derived([...new Set(rows.flatMap(row => Object.keys(row)))]);
+	const registration = $derived(visualization?.panelType ? resolvePanelType(visualization.panelType) : null);
+	const primitiveParameters = $derived.by(() => {
+		if (!bound.ok) return {};
+		const { rows: boundRows, ...params } = bound.value;
+		const rowCount = z.number().safeParse(boundRows);
+		return rowCount.success ? { ...params, rows: rowCount.data } : params;
+	});
+	const primitiveProps = $derived({
+		...primitiveParameters,
+		id: visualization?.id ?? '', runId, artifacts: panelArtifacts, liveCrystalBonds, runIsActive,
+		value: samples.at(-1) ?? 0, label: visualization?.name ?? visualization?.id ?? ''
+	});
+
+	$effect(() => {
+		if (mfd.initialized && mfd.panelCount > 0 && visualization?.panelType) {
+			const values = metric === null ? rows.flatMap(row => {
+				const number = z.number().safeParse(row.value);
+				return number.success ? [number.data] : [];
+			}) : samples;
+			mfd.setData(visualization.id, values);
+		}
+	});
+
+	function display(value: JsonValue | undefined): string {
+		if (value === undefined) return '';
+		const text = z.string().safeParse(value);
+		return text.success ? text.data : JSON.stringify(value);
+	}
+</script>
+
+{#if !parsed.success}
+	<p role="alert">Invalid visualization: {parsed.error.message}</p>
+{:else if !bound.ok}
+	<p role="alert">Invalid visualization parameters: {bound.reason}</p>
+{:else if visualization?.componentRef}
+	<UserComponent id={visualization.componentRef.id} version={visualization.componentRef.version}
+		{origin} props={{ ...bound.value, runId, metrics, artifacts: panelArtifacts, liveCrystalBonds, runIsActive }} />
+{:else if metric !== null && samples.length === 0}
+	<p role="status">{visualization?.name ?? visualization?.id}: no data for {metric}.</p>
+{:else if registration}
+	{@const Primitive = registration.component}
+	<Primitive {...primitiveProps} />
+	{#if binding && ('event' in binding || 'children' in binding)}
+		{#if rows.length === 0}
+			<p role="status">No recorded observations yet.</p>
+		{:else}
+			<div class="panel-records">
+				<table aria-label={visualization?.name ?? visualization?.id}>
+					<thead><tr>{#each columns as column}<th scope="col">{column}</th>{/each}</tr></thead>
+					<tbody>{#each rows as row}<tr>{#each columns as column}<td>{display(row[column])}</td>{/each}</tr>{/each}</tbody>
+				</table>
+			</div>
+		{/if}
+	{/if}
+{/if}
+
+<style>
+	.panel-records { overflow: auto; max-height: 24rem; }
+	table { width: 100%; border-collapse: collapse; font: inherit; }
+	th, td { padding: .4rem .6rem; border-bottom: 1px solid var(--border, #39443d); text-align: left; vertical-align: top; }
+</style>