@volter/editor-core 0.5.57

package/src/authoring/write-pipe.ts

@@ -0,0 +1,173 @@
+/**
+ * THE ONE PERSISTENCE PIPE — `resolve(anchor) → write(dialect) → record(recorder)`.
+ *
+ * Every authored write, from every lane, runs through {@link runWritePipe}.
+ * The lanes that used to be parallel stacks are now this pipe's PLUG POINTS:
+ * a lane supplies a resolution (which anchor this edit lands at), a dialect
+ * writer (the bytes), and a recorder (history), and the pipe supplies the
+ * ordering, the awaiting, and the ack.
+ *
+ * ## The three defects it exists for, all measured on the vendored racing game
+ *
+ * 1. **The ack was the ADAPTER'S blanket answer, not this edit's.** The
+ *    composite joined only its persist-CAPABLE children, so a three-root edit
+ *    acked the DOM root's destination with `persisted: true`. Here the ack is
+ *    produced by the component that performed the write, about that write, and
+ *    there is nowhere else for a caller to get one.
+ * 2. **The classifier and the writer were different components.** A subject the
+ *    adapter classified `live-only` still wrote a real prop into the game's
+ *    source, because the code answering `TruthProvider.resolve` was not
+ *    the code performing the write. Here the anchor is resolved ONCE, and a
+ *    `live-only` resolution has no `write` member at all — reaching a dialect
+ *    writer from it is a type error, not a discipline.
+ * 3. **The write was fired un-awaited, so the ack raced the byte.** Here the
+ *    pipe awaits the dialect writer and the recorder before it acks.
+ *
+ * ## Why `live-only` is a destination and not a failure
+ *
+ * `live-only` (and its play-mode sibling, ephemeral) is a real
+ * {@link WriteAnchorKind}: the edit lands on the running object for the session
+ * and nothing else, and the contract of that kind is that the surface SAYS SO.
+ * So the pipe's live-only branch still applies the edit — the caller has
+ * already done that, synchronously, which is what keeps an `endEdit(); undo()`
+ * sequence working — and answers `persisted: false` with the reason reported
+ * where a user can read it. What the pipe forbids is the inverse: naming a
+ * destination no byte reached.
+ */
+
+import type { WriteAck, WriteAnchorKind } from '@volter/editor-project/adapter';
+
+export type { WriteAck } from '@volter/editor-project/adapter';
+
+/** What a surface reports when nothing this session does reaches a file. */
+export const LIVE_ONLY_DESTINATION = 'live-only (not saved)';
+
+/** What a play-mode adoption reports: edits are real, and die with the session. */
+export const EPHEMERAL_DESTINATION = 'ephemeral (discarded on stop)';
+
+/** What `CompositeAuthoringAdapter.persistence` reports when no child of the
+ *  composition can persist at all. That provider answers the SAVE-status
+ *  question ("where do this surface's saves go"), never the per-edit one — the
+ *  pipe's ack is the only answer to that. */
+export const NO_PERSISTABLE_CHILD_DESTINATION = '(no persistable child)';
+
+/** The honest floor, as a value: no write was performed, and saying so is the
+ *  whole point. Frozen because it is shared by every lane that has no write. */
+export const LIVE_ONLY_ACK: WriteAck = Object.freeze({
+  destination: LIVE_ONLY_DESTINATION,
+  persisted: false,
+});
+
+/**
+ * A CLIPBOARD gesture reports itself by its WRITE, never by the clipboard half
+ * that already succeeded.
+ *
+ * `StructuralClipboardOutcome` (`@volter/editor-project/adapter`) keeps `false` as the refusal
+ * channel and reserves the {@link WriteAck} for a SUCCESSFUL cut/paste. A cut
+ * whose removal reached no byte is a COPY: handing its `persisted: false` ack
+ * straight back is truthy, so every caller — `consumer-actions.ts`'s
+ * `clipboardStructureWrite`, which only shortcuts on `=== false`, and the
+ * composite's `cut`, which claims clipboard ownership on anything else — reads
+ * a refusal as a landed edit.
+ *
+ * ONE owner, because the four lanes each said this inline and one commit
+ * deleted all four collapses together while widening the return type.
+ */
+export function clipboardOutcome(ack: WriteAck): false | WriteAck {
+  return ack.persisted ? ack : false;
+}
+
+/** An anchor kind that has somewhere to land. `live-only` is excluded BY THE
+ *  TYPE, which is what makes "a live-only resolution cannot reach a writer" a
+ *  compile-time fact rather than a convention. */
+export type AnchoredWriteKind = Exclude<WriteAnchorKind, 'live-only'>;
+
+/**
+ * Step 1's product: what THIS edit's anchor resolved to.
+ *
+ * The two arms are not "success" and "failure" — they are the two honest
+ * outcomes of asking where an edit lands. Only the `writer` arm carries a
+ * `write`, so a lane cannot accidentally write through a resolution that said
+ * there was nowhere to write.
+ */
+export type WriteResolution =
+  | {
+      readonly reaches: 'writer';
+      /** Which lane carries it — the SAME fact `TruthProvider.resolve`
+       *  must report for this subject, because both read this resolution. */
+      readonly anchorKind: AnchoredWriteKind;
+      /** Where the bytes go, in the dialect writer's own words. */
+      readonly destination: string;
+      /** Step 2 — the dialect writer, already bound to this edit. `true` ⇒ the
+       *  bytes landed and the writer's own transaction carries both halves. */
+      readonly write: () => Promise<boolean>;
+    }
+  | {
+      readonly reaches: 'live-only';
+      /** {@link LIVE_ONLY_DESTINATION} or {@link EPHEMERAL_DESTINATION}. */
+      readonly destination: string;
+      /** Why there is nowhere to write — reported to the user by the lane's
+       *  own reporter, never swallowed. */
+      readonly reason: string;
+    };
+
+/** One edit, offered to the pipe. */
+export interface PipedWrite {
+  /**
+   * Step 1 — resolve THIS edit's anchor. Called EXACTLY ONCE by the pipe, so
+   * the classification a caller reads and the route the write takes are the
+   * same object rather than two evaluations that can disagree.
+   */
+  resolve(): WriteResolution;
+  /**
+   * Step 3 — the recorder. Called exactly once, after the write step settled,
+   * with what actually happened. `persisted: true` ⇒ the dialect writer's own
+   * transaction already carries both the file and the live half, so the
+   * recorder skips its session journal rather than adding a second entry.
+   *
+   * This is where undo/redo integrates, and it is the ONLY place: a lane that
+   * journals outside the pipe forks history, which is what the pipe replaced.
+   */
+  record(persisted: boolean): void;
+  /**
+   * Show a live-only reason where the user can read it. Called only for the
+   * `live-only` arm, and only when the lane wants it said (an unarmed backend
+   * refusing on every frame of a game somebody is playing is noise, so lanes
+   * gate this themselves).
+   */
+  report?(reason: string): void;
+}
+
+/**
+ * RUN ONE EDIT THROUGH THE PIPE, and answer for it.
+ *
+ * The ordering is the contract: resolve, then write (awaited), then record
+ * (before the ack). A caller that awaits this ack has awaited the byte.
+ *
+ * A dialect writer that comes back `false` has already reported its own reason
+ * (that is its contract — every refusal names its gate), and the edit degrades
+ * to the live-only floor: the value is on the running object, the recorder
+ * journals it so it can be undone, and the ack says no byte moved.
+ */
+export async function runWritePipe(edit: PipedWrite): Promise<WriteAck> {
+  const resolution = edit.resolve();
+  if (resolution.reaches === 'live-only') {
+    edit.report?.(resolution.reason);
+    edit.record(false);
+    return { destination: resolution.destination, persisted: false };
+  }
+  const persisted = await resolution.write();
+  edit.record(persisted);
+  return persisted
+    ? { destination: resolution.destination, persisted: true }
+    : { destination: LIVE_ONLY_DESTINATION, persisted: false };
+}
+
+/** Spell a live-only resolution — the one form, so no lane invents a second
+ *  phrasing of "there is nowhere to write". */
+export function resolvesLiveOnly(
+  reason: string,
+  destination: string = LIVE_ONLY_DESTINATION,
+): WriteResolution {
+  return { reaches: 'live-only', destination, reason };
+}

package/src/availability-tick.ts

@@ -0,0 +1,66 @@
+/**
+ * ONE shared 250ms availability tick replacing the three independent
+ * `setInterval(…, 250)` pollers that W4 left behind (utility availability,
+ * the Dev utility's live-plane gate, and ConnectionStatus's networking-adapter
+ * poll).
+ *
+ * These gates all watch the SAME kind of out-of-band signal — a live play
+ * session's adapters appearing/disappearing without any store/registry
+ * notification — so they don't need three timers, three wakeups, and three
+ * interleaved re-render schedules; they need one heartbeat. The interval is
+ * refcounted: it starts with the first subscriber and stops with the last,
+ * so an idle editor (none of the three consumers mounted) runs no timer at
+ * all — strictly better than the three always-on intervals it replaces.
+ *
+ * `useSyncExternalStore`-shaped on purpose: consumers subscribe and SELECT
+ * the derived value they actually read (`getActiveDebug()` presence, a
+ * connection state, an availability fingerprint) — they re-render only when
+ * that value changes, never on the tick itself. The former version-counter
+ * hook (`useAvailabilityTick`) re-rendered every subscriber 4×/s
+ * unconditionally; with the workspace and every panel subscribed
+ * that measured ~27ms of React work per tick (~110ms/s) in an idle editor —
+ * found 2026-07-31 by the Profiler's long-animation-frame attribution.
+ */
+
+import { useSyncExternalStore } from 'react';
+
+const TICK_MS = 250;
+
+let _version = 0;
+let _intervalId: ReturnType<typeof setInterval> | null = null;
+const _listeners = new Set<() => void>();
+
+function onTick(): void {
+  _version++;
+  for (const fn of _listeners) fn();
+}
+
+/** Subscribe to the shared 250ms tick. Starts the timer on first subscriber,
+ *  stops it with the last. Returns unsubscribe. */
+export function subscribeAvailabilityTick(fn: () => void): () => void {
+  _listeners.add(fn);
+  if (_intervalId === null) _intervalId = setInterval(onTick, TICK_MS);
+  return () => {
+    _listeners.delete(fn);
+    if (_listeners.size === 0 && _intervalId !== null) {
+      clearInterval(_intervalId);
+      _intervalId = null;
+    }
+  };
+}
+
+/** Monotonic tick counter — exposed for tests that assert the timer runs. */
+export function availabilityTickVersion(): number {
+  return _version;
+}
+
+/**
+ * Re-evaluate `select` on every shared availability tick, re-rendering the
+ * caller ONLY when its result changes (`Object.is`). `select` must return a
+ * primitive or a stable reference (an adapter identity, a joined-id string,
+ * a bitmask) — a fresh object every call would defeat the point and re-render
+ * per tick. It runs 4×/s plus once per render, so keep it a cheap read.
+ */
+export function useAvailabilitySelector<T>(select: () => T): T {
+  return useSyncExternalStore(subscribeAvailabilityTick, select, select);
+}

package/src/bitmap-label.ts

@@ -0,0 +1,120 @@
+/**
+ * The 5x7 bitmap label drawn onto every contact sheet cell.
+ *
+ * Extracted from `asset-preview.ts` (where it was `drawBitmapLabel` plus its
+ * `LABEL_GLYPHS` table) when the STORY lane needed the same labels: a story
+ * variant sheet is composited from DOM captures and has no business importing
+ * the three.js asset-preview engine to draw a caption. Same pixels, one owner
+ * — a second hand-rolled label routine is exactly how two sheets start
+ * looking like two products.
+ *
+ * A bitmap font rather than `fillText`: the sheet is evidence, and canvas text
+ * rendering varies by platform font stack, which would make two runs of the
+ * same capture differ in a way that has nothing to do with the subject.
+ */
+
+const LABEL_GLYPHS: Record<string, readonly string[]> = {
+  F: ['11111', '10000', '10000', '11110', '10000', '10000', '10000'],
+  R: ['11110', '10001', '10001', '11110', '10100', '10010', '10001'],
+  O: ['01110', '10001', '10001', '10001', '10001', '10001', '01110'],
+  N: ['10001', '11001', '11001', '10101', '10011', '10011', '10001'],
+  T: ['11111', '00100', '00100', '00100', '00100', '00100', '00100'],
+  I: ['11111', '00100', '00100', '00100', '00100', '00100', '11111'],
+  G: ['01110', '10001', '10000', '10111', '10001', '10001', '01110'],
+  H: ['10001', '10001', '10001', '11111', '10001', '10001', '10001'],
+  P: ['11110', '10001', '10001', '11110', '10000', '10000', '10000'],
+  '3': ['11110', '00001', '00001', '01110', '00001', '00001', '11110'],
+  '/': ['00001', '00010', '00100', '00100', '01000', '10000', '10000'],
+  '4': ['00010', '00110', '01010', '10010', '11111', '00010', '00010'],
+  // Labeled shot sets (project-defined labels like 'ZOOM-HEAD'/'BEND-Q')
+  // pull in these additional glyphs, same 5x7 bitmap style as the set
+  // above. The font covers A-Z and 0-9 outright rather than the subset the
+  // in-repo sets happen to spell: a missing glyph renders as a BLANK CELL,
+  // so a partial font mislabels a project's shot silently — the dragon set's
+  // 'ZOOM-WINGTIP-UP' drew as 'ZOOM- INGTIP-UP' for want of a W.
+  A: ['01110', '10001', '10001', '11111', '10001', '10001', '10001'],
+  B: ['11110', '10001', '10001', '11110', '10001', '10001', '11110'],
+  C: ['01111', '10000', '10000', '10000', '10000', '10000', '01111'],
+  D: ['11110', '10001', '10001', '10001', '10001', '10001', '11110'],
+  E: ['11111', '10000', '10000', '11110', '10000', '10000', '11111'],
+  K: ['10001', '10010', '10100', '11000', '10100', '10010', '10001'],
+  L: ['10000', '10000', '10000', '10000', '10000', '10000', '11111'],
+  M: ['10001', '11011', '10101', '10101', '10001', '10001', '10001'],
+  Q: ['01110', '10001', '10001', '10001', '10101', '10010', '01101'],
+  S: ['01111', '10000', '10000', '01110', '00001', '00001', '11110'],
+  U: ['10001', '10001', '10001', '10001', '10001', '10001', '01110'],
+  Z: ['11111', '00001', '00010', '00100', '01000', '10000', '11111'],
+  J: ['00111', '00010', '00010', '00010', '00010', '10010', '01100'],
+  V: ['10001', '10001', '10001', '10001', '10001', '01010', '00100'],
+  W: ['10001', '10001', '10001', '10101', '10101', '11011', '10001'],
+  X: ['10001', '10001', '01010', '00100', '01010', '10001', '10001'],
+  Y: ['10001', '10001', '01010', '00100', '00100', '00100', '00100'],
+  '0': ['01110', '10001', '10011', '10101', '11001', '10001', '01110'],
+  '1': ['00100', '01100', '00100', '00100', '00100', '00100', '01110'],
+  '2': ['01110', '10001', '00001', '00010', '00100', '01000', '11111'],
+  '5': ['11111', '10000', '11110', '00001', '00001', '10001', '01110'],
+  '6': ['00110', '01000', '10000', '11110', '10001', '10001', '01110'],
+  '7': ['11111', '00001', '00010', '00100', '01000', '01000', '01000'],
+  '8': ['01110', '10001', '10001', '01110', '10001', '10001', '01110'],
+  '9': ['01110', '10001', '10001', '01111', '00001', '00010', '01100'],
+  '-': ['00000', '00000', '00000', '11111', '00000', '00000', '00000'],
+  // Axis-orientation annotations (asset-preview's authored-axis markers).
+  '+': ['00000', '00100', '00100', '11111', '00100', '00100', '00000'],
+  '<': ['00010', '00100', '01000', '10000', '01000', '00100', '00010'],
+  '>': ['01000', '00100', '00010', '00001', '00010', '00100', '01000'],
+};
+
+/**
+ * The pixel box {@link drawBitmapLabel} will paint for `label` in a cell of
+ * this size — exported so a caller can right- or bottom-align a label inside
+ * its cell instead of duplicating the font's scale arithmetic.
+ */
+export function measureBitmapLabel(
+  label: string,
+  cellWidth: number,
+  cellHeight: number,
+): { width: number; height: number } {
+  const scale = Math.max(1, Math.floor(Math.min(cellWidth, cellHeight) / 128));
+  const padding = scale * 3;
+  return {
+    width: label.length * scale * 6 - scale + padding * 2,
+    height: scale * 7 + padding * 2,
+  };
+}
+
+export function drawBitmapLabel(
+  context: CanvasRenderingContext2D,
+  label: string,
+  x: number,
+  y: number,
+  cellWidth: number,
+  cellHeight: number,
+  tone: 'normal' | 'warning' = 'normal',
+): void {
+  const scale = Math.max(1, Math.floor(Math.min(cellWidth, cellHeight) / 128));
+  const padding = scale * 3;
+  const advance = scale * 6;
+  const width = label.length * advance - scale + padding * 2;
+  const height = scale * 7 + padding * 2;
+  context.fillStyle = tone === 'warning' ? 'rgba(154, 24, 24, 0.92)' : 'rgba(0, 0, 0, 0.62)';
+  context.fillRect(x, y, width, height);
+  context.fillStyle = '#ffffff';
+  for (let glyphIndex = 0; glyphIndex < label.length; glyphIndex++) {
+    // Labels are project data now — a character outside the bitmap font
+    // renders as a blank cell rather than crashing the capture.
+    const glyph = LABEL_GLYPHS[label[glyphIndex]!];
+    if (!glyph) continue;
+    for (let row = 0; row < glyph.length; row++) {
+      for (let column = 0; column < glyph[row]!.length; column++) {
+        if (glyph[row]![column] === '1') {
+          context.fillRect(
+            x + padding + glyphIndex * advance + column * scale,
+            y + padding + row * scale,
+            scale,
+            scale,
+          );
+        }
+      }
+    }
+  }
+}

package/src/blender-tab-metrics.ts

@@ -0,0 +1,161 @@
+/**
+ * THE BLENDER TWIN'S STALLS, measured by the page and carried to `vgai status`.
+ *
+ * WHY (measured 2026-09-16): one `blender-execute` held the Blender worker for
+ * over 1,800s and wedged the tab; the only report anyone got was a replay
+ * harness timing out. Separately, a 0.86s-per-call cost in a 225-mesh scene
+ * stretched under load into heartbeat timeouts that read as "tab present, did
+ * not respond". The product had a number for NEITHER. Owner ruling: a tab that
+ * stops answering is the product's defect regardless of what the machine is
+ * doing, and the product must surface it.
+ *
+ * TWO MEASUREMENTS, BOTH TAKEN FROM THE PAGE, because neither blocked party can
+ * report on itself:
+ *  - the WORKER's call times come from `BlenderRuntime.metrics()`, which stamps
+ *    each `postMessage` and its reply (`packages/blender-engine/browser/runtime.ts`);
+ *    a blocked worker cannot send, but the side that posted still has a clock.
+ *  - the MAIN THREAD's stalls come from the `longtask` PerformanceObserver kept
+ *    here. (The sky work measured this ad hoc through a `window.__skyStall`
+ *    global; this is that measurement as a proper field of the runtime host,
+ *    with no global.)
+ *
+ * WHY A REGISTRY AND NOT A DIRECT IMPORT. The census sampler
+ * (`tab-census.ts`) must not pull the Blender stack — three.js, the display
+ * LUT contributions, the worker URL — into its import closure just to ask a
+ * question that is usually answered "no session". The lane publishes its meter
+ * here when it constructs its runtime, exactly the way a mounted game publishes
+ * its render-debug adapter to `authoring/active-systems`.
+ *
+ * THE LANE IS A PACKAGE AND REACHES THIS THROUGH THE DOOR (2026-09-19):
+ * `@volter/editor-blender` calls `host.session.reportWorkerCallMeter`
+ * (`editor-host-door.ts`), which is this module's `setBlenderCallMeter`. It
+ * used to import this file directly through `@editor/*` and also START the
+ * observer below, which is the half that was never the package's: the LONG
+ * TASKS are the host page's own, measured whether or not a lane is running,
+ * and a package cannot be the thing that decides the page is being watched.
+ * So publishing a meter is now what starts the watch.
+ *
+ * MEASUREMENT ONLY. Nothing here cancels, kills, or budgets a call, and no
+ * threshold is enforced anywhere: a budget is the owner's policy, and these are
+ * the numbers such a policy would have to be made from.
+ */
+
+import type { EditorHostWorkerCallMetrics } from '@volter/editor-sdk/host';
+import type { BlenderTabMetrics } from '@volter/editor-sdk/tab-census';
+
+/** What the lane publishes: a read of the live call meter. The SHAPE is the
+ *  SDK's (`host.session.reportWorkerCallMeter`), and structural, so this module
+ *  does not import `@volter/blender-engine/browser` (and `BlenderRuntime` does not
+ *  import the editor or the SDK). */
+export type BlenderCallMeter = () => EditorHostWorkerCallMetrics;
+
+let meter: BlenderCallMeter | null = null;
+
+/**
+ * Publish (or retract, with null) the tab's Blender call meter, and start the
+ * page's own stall watch behind it.
+ *
+ * ONE OWNER: the lane's own runtime singleton — the same lifetime as the
+ * session itself. There is no per-document or per-play teardown that may
+ * retract it, because the session outlives both. ONE METER rides the census, so
+ * a second publisher replaces the first.
+ */
+export function setBlenderCallMeter(read: BlenderCallMeter | null): void {
+  meter = read;
+  // The observer's lifetime is the PAGE's (its history is what "during the
+  // last call" is answered from), so it is started, never stopped: a retracted
+  // meter simply stops the census from carrying a `blender` block at all.
+  if (read !== null) startStallObserver();
+}
+
+/** A long task, kept only as long as it can still be attributed to a call. */
+interface StallEntry {
+  readonly start: number;
+  readonly duration: number;
+}
+
+/**
+ * How many recent long tasks to keep for the "during the last call" question.
+ *
+ * A long task is >50ms by spec, so this is minutes of a badly-stalled tab and
+ * nothing at all on a healthy one. Bounded because the observer runs for the
+ * life of the page.
+ */
+const STALL_HISTORY = 128;
+
+let recent: StallEntry[] = [];
+let longestTaskMs: number | null = null;
+let tasksOver100ms = 0;
+let observing = false;
+
+/**
+ * Start watching the main thread. Idempotent, and silent where the Long Tasks
+ * API does not exist (Safari/Firefox): `longestTaskMs` then stays null, which
+ * says "nobody measured" rather than the falsehood a 0 would tell.
+ *
+ * Internal: {@link setBlenderCallMeter} is the one caller, so the page's watch
+ * begins the moment a lane has calls to attribute stalls to, and no package has
+ * to know the page is watched at all.
+ */
+function startStallObserver(): () => void {
+  if (observing) return () => {};
+  if (typeof PerformanceObserver === 'undefined') return () => {};
+  let observer: PerformanceObserver;
+  try {
+    observer = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        const duration = entry.duration;
+        if (longestTaskMs === null || duration > longestTaskMs) longestTaskMs = duration;
+        if (duration >= 100) tasksOver100ms += 1;
+        recent.push({ start: entry.startTime, duration });
+        if (recent.length > STALL_HISTORY) recent = recent.slice(-STALL_HISTORY);
+      }
+    });
+    // `buffered` picks up the boot-time stalls that happened before this ran —
+    // a cold editor boot is one of the longest tasks a session ever has, and it
+    // is not measurable any other way.
+    observer.observe({ type: 'longtask', buffered: true });
+  } catch {
+    // An unsupported entry type throws here on some engines. Same answer as an
+    // absent API: no numbers, rather than invented ones.
+    return () => {};
+  }
+  observing = true;
+  return () => {
+    observer.disconnect();
+    observing = false;
+  };
+}
+
+/**
+ * The tab's Blender block, or null when this tab has no Blender session — the
+ * census then carries no `blender` key at all, because "absent" and "idle" are
+ * different claims.
+ */
+export function blenderTabMetrics(now: number = performance.now()): BlenderTabMetrics | null {
+  const read = meter;
+  if (read === null) return null;
+  const calls = read();
+  const window = calls.lastCallWindow;
+  let duringCall: number | null = null;
+  if (window !== null) {
+    const end = window.end ?? now;
+    for (const task of recent) {
+      // Overlap, not containment: the task that matters most is the one that
+      // was ALREADY running when the call was posted.
+      if (task.start + task.duration < window.start || task.start > end) continue;
+      if (duringCall === null || task.duration > duringCall) duringCall = task.duration;
+    }
+  }
+  return {
+    inFlightMs: calls.inFlightMs,
+    lastCallMs: calls.lastCallMs,
+    maxCallMs: calls.maxCallMs,
+    callsOver5s: calls.callsOver5s,
+    callsOver30s: calls.callsOver30s,
+    longestTaskMs: longestTaskMs === null ? null : Math.round(longestTaskMs),
+    tasksOver100ms,
+    lastCallLongestTaskMs: duringCall === null ? null : Math.round(duringCall),
+    wasmMemoryMB: calls.wasmMemoryMB,
+  };
+}

package/src/board-open-actions.ts

@@ -0,0 +1,20 @@
+/** Palette actions over discoverable component canvases, including closed tabs.
+ * The registry retains the board descriptor; opening does not create another board. */
+
+import type { EditorAction } from './action-registry';
+import {
+  availableWorkspaceDocuments,
+  openAvailableWorkspaceDocument,
+} from './workspace-available-documents';
+
+/** Commands stay available when a board's tab is closed. */
+export function buildBoardOpenActions(): EditorAction[] {
+  return availableWorkspaceDocuments()
+    .filter((entry) => entry.category === 'canvas')
+    .map(({ descriptor }) => ({
+      id: `board:${descriptor.id}`,
+      label: `Open ${descriptor.title}`,
+      category: 'action',
+      execute: () => void openAvailableWorkspaceDocument(descriptor.id),
+    }));
+}