@almadar/ui 6.5.0 → 6.6.0

package/dist/runtime/index.js

@@ -6,7 +6,7 @@ import { createLogger, setNamespaceLevel, isLogLevelEnabled } from '@almadar/log
 import { perfStore, pushPerfEntry, wrapCallbackForEvent, perfStart, perfEnd, perfGauge, prepareSchemaForPreview, perfTimeAsync, collectTraitRefsFromResolvedTrait, buildOrbitalsByTrait, collectEmbeddedTraits } from '@almadar/runtime/ui';
 export { PERF_NAMESPACE, adjustSchemaForMockData, buildMockData, clearPerf, perfEnd, perfStart, perfTime, prepareSchemaForPreview, wrapCallbackForEvent } from '@almadar/runtime/ui';
 import { StateMachineManager, collectDeclaredConfigDefaults, resolveCallSitePayloadCaptures, createServerEffectHandlers, EffectExecutor, createContextFromBindings, createTickScheduler, isValidCronExpression, parseDurationString, InMemoryPersistence, normalizeCallSiteConfigToValues, interpolateValue } from '@almadar/runtime';
-import { mergeEntityFrame, isCircuitEvent, applyListenPayloadMapping, schemaToIR, getPage, clearSchemaCache as clearSchemaCache$1, walkSExpr, buildResolvedTraitConfigs, isRenderBindingMarker, isFileValue, isInlineTrait, containsEntityBinding, isSExpr, isEventPayloadValue, RENDER_BINDING_MARKER } from '@almadar/core';
+import { UI_SLOTS, mergeEntityFrame, isCircuitEvent, applyListenPayloadMapping, schemaToIR, getPage, clearSchemaCache as clearSchemaCache$1, walkSExpr, buildResolvedTraitConfigs, isRenderBindingMarker, isFileValue, isInlineTrait, containsEntityBinding, isSExpr, isEventPayloadValue, RENDER_BINDING_MARKER } from '@almadar/core';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 import * as LucideIcons2 from 'lucide-react';
@@ -10427,7 +10427,7 @@ function collectDrawnItems(nodes) {
   for (const n of nodes) {
     switch (n.type) {
       case "draw-sprite":
-        if (isValidScenePos(n.position)) out.push({ pos: n.position, id: n.id, anchor: n.anchor, width: n.width, height: n.height });
+        if (isValidScenePos(n.position)) out.push({ pos: n.position, id: n.id, anchor: n.anchor, width: n.width, height: n.height, rotation: n.rotation });
         break;
       case "draw-shape":
       case "draw-text":
@@ -10437,7 +10437,7 @@ function collectDrawnItems(nodes) {
         break;
       case "draw-sprite-layer":
         for (const it of n.items) {
-          if (isValidScenePos(it.position)) out.push({ pos: it.position, id: it.id, anchor: it.anchor, width: it.width, height: it.height });
+          if (isValidScenePos(it.position)) out.push({ pos: it.position, id: it.id, anchor: it.anchor, width: it.width, height: it.height, rotation: it.rotation });
         }
         break;
       case "draw-shape-layer":
@@ -10457,15 +10457,39 @@ function buildHitIndex(items) {
   }
   return m;
 }
+function withPreviewPosition(nodes, id, pos) {
+  return nodes.map((n) => {
+    if (n.type === "draw-sprite-layer" || n.type === "draw-shape-layer" || n.type === "draw-text-layer") {
+      if (!n.items.some((it) => it.id === id)) return n;
+      return { ...n, items: n.items.map((it) => it.id === id ? { ...it, position: pos } : it) };
+    }
+    if (n.type === "draw-group") {
+      if (!Array.isArray(n.items)) return n;
+      return { ...n, items: withPreviewPosition(n.items, id, pos) };
+    }
+    if (n.id === id && "position" in n) {
+      return { ...n, position: pos };
+    }
+    return n;
+  });
+}
 function hitTestSprites(items, projector, point) {
   for (let i = items.length - 1; i >= 0; i--) {
     const it = items[i];
     if (it.id === void 0) continue;
     const r = spriteRect(projector, { position: it.pos, anchor: it.anchor, width: it.width, height: it.height });
-    if (point.x >= r.x && point.x <= r.x + r.w && point.y >= r.y && point.y <= r.y + r.h) return it.id;
+    const test = it.rotation ? rotatePoint(point, { x: r.x + r.w / 2, y: r.y + r.h / 2 }, -it.rotation) : point;
+    if (test.x >= r.x && test.x <= r.x + r.w && test.y >= r.y && test.y <= r.y + r.h) return it.id;
   }
   return void 0;
 }
+function rotatePoint(p, center, radians) {
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  const dx = p.x - center.x;
+  const dy = p.y - center.y;
+  return { x: center.x + dx * cos - dy * sin, y: center.y + dx * sin + dy * cos };
+}
 var init_hitTest = __esm({
   "lib/drawable/hitTest.ts"() {
     init_contract();
@@ -10474,6 +10498,41 @@ var init_hitTest = __esm({
 function normalizeBackdrop(bg) {
   return typeof bg === "string" ? { url: bg, role: "decoration", category: "background" } : bg;
 }
+function selectionOverlayNodes(projector, item) {
+  const r = spriteRect(projector, { position: item.pos, anchor: item.anchor, width: item.width, height: item.height });
+  const tw = projector.tileWidth;
+  const cellTopLeft = projector.anchorPoint(item.pos, "top-left");
+  const offsetX = (r.x - cellTopLeft.x) / tw;
+  const offsetY = (r.y - cellTopLeft.y) / tw;
+  const width = r.w / tw;
+  const height = r.h / tw;
+  const handle = EDIT_HANDLE_SIZE_PX / tw;
+  const ring = {
+    type: "draw-shape",
+    shape: "rect",
+    position: item.pos,
+    anchor: "top-left",
+    offsetX,
+    offsetY,
+    width,
+    height,
+    stroke: EDIT_SELECTION_COLOR,
+    strokeWidth: 2,
+    fill: "none"
+  };
+  const handles = EDIT_SELECTION_CORNERS.map(([cx, cy]) => ({
+    type: "draw-shape",
+    shape: "rect",
+    position: item.pos,
+    anchor: "top-left",
+    offsetX: offsetX + cx * width - handle / 2,
+    offsetY: offsetY + cy * height - handle / 2,
+    width: handle,
+    height: handle,
+    fill: EDIT_SELECTION_COLOR
+  }));
+  return [ring, ...handles];
+}
 function Canvas2D({
   className,
   isLoading = false,
@@ -10487,6 +10546,12 @@ function Canvas2D({
   tileLeaveEvent,
   keyMap,
   keyUpMap,
+  editable = false,
+  selectedId = null,
+  onSelect,
+  onMove,
+  selectEvent,
+  moveEvent,
   camera = "pan-zoom",
   scale = 0.4,
   tileWidth,
@@ -10744,10 +10809,22 @@ function Canvas2D({
     painter.scale(cam.zoom, cam.zoom);
     painter.translate(-viewportSize.width / 2 - cam.x, -viewportSize.height / 2 - cam.y);
     const dctx = { projector, time: timeMs, invalidate: bumpAtlas };
-    for (const node of drawables) paintDrawable(painter, node, dctx);
+    let paintNodes = drawables;
+    if (editable) {
+      const drag = editDragRef.current;
+      if (drag && drag.moved) {
+        paintNodes = withPreviewPosition(paintNodes, drag.id, { x: drag.previewX, y: drag.previewY });
+      }
+      const selectedItem = selectedId != null ? drawnItems.find((it) => it.id === selectedId) : void 0;
+      if (selectedItem) {
+        const overlaySource = drag && drag.moved && drag.id === selectedId ? { ...selectedItem, pos: { x: drag.previewX, y: drag.previewY } } : selectedItem;
+        paintNodes = [...paintNodes, ...selectionOverlayNodes(projector, overlaySource)];
+      }
+    }
+    for (const node of paintNodes) paintDrawable(painter, node, dctx);
     painter.restore();
-    scheduleAnimation(drawables);
-  }, [viewportSize, backgroundImage, bgColor, drawables, projector, cameraRef, bumpAtlas, getImage, cameraPos, defaultGridFocus, camera, dragDistance]);
+    scheduleAnimation(paintNodes);
+  }, [viewportSize, backgroundImage, bgColor, drawables, projector, cameraRef, bumpAtlas, getImage, cameraPos, defaultGridFocus, camera, dragDistance, editable, selectedId, drawnItems]);
   useEffect(() => {
     drawTimeRef.current = draw;
   }, [draw]);
@@ -10792,23 +10869,83 @@ function Canvas2D({
     };
   }, [camera, followTarget, lerpToTarget, draw]);
   const singlePointerActiveRef = useRef(false);
+  const editDragRef = useRef(null);
+  const pointerToScene = useCallback((clientX, clientY) => {
+    const canvas = canvasRef.current;
+    if (!canvas) return { x: 0, y: 0 };
+    const world = screenToWorld(clientX, clientY, canvas, viewportSize);
+    const adjustedX = world.x - scaledTileWidth / 2;
+    const adjustedY = squareGrid ? world.y - scaledTileWidth / 2 : world.y - scaledDiamondTopY - scaledFloorHeight / 2;
+    return unproject(adjustedX, adjustedY);
+  }, [screenToWorld, viewportSize, scaledTileWidth, squareGrid, scaledDiamondTopY, scaledFloorHeight, unproject]);
   const handleCanvasPointerDown = useCallback((e) => {
     singlePointerActiveRef.current = true;
+    if (editable) {
+      if (!canvasRef.current) return;
+      const world = screenToWorld(e.clientX, e.clientY, canvasRef.current, viewportSize);
+      const hitId = hitTestSprites(drawnItems, projector, world);
+      if (hitId === void 0) return;
+      const item = [...drawnItems].reverse().find((it) => it.id === hitId);
+      if (!item) return;
+      editDragRef.current = {
+        id: hitId,
+        pointerId: e.pointerId,
+        startClientX: e.clientX,
+        startClientY: e.clientY,
+        startSceneX: item.pos.x,
+        startSceneY: item.pos.y,
+        moved: false,
+        previewX: item.pos.x,
+        previewY: item.pos.y
+      };
+      return;
+    }
     if (enableCamera) handlePointerDown(e);
-  }, [enableCamera, handlePointerDown]);
+  }, [editable, screenToWorld, viewportSize, drawnItems, projector, enableCamera, handlePointerDown]);
   const handleCanvasPointerMove = useCallback((e) => {
+    if (editable) {
+      const drag = editDragRef.current;
+      if (!drag || drag.pointerId !== e.pointerId) return;
+      const dxPx = e.clientX - drag.startClientX;
+      const dyPx = e.clientY - drag.startClientY;
+      if (!drag.moved && Math.abs(dxPx) + Math.abs(dyPx) <= 5) return;
+      drag.moved = true;
+      const nowScene = pointerToScene(e.clientX, e.clientY);
+      const startScene = pointerToScene(drag.startClientX, drag.startClientY);
+      drag.previewX = drag.startSceneX + (nowScene.x - startScene.x);
+      drag.previewY = drag.startSceneY + (nowScene.y - startScene.y);
+      draw();
+      return;
+    }
     if (enableCamera) handlePointerMove(e, () => draw());
-  }, [enableCamera, handlePointerMove, draw]);
+  }, [editable, pointerToScene, draw, enableCamera, handlePointerMove]);
   const handleCanvasHover = useCallback((e) => {
     if (singlePointerActiveRef.current) return;
     if (!tileHoverEvent || !canvasRef.current) return;
-    const world = screenToWorld(e.clientX, e.clientY, canvasRef.current, viewportSize);
-    const adjustedX = world.x - scaledTileWidth / 2;
-    const adjustedY = squareGrid ? world.y - scaledTileWidth / 2 : world.y - scaledDiamondTopY - scaledFloorHeight / 2;
-    const isoPos = unproject(adjustedX, adjustedY);
+    const isoPos = pointerToScene(e.clientX, e.clientY);
     eventBus.emit(`UI:${tileHoverEvent}`, { x: isoPos.x, y: isoPos.y });
-  }, [screenToWorld, viewportSize, scaledTileWidth, squareGrid, scaledDiamondTopY, scaledFloorHeight, unproject, tileHoverEvent, eventBus]);
+  }, [pointerToScene, tileHoverEvent, eventBus]);
   const handleCanvasPointerUp = useCallback((e) => {
+    if (editable) {
+      singlePointerActiveRef.current = false;
+      const drag = editDragRef.current;
+      if (drag && drag.pointerId === e.pointerId) {
+        editDragRef.current = null;
+        if (drag.moved) {
+          onMove?.(drag.id, drag.previewX, drag.previewY);
+          if (moveEvent) eventBus.emit(`UI:${moveEvent}`, { id: drag.id, x: drag.previewX, y: drag.previewY });
+          draw();
+          return;
+        }
+        const next = selectedId === drag.id ? null : drag.id;
+        onSelect?.(next);
+        if (selectEvent) eventBus.emit(`UI:${selectEvent}`, { id: next });
+        return;
+      }
+      onSelect?.(null);
+      if (selectEvent) eventBus.emit(`UI:${selectEvent}`, { id: null });
+      return;
+    }
     singlePointerActiveRef.current = false;
     if (enableCamera) handlePointerUp();
     if (dragDistance() > 5) return;
@@ -10819,16 +10956,14 @@ function Canvas2D({
       eventBus.emit(`UI:${unitClickEvent}`, { unitId: spriteHit });
       return;
     }
-    const adjustedX = world.x - scaledTileWidth / 2;
-    const adjustedY = squareGrid ? world.y - scaledTileWidth / 2 : world.y - scaledDiamondTopY - scaledFloorHeight / 2;
-    const isoPos = unproject(adjustedX, adjustedY);
+    const isoPos = pointerToScene(e.clientX, e.clientY);
     const hitId = hitIndex.get(`${isoPos.x},${isoPos.y}`);
     if (hitId !== void 0 && unitClickEvent) {
       eventBus.emit(`UI:${unitClickEvent}`, { unitId: hitId });
     } else if (tileClickEvent) {
       eventBus.emit(`UI:${tileClickEvent}`, { x: isoPos.x, y: isoPos.y });
     }
-  }, [enableCamera, handlePointerUp, dragDistance, screenToWorld, viewportSize, scaledTileWidth, squareGrid, scaledDiamondTopY, scaledFloorHeight, unproject, hitIndex, drawnItems, projector, tileClickEvent, unitClickEvent, eventBus]);
+  }, [editable, selectedId, onMove, moveEvent, onSelect, selectEvent, eventBus, draw, enableCamera, handlePointerUp, dragDistance, screenToWorld, viewportSize, drawnItems, projector, tileClickEvent, unitClickEvent, hitIndex, pointerToScene]);
   const handleCanvasPointerLeave = useCallback(() => {
     handleMouseLeave();
     if (tileLeaveEvent) eventBus.emit(`UI:${tileLeaveEvent}`, {});
@@ -10847,7 +10982,7 @@ function Canvas2D({
   }, [enableCamera, handlePointerUp]);
   const gestureHandlers = useCanvasGestures({
     canvasRef,
-    enabled: enableCamera || !!tileHoverEvent || !!tileClickEvent || !!unitClickEvent,
+    enabled: enableCamera || !!tileHoverEvent || !!tileClickEvent || !!unitClickEvent || editable,
     onPointerDown: handleCanvasPointerDown,
     onPointerMove: handleCanvasPointerMove,
     onPointerUp: handleCanvasPointerUp,
@@ -10979,7 +11114,7 @@ function Canvas2D({
     }
   ) });
 }
-var canvas2DLog;
+var canvas2DLog, EDIT_SELECTION_COLOR, EDIT_HANDLE_SIZE_PX, EDIT_SELECTION_CORNERS;
 var init_Canvas2D = __esm({
   "components/game/molecules/Canvas2D.tsx"() {
     "use client";
@@ -11004,8 +11139,12 @@ var init_Canvas2D = __esm({
     init_DrawGroup();
     init_registry();
     init_hitTest();
+    init_contract();
     init_isometric();
     canvas2DLog = createLogger("almadar:ui:game-canvas");
+    EDIT_SELECTION_COLOR = "#3b82f6";
+    EDIT_HANDLE_SIZE_PX = 8;
+    EDIT_SELECTION_CORNERS = [[0, 0], [1, 0], [0, 1], [1, 1]];
     Canvas2D.displayName = "Canvas2D";
   }
 });
@@ -11047,6 +11186,12 @@ function Canvas({
   featureClickEvent,
   keyMap,
   keyUpMap,
+  editable,
+  selectedId,
+  onSelect,
+  onMove,
+  selectEvent,
+  moveEvent,
   children
 }) {
   canvasLog.debug("Canvas render", { mode, drawablesCount: drawables?.length, projection, camera: camera ? JSON.stringify(camera) : void 0 });
@@ -11124,6 +11269,12 @@ function Canvas({
       tileLeaveEvent,
       keyMap,
       keyUpMap,
+      editable,
+      selectedId,
+      onSelect,
+      onMove,
+      selectEvent,
+      moveEvent,
       ...children !== void 0 ? { children } : {}
     }
   );
@@ -11145,15 +11296,19 @@ function GameAudioToggle({
   size = "sm",
   className,
   onAsset,
-  offAsset
+  offAsset,
+  toggleEvent
 }) {
   const ctx = useGameAudioContextOptional();
   const [localMuted, setLocalMuted] = useState(false);
   const muted = ctx ? ctx.muted : localMuted;
   const setMuted = ctx ? ctx.setMuted : setLocalMuted;
+  const eventBus = useEventBus();
   const handleToggle = useCallback(() => {
-    setMuted(!muted);
-  }, [muted, setMuted]);
+    const next = !muted;
+    setMuted(next);
+    if (toggleEvent) eventBus.emit(`UI:${toggleEvent}`, { muted: next });
+  }, [muted, setMuted, toggleEvent, eventBus]);
   const activeAsset = muted ? offAsset : onAsset;
   return /* @__PURE__ */ jsx(
     Button,
@@ -11172,10 +11327,319 @@ var init_GameAudioToggle = __esm({
     "use client";
     init_atoms();
     init_cn();
+    init_useEventBus();
     init_GameIcon();
     GameAudioToggle.displayName = "GameAudioToggle";
   }
 });
+function pickPath(entry) {
+  if (Array.isArray(entry.path)) {
+    return entry.path[Math.floor(Math.random() * entry.path.length)];
+  }
+  return entry.path;
+}
+function useGameAudio({
+  manifest,
+  baseUrl = "",
+  initialMuted = false,
+  initialVolume = 1
+}) {
+  const [muted, setMutedState] = useState(initialMuted);
+  const [masterVolume, setMasterVolumeState] = useState(initialVolume);
+  const mutedRef = useRef(muted);
+  const volumeRef = useRef(masterVolume);
+  const manifestRef = useRef(manifest);
+  mutedRef.current = muted;
+  volumeRef.current = masterVolume;
+  manifestRef.current = manifest;
+  const poolsRef = useRef(/* @__PURE__ */ new Map());
+  const getOrCreateElement = useCallback((key) => {
+    const entry = manifestRef.current[key];
+    if (!entry) return null;
+    let pool = poolsRef.current.get(key);
+    if (!pool) {
+      pool = [];
+      poolsRef.current.set(key, pool);
+    }
+    const maxSize = entry.poolSize ?? 1;
+    for (const audio of pool) {
+      if (audio.paused && (audio.ended || audio.currentTime === 0)) {
+        return audio;
+      }
+    }
+    if (pool.length < maxSize) {
+      const src = baseUrl + pickPath(entry);
+      const audio = new Audio(src);
+      audio.loop = entry.loop ?? false;
+      pool.push(audio);
+      return audio;
+    }
+    if (!entry.loop) {
+      let oldest = pool[0];
+      for (const audio of pool) {
+        if (audio.currentTime > oldest.currentTime) {
+          oldest = audio;
+        }
+      }
+      oldest.pause();
+      oldest.currentTime = 0;
+      return oldest;
+    }
+    return null;
+  }, [baseUrl]);
+  const play = useCallback((key) => {
+    if (mutedRef.current) return;
+    const entry = manifestRef.current[key];
+    if (!entry) return;
+    const audio = getOrCreateElement(key);
+    if (!audio) return;
+    audio.volume = Math.min(1, (entry.volume ?? 1) * volumeRef.current);
+    if (!entry.loop) {
+      audio.currentTime = 0;
+    }
+    const promise = audio.play();
+    if (promise) {
+      promise.catch(() => {
+      });
+    }
+  }, [getOrCreateElement]);
+  const stop = useCallback((key) => {
+    const pool = poolsRef.current.get(key);
+    if (!pool) return;
+    for (const audio of pool) {
+      audio.pause();
+      audio.currentTime = 0;
+    }
+  }, []);
+  const currentMusicKeyRef = useRef(null);
+  const currentMusicElRef = useRef(null);
+  const musicFadeRef = useRef(null);
+  const pendingMusicKeyRef = useRef(null);
+  const clearMusicFade = useCallback(() => {
+    if (musicFadeRef.current) {
+      clearInterval(musicFadeRef.current);
+      musicFadeRef.current = null;
+    }
+  }, []);
+  const playMusic = useCallback((key) => {
+    if (key === currentMusicKeyRef.current) return;
+    pendingMusicKeyRef.current = key;
+    const entry = manifestRef.current[key];
+    if (!entry) return;
+    const fadeDurationMs = entry.crossfadeDurationMs ?? 1500;
+    const stepMs = 50;
+    const totalSteps = Math.max(1, fadeDurationMs / stepMs);
+    const targetVolume = Math.min(1, (entry.volume ?? 1) * volumeRef.current);
+    clearMusicFade();
+    const src = baseUrl + (Array.isArray(entry.path) ? entry.path[0] : entry.path);
+    const incoming = new Audio(src);
+    incoming.loop = true;
+    incoming.volume = 0;
+    const outgoing = currentMusicElRef.current;
+    const outgoingStartVol = outgoing?.volume ?? 0;
+    currentMusicKeyRef.current = key;
+    currentMusicElRef.current = incoming;
+    if (!mutedRef.current) {
+      incoming.play().catch(() => {
+        currentMusicKeyRef.current = null;
+        currentMusicElRef.current = outgoing;
+      });
+    }
+    let step = 0;
+    musicFadeRef.current = setInterval(() => {
+      step++;
+      const progress = Math.min(step / totalSteps, 1);
+      incoming.volume = Math.min(1, targetVolume * progress);
+      if (outgoing) {
+        outgoing.volume = Math.max(0, outgoingStartVol * (1 - progress));
+      }
+      if (progress >= 1) {
+        clearMusicFade();
+        if (outgoing) {
+          outgoing.pause();
+          outgoing.src = "";
+        }
+      }
+    }, stepMs);
+  }, [baseUrl, clearMusicFade]);
+  const stopMusic = useCallback((fadeDurationMs = 1e3) => {
+    const outgoing = currentMusicElRef.current;
+    if (!outgoing) return;
+    currentMusicKeyRef.current = null;
+    currentMusicElRef.current = null;
+    pendingMusicKeyRef.current = null;
+    clearMusicFade();
+    const startVolume = outgoing.volume;
+    const stepMs = 50;
+    const totalSteps = Math.max(1, fadeDurationMs / stepMs);
+    let step = 0;
+    musicFadeRef.current = setInterval(() => {
+      step++;
+      const progress = step / totalSteps;
+      outgoing.volume = Math.max(0, startVolume * (1 - progress));
+      if (progress >= 1) {
+        clearMusicFade();
+        outgoing.pause();
+        outgoing.src = "";
+      }
+    }, stepMs);
+  }, [clearMusicFade]);
+  const stopAll = useCallback(() => {
+    for (const pool of poolsRef.current.values()) {
+      for (const audio of pool) {
+        audio.pause();
+        audio.currentTime = 0;
+      }
+    }
+    stopMusic(0);
+  }, [stopMusic]);
+  const setMuted = useCallback((value) => {
+    setMutedState(value);
+    if (value) {
+      for (const [key, pool] of poolsRef.current.entries()) {
+        if (manifestRef.current[key]?.loop) {
+          for (const audio of pool) {
+            if (!audio.paused) audio.pause();
+          }
+        }
+      }
+      currentMusicElRef.current?.pause();
+    } else {
+      for (const [key, pool] of poolsRef.current.entries()) {
+        const entry = manifestRef.current[key];
+        if (entry?.loop && entry?.autostart) {
+          for (const audio of pool) {
+            if (audio.paused) audio.play().catch(() => {
+            });
+          }
+        }
+      }
+      const musicEl = currentMusicElRef.current;
+      if (musicEl) {
+        musicEl.play().catch(() => {
+        });
+      }
+    }
+  }, []);
+  const setMasterVolume = useCallback((volume) => {
+    const clamped = Math.max(0, Math.min(1, volume));
+    setMasterVolumeState(clamped);
+    for (const [key, pool] of poolsRef.current.entries()) {
+      const entryVol = manifestRef.current[key]?.volume ?? 1;
+      for (const audio of pool) {
+        audio.volume = Math.min(1, entryVol * clamped);
+      }
+    }
+    if (!musicFadeRef.current && currentMusicElRef.current) {
+      const key = currentMusicKeyRef.current;
+      const entryVol = key ? manifestRef.current[key]?.volume ?? 1 : 1;
+      currentMusicElRef.current.volume = Math.min(1, entryVol * clamped);
+    }
+  }, []);
+  const unlockedRef = useRef(false);
+  useEffect(() => {
+    const autoKeys = Object.keys(manifest).filter((k) => manifest[k].autostart);
+    const hasPendingMusic = () => pendingMusicKeyRef.current !== null;
+    const hasAutoStart = autoKeys.length > 0;
+    if (!hasAutoStart && !hasPendingMusic()) return;
+    const unlock = () => {
+      if (unlockedRef.current) return;
+      unlockedRef.current = true;
+      if (!mutedRef.current) {
+        for (const key of autoKeys) {
+          play(key);
+        }
+        const pending = pendingMusicKeyRef.current;
+        if (pending && pending !== currentMusicKeyRef.current) {
+          playMusic(pending);
+        }
+      }
+    };
+    document.addEventListener("click", unlock, { once: true });
+    document.addEventListener("keydown", unlock, { once: true });
+    document.addEventListener("touchstart", unlock, { once: true });
+    return () => {
+      document.removeEventListener("click", unlock);
+      document.removeEventListener("keydown", unlock);
+      document.removeEventListener("touchstart", unlock);
+    };
+  }, [manifest, play, playMusic]);
+  useEffect(() => {
+    return () => {
+      clearMusicFade();
+      for (const pool of poolsRef.current.values()) {
+        for (const audio of pool) {
+          audio.pause();
+          audio.src = "";
+        }
+      }
+      poolsRef.current.clear();
+      if (currentMusicElRef.current) {
+        currentMusicElRef.current.pause();
+        currentMusicElRef.current.src = "";
+        currentMusicElRef.current = null;
+      }
+    };
+  }, [clearMusicFade]);
+  return {
+    play,
+    stop,
+    stopAll,
+    playMusic,
+    stopMusic,
+    muted,
+    setMuted,
+    masterVolume,
+    setMasterVolume
+  };
+}
+var init_useGameAudio = __esm({
+  "hooks/useGameAudio.ts"() {
+    "use client";
+    useGameAudio.displayName = "useGameAudio";
+  }
+});
+function GameAudioCue({
+  cue,
+  cueSeq,
+  music,
+  muted,
+  volume,
+  manifest,
+  baseUrl
+}) {
+  const { play, playMusic, stopMusic, setMuted, setMasterVolume } = useGameAudio({
+    manifest,
+    baseUrl,
+    initialMuted: muted,
+    initialVolume: volume
+  });
+  const prevCueSeqRef = useRef(cueSeq);
+  useEffect(() => {
+    if (cue && cueSeq !== void 0 && cueSeq !== prevCueSeqRef.current) {
+      play(cue);
+    }
+    prevCueSeqRef.current = cueSeq;
+  }, [cue, cueSeq, play]);
+  useEffect(() => {
+    if (music) playMusic(music);
+    else stopMusic();
+  }, [music, playMusic, stopMusic]);
+  useEffect(() => {
+    if (muted !== void 0) setMuted(muted);
+  }, [muted, setMuted]);
+  useEffect(() => {
+    if (volume !== void 0) setMasterVolume(volume);
+  }, [volume, setMasterVolume]);
+  return null;
+}
+var init_GameAudioCue = __esm({
+  "components/game/atoms/GameAudioCue.tsx"() {
+    "use client";
+    init_useGameAudio();
+    GameAudioCue.displayName = "GameAudioCue";
+  }
+});
 function isKnownState(s) {
   return s in DEFAULT_STATE_STYLES;
 }
@@ -11874,15 +12338,18 @@ var init_StateJsonView = __esm({
     StateJsonView.displayName = "StateJsonView";
   }
 });
-var GAME_FONTS, GameShell;
-var init_GameShell = __esm({
-  "components/game/templates/GameShell.tsx"() {
-    init_cn();
-    init_Box();
-    init_Card();
-    init_Typography();
-    init_AtlasImage();
-    GAME_FONTS = {
+
+// lib/gameFonts.ts
+function resolveGameFontFamily(input) {
+  if (!input) return void 0;
+  const resolved = GAME_FONT_KEYS[input];
+  if (resolved) return `'${resolved}', ui-sans-serif, system-ui, sans-serif`;
+  return input;
+}
+var GAME_FONT_KEYS;
+var init_gameFonts = __esm({
+  "lib/gameFonts.ts"() {
+    GAME_FONT_KEYS = {
       fredoka: "Fredoka",
       future: "Kenney Future",
       "future-narrow": "Kenney Future Narrow",
@@ -11890,6 +12357,17 @@ var init_GameShell = __esm({
       blocks: "Kenney Blocks",
       mini: "Kenney Mini"
     };
+  }
+});
+var GameShell;
+var init_GameShell = __esm({
+  "components/game/templates/GameShell.tsx"() {
+    init_cn();
+    init_gameFonts();
+    init_Box();
+    init_Card();
+    init_Typography();
+    init_AtlasImage();
     GameShell = ({
       appName = "Game",
       hud,
@@ -11903,7 +12381,7 @@ var init_GameShell = __esm({
       fontFamily,
       "data-theme": dataTheme
     }) => {
-      const font = fontFamily ? GAME_FONTS[fontFamily] ?? fontFamily : void 0;
+      const displayFont = resolveGameFontFamily(fontFamily);
       return /* @__PURE__ */ jsxs(
         Box,
         {
@@ -11922,7 +12400,7 @@ var init_GameShell = __esm({
             // passed — an always-on inline stamp would shadow the orbital's
             // inline-theme font-family-display token (inline style beats the
             // theme provider's vars for the whole shell subtree).
-            ...font ? { "--font-family-display": `'${font}', ui-sans-serif, system-ui, sans-serif` } : {}
+            ...displayFont ? { "--font-family-display": displayFont } : {}
           },
           children: [
             backgroundAsset && /* @__PURE__ */ jsx(
@@ -12120,14 +12598,15 @@ function drawArrowHead(ctx, x1, y1, x2, y2, size) {
   ctx.closePath();
   ctx.fill();
 }
-function drawShape(ctx, shape, width, height, allShapes) {
+function drawShape(ctx, shape, width, height, allShapes, fontFamily) {
   ctx.save();
   const opacity = shape.opacity ?? 1;
   ctx.globalAlpha = opacity;
   const stroke = resolveColor2(shape.color, ctx, "#333333");
   const fill = shape.fill ? resolveColor2(shape.fill, ctx, "#cccccc") : void 0;
   ctx.lineWidth = shape.lineWidth ?? 2;
-  if (shape.dash) ctx.setLineDash([...DASH_PATTERNS[shape.dash]]);
+  const dashPattern = shape.dash ? DASH_PATTERNS[shape.dash] : void 0;
+  if (dashPattern) ctx.setLineDash([...dashPattern]);
   switch (shape.type) {
     case "grid": {
       const step = shape.step ?? 40;
@@ -12249,7 +12728,7 @@ function drawShape(ctx, shape, width, height, allShapes) {
     case "text": {
       if (shape.x == null || shape.y == null || !shape.text) break;
       ctx.fillStyle = stroke;
-      ctx.font = `${shape.fontSize ?? 14}px ${themeBodyFont(ctx.canvas)}`;
+      ctx.font = `${shape.fontSize ?? 14}px ${shape.fontFamily ?? fontFamily ?? themeBodyFont(ctx.canvas)}`;
       ctx.textAlign = shape.align ?? "left";
       ctx.textBaseline = "middle";
       ctx.fillText(shape.text, shape.x, shape.y);
@@ -12291,7 +12770,7 @@ function drawShape(ctx, shape, width, height, allShapes) {
   }
   ctx.restore();
 }
-function readoutShapes(readouts, width) {
+function readoutShapes(readouts, width, fontFamily) {
   const out = [];
   const chipH = 18;
   const gap = 6;
@@ -12315,13 +12794,14 @@ function readoutShapes(readouts, width) {
       text,
       color: "#ffffff",
       fontSize: 10,
-      align: "center"
+      align: "center",
+      fontFamily
     });
     rightEdge = chipX - gap;
   }
   return out;
 }
-function traceShapes(panel, k, width, height) {
+function traceShapes(panel, k, width, height, fontFamily) {
   const w = panel.width ?? Math.round(width * 0.32);
   const h = panel.height ?? Math.round(height * 0.28);
   const x = panel.x ?? width - w - 8;
@@ -12375,14 +12855,14 @@ function traceShapes(panel, k, width, height) {
       out.push({ type: "circle", x: last.x, y: last.y, radius: 2, color, fill: color });
     }
     if (series.label) {
-      out.push({ type: "text", x: x + 6, y: y + 10 + 11 * j, text: series.label, color, fontSize: 9 });
+      out.push({ type: "text", x: x + 6, y: y + 10 + 11 * j, text: series.label, color, fontSize: 9, fontFamily });
     }
   });
   if (panel.yLabel) {
-    out.push({ type: "text", x: x + w - 6, y: y + 10, text: panel.yLabel, color: "#6b7280", fontSize: 9, align: "right" });
+    out.push({ type: "text", x: x + w - 6, y: y + 10, text: panel.yLabel, color: "#6b7280", fontSize: 9, align: "right", fontFamily });
   }
   if (panel.xLabel) {
-    out.push({ type: "text", x: x + w - 6, y: y + h - 6, text: panel.xLabel, color: "#6b7280", fontSize: 9, align: "right" });
+    out.push({ type: "text", x: x + w - 6, y: y + h - 6, text: panel.xLabel, color: "#6b7280", fontSize: 9, align: "right", fontFamily });
   }
   return out;
 }
@@ -12405,13 +12885,14 @@ var init_LearningCanvas = __esm({
     init_useEventBus();
     init_webPainter2d();
     init_paintDispatch();
-    DASH_PATTERNS = { dashed: [6, 4], dotted: [2, 3] };
+    DASH_PATTERNS = { solid: [], dashed: [6, 4], dotted: [2, 3] };
     TRACE_SERIES_COLORS = ["#2563eb", "#dc2626", "#16a34a", "#f59e0b"];
     LearningCanvas = ({
       className,
       width = 600,
       height = 400,
       backgroundColor,
+      fontFamily,
       shapes = [],
       drawables,
       projector,
@@ -12447,10 +12928,10 @@ var init_LearningCanvas = __esm({
       }, [shapes]);
       const derivedShapes = useMemo(() => {
         if (!traces?.length && !readouts?.length) return shapes;
-        const traceOut = (traces ?? []).flatMap((panel, k) => traceShapes(panel, k, width, height));
-        const readoutOut = readouts?.length ? readoutShapes(readouts, width) : [];
+        const traceOut = (traces ?? []).flatMap((panel, k) => traceShapes(panel, k, width, height, fontFamily));
+        const readoutOut = readouts?.length ? readoutShapes(readouts, width, fontFamily) : [];
         return [...shapes, ...traceOut, ...readoutOut];
-      }, [shapes, traces, readouts, width, height]);
+      }, [shapes, traces, readouts, width, height, fontFamily]);
       const draw = useCallback(() => {
         const _perfT = perfStart("learningcanvas:paint");
         const canvas = canvasRef.current;
@@ -12469,15 +12950,15 @@ var init_LearningCanvas = __esm({
           ctx.fillRect(0, 0, width, height);
         }
         for (const shape of derivedShapes) {
-          if (shape.type !== "text") drawShape(ctx, shape, width, height, derivedShapes);
+          if (shape.type !== "text") drawShape(ctx, shape, width, height, derivedShapes, fontFamily);
         }
         for (const shape of derivedShapes) {
-          if (shape.type === "text") drawShape(ctx, shape, width, height, derivedShapes);
+          if (shape.type === "text") drawShape(ctx, shape, width, height, derivedShapes, fontFamily);
         }
         if (drawables?.length && projector) {
           const painter = createWebPainter(ctx, invalidateRef.current);
           const timeMs = needsAnim && typeof performance !== "undefined" ? performance.now() : 0;
-          const dctx = { projector, time: timeMs, invalidate: invalidateRef.current, fontFamily: themeBodyFont(canvas) };
+          const dctx = { projector, time: timeMs, invalidate: invalidateRef.current, fontFamily: fontFamily || themeBodyFont(canvas) };
           for (const node of drawables) {
             paintDrawable(painter, node, dctx);
           }
@@ -17076,6 +17557,250 @@ var init_EmptyState = __esm({
     EmptyState.displayName = "EmptyState";
   }
 });
+
+// lib/editorMotions.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function computeLines(text) {
+  const lines = [];
+  let start = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i === text.length || text[i] === "\n") {
+      lines.push({ start, end: i });
+      start = i + 1;
+    }
+  }
+  return lines;
+}
+function lineIndexAt(lines, pos) {
+  for (let i = 0; i < lines.length; i++) {
+    if (pos <= lines[i].end) return i;
+  }
+  return lines.length - 1;
+}
+function findWords(text) {
+  const words = [];
+  const re = /\w+|\S+/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    words.push({ start: m.index, end: m.index + m[0].length });
+  }
+  return words;
+}
+function nextWordStart(text, pos) {
+  for (const w of findWords(text)) {
+    if (w.start > pos) return w.start;
+  }
+  return text.length;
+}
+function prevWordStart(text, pos) {
+  let result = 0;
+  for (const w of findWords(text)) {
+    if (w.start < pos) result = w.start;
+    else break;
+  }
+  return result;
+}
+function nextWordEnd(text, pos) {
+  for (const w of findWords(text)) {
+    const lastChar = w.end - 1;
+    if (lastChar > pos) return lastChar;
+  }
+  return text.length > 0 ? text.length - 1 : 0;
+}
+function firstNonBlank(text, line) {
+  let i = line.start;
+  while (i < line.end && (text[i] === " " || text[i] === "	")) i++;
+  return i;
+}
+function nextParagraphBoundary(lines, fromLineIdx, textLength) {
+  for (let i = fromLineIdx + 1; i < lines.length; i++) {
+    if (lines[i].start === lines[i].end) return lines[i].start;
+  }
+  return textLength;
+}
+function prevParagraphBoundary(lines, fromLineIdx) {
+  for (let i = fromLineIdx - 1; i >= 0; i--) {
+    if (lines[i].start === lines[i].end) return lines[i].start;
+  }
+  return 0;
+}
+function applyMotion(text, caret, motion, count) {
+  const n = Math.max(1, count);
+  const lines = computeLines(text);
+  const lineIdx = lineIndexAt(lines, caret);
+  const line = lines[lineIdx];
+  switch (motion) {
+    case "left":
+      return clamp(caret - n, line.start, line.end);
+    case "right":
+      return clamp(caret + n, line.start, line.end);
+    case "up": {
+      const col = caret - line.start;
+      const targetIdx = clamp(lineIdx - n, 0, lines.length - 1);
+      const target = lines[targetIdx];
+      return clamp(target.start + col, target.start, target.end);
+    }
+    case "down": {
+      const col = caret - line.start;
+      const targetIdx = clamp(lineIdx + n, 0, lines.length - 1);
+      const target = lines[targetIdx];
+      return clamp(target.start + col, target.start, target.end);
+    }
+    case "word-forward": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) pos = nextWordStart(text, pos);
+      return pos;
+    }
+    case "word-back": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) pos = prevWordStart(text, pos);
+      return pos;
+    }
+    case "word-end": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) pos = nextWordEnd(text, pos);
+      return pos;
+    }
+    case "line-start":
+      return line.start;
+    case "line-end":
+      return line.end > line.start ? line.end - 1 : line.start;
+    case "first-nonblank":
+      return firstNonBlank(text, line);
+    case "doc-start":
+      return 0;
+    case "doc-end":
+      return text.length;
+    case "paragraph-forward": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) {
+        pos = nextParagraphBoundary(lines, lineIndexAt(lines, pos), text.length);
+      }
+      return pos;
+    }
+    case "paragraph-back": {
+      let pos = caret;
+      for (let i = 0; i < n; i++) {
+        pos = prevParagraphBoundary(lines, lineIndexAt(lines, pos));
+      }
+      return pos;
+    }
+    case "line":
+    case "selection":
+      return caret;
+    default: {
+      const _exhaustive = motion;
+      return _exhaustive;
+    }
+  }
+}
+function motionRange(text, caret, motion, count, selection) {
+  if (motion === "selection") {
+    if (!selection) return [caret, caret];
+    return [Math.min(selection[0], selection[1]), Math.max(selection[0], selection[1])];
+  }
+  const lines = computeLines(text);
+  if (motion === "line") {
+    const n = Math.max(1, count);
+    const startIdx = lineIndexAt(lines, caret);
+    const endIdx = clamp(startIdx + n - 1, 0, lines.length - 1);
+    const start2 = lines[startIdx].start;
+    const rawEnd = lines[endIdx].end;
+    const end2 = rawEnd < text.length ? rawEnd + 1 : rawEnd;
+    return [start2, end2];
+  }
+  const newCaret = applyMotion(text, caret, motion, count);
+  let start = Math.min(caret, newCaret);
+  let end = Math.max(caret, newCaret);
+  if (motion === "word-end" || motion === "line-end") {
+    end = Math.min(Math.max(start, newCaret) + 1, text.length);
+  } else if (motion === "word-forward" && newCaret > caret) {
+    const startLine = lineIndexAt(lines, caret);
+    const endLine = lineIndexAt(lines, newCaret);
+    if (endLine !== startLine) {
+      end = lines[startLine].end;
+    }
+  }
+  return [start, end];
+}
+function applyOperator(text, range, operator, register) {
+  const start = clamp(range[0], 0, text.length);
+  const end = clamp(range[1], start, text.length);
+  const removed = text.slice(start, end);
+  if (operator === "yank") {
+    return { text, caret: start, register: removed };
+  }
+  return { text: text.slice(0, start) + text.slice(end), caret: start, register: removed };
+}
+var init_editorMotions = __esm({
+  "lib/editorMotions.ts"() {
+  }
+});
+function isMotionPayload(payload) {
+  return !!payload && typeof payload.editorId === "string" && typeof payload.motion === "string" && typeof payload.count === "number";
+}
+function isOperatePayload(payload) {
+  return !!payload && typeof payload.editorId === "string" && typeof payload.operator === "string" && typeof payload.motion === "string" && typeof payload.count === "number";
+}
+function isInsertTextPayload(payload) {
+  return !!payload && typeof payload.editorId === "string" && typeof payload.text === "string";
+}
+function isSetModePayload(payload) {
+  return !!payload && typeof payload.editorId === "string" && typeof payload.mode === "string" && typeof payload.caret === "string";
+}
+function useEditorCapabilities(args) {
+  const [caretMode, setCaretMode] = useState("bar");
+  const registerRef = useRef("");
+  useEventListener(`UI:${args.events.onMotion}`, (evt) => {
+    if (!args.editorId || !isMotionPayload(evt.payload) || evt.payload.editorId !== args.editorId) return;
+    const ta = args.textareaRef.current;
+    if (!ta) return;
+    const { motion, count } = evt.payload;
+    const newCaret = applyMotion(ta.value, ta.selectionStart, motion, count);
+    if (ta.selectionStart !== ta.selectionEnd) {
+      ta.setSelectionRange(ta.selectionStart, newCaret);
+    } else {
+      ta.setSelectionRange(newCaret, newCaret);
+    }
+  });
+  useEventListener(`UI:${args.events.onOperate}`, (evt) => {
+    if (!args.editorId || !isOperatePayload(evt.payload) || evt.payload.editorId !== args.editorId) return;
+    const ta = args.textareaRef.current;
+    if (!ta) return;
+    const { operator, motion, count } = evt.payload;
+    const selection = motion === "selection" ? [ta.selectionStart, ta.selectionEnd] : void 0;
+    const range = motionRange(ta.value, ta.selectionStart, motion, count, selection);
+    const result = applyOperator(ta.value, range, operator, registerRef.current);
+    registerRef.current = result.register;
+    if (operator === "yank") {
+      ta.setSelectionRange(range[0], range[0]);
+    } else {
+      ta.setRangeText("", range[0], range[1], "end");
+    }
+    args.applyChange(ta.value);
+  });
+  useEventListener(`UI:${args.events.onInsertText}`, (evt) => {
+    if (!args.editorId || !isInsertTextPayload(evt.payload) || evt.payload.editorId !== args.editorId) return;
+    const ta = args.textareaRef.current;
+    if (!ta) return;
+    ta.setRangeText(evt.payload.text, ta.selectionStart, ta.selectionEnd, "end");
+    args.applyChange(ta.value);
+  });
+  useEventListener(`UI:${args.events.onSetMode}`, (evt) => {
+    if (!args.editorId || !isSetModePayload(evt.payload) || evt.payload.editorId !== args.editorId) return;
+    setCaretMode(evt.payload.caret);
+  });
+  return { caretMode };
+}
+var init_useEditorCapabilities = __esm({
+  "components/core/molecules/markdown/useEditorCapabilities.ts"() {
+    "use client";
+    init_useEventBus();
+    init_editorMotions();
+  }
+});
 function isLanguageRegistered(lang) {
   return CODE_LANGUAGE_SET.has(lang) || dynamicallyLoaded.has(lang);
 }
@@ -17161,7 +17886,36 @@ function useLanguageReady(language) {
   }, [language]);
   return ready;
 }
-var dynamicallyLoaded, codeLanguageLoader, orbStyleOverrides, orbStyle, loloStyleOverrides, loloStyle, log6, CODE_LANGUAGES, CODE_LANGUAGE_SET, DIFF_STYLES, DIFF_STYLE_FALLBACK, LINE_PROPS_FN, HIDDEN_LINE_NUMBERS, HIGHLIGHT_CAPACITY_BYTES, CodeBlock;
+function resolveHighlightStyle(lang) {
+  if (lang === "orb") return orbStyle;
+  if (lang === "lolo") return loloStyle;
+  return dark;
+}
+function plainCodeColorOf(style) {
+  return style['code[class*="language-"]']?.color ?? "#d4d4d4";
+}
+function buildLineProps(errorLines, extraClassName) {
+  return (lineNumber) => {
+    const base = {
+      "data-line": String(lineNumber - 1),
+      ...extraClassName ? { className: extraClassName } : {}
+    };
+    const severity = errorLines?.get(lineNumber);
+    if (!severity) return base;
+    return {
+      ...base,
+      style: {
+        display: "block",
+        backgroundColor: severity === "error" ? "rgba(248, 113, 113, 0.18)" : "rgba(251, 191, 36, 0.18)",
+        // amber-400 @ 18%
+        borderLeft: `3px solid ${severity === "error" ? "#ef4444" : "#f59e0b"}`,
+        paddingLeft: "0.5rem",
+        marginLeft: "-0.5rem"
+      }
+    };
+  };
+}
+var dynamicallyLoaded, codeLanguageLoader, orbStyleOverrides, orbStyle, loloStyleOverrides, loloStyle, log6, CODE_LANGUAGES, CODE_LANGUAGE_SET, DIFF_STYLES, DIFF_STYLE_FALLBACK, LINE_PROPS_FN, HIDDEN_LINE_NUMBERS, HIGHLIGHT_CAPACITY_BYTES, MONO_FONT_FAMILY, VIEWER_LINE_NUMBER_STYLE, CodeBlock;
 var init_CodeBlock = __esm({
   "components/core/molecules/markdown/CodeBlock.tsx"() {
     init_cn();
@@ -17177,6 +17931,7 @@ var init_CodeBlock = __esm({
     init_Textarea();
     init_Icon();
     init_useEventBus();
+    init_useEditorCapabilities();
     SyntaxHighlighter.registerLanguage("json", langJson);
     SyntaxHighlighter.registerLanguage("javascript", langJavascript);
     SyntaxHighlighter.registerLanguage("js", langJavascript);
@@ -17395,6 +18150,15 @@ var init_CodeBlock = __esm({
     LINE_PROPS_FN = (n) => ({ "data-line": String(n - 1) });
     HIDDEN_LINE_NUMBERS = { display: "none" };
     HIGHLIGHT_CAPACITY_BYTES = 512 * 1024;
+    MONO_FONT_FAMILY = 'ui-monospace, SFMono-Regular, Menlo, Monaco, "Cascadia Mono", "Courier New", monospace';
+    VIEWER_LINE_NUMBER_STYLE = {
+      minWidth: "2.5em",
+      paddingRight: "1rem",
+      textAlign: "right",
+      userSelect: "none",
+      opacity: 0.5,
+      fontVariantNumeric: "tabular-nums"
+    };
     CodeBlock = React87__default.memo(
       ({
         code: rawCode,
@@ -17419,15 +18183,39 @@ var init_CodeBlock = __esm({
         actions,
         isLoading = false,
         error,
-        showCopy
+        showCopy,
+        // editor capability surface — P1 wires these
+        editorId,
+        onEditorFocus = "EDITOR_FOCUS",
+        onEditorBlur = "EDITOR_BLUR",
+        onMotion = "MOTION",
+        onOperate = "OPERATE",
+        onInsertText = "INSERT_TEXT",
+        onSetMode = "SET_MODE",
+        motions = [
+          "left",
+          "right",
+          "up",
+          "down",
+          "word-forward",
+          "word-back",
+          "word-end",
+          "line-start",
+          "line-end",
+          "first-nonblank",
+          "doc-start",
+          "doc-end",
+          "paragraph-forward",
+          "paragraph-back",
+          "line",
+          "selection"
+        ],
+        operators = ["delete", "yank", "change"]
       }) => {
         const code = typeof rawCode === "string" ? rawCode : String(rawCode ?? "");
-        const isOrb = language === "orb";
-        const isLolo = language === "lolo";
-        const activeStyle = isOrb ? orbStyle : isLolo ? loloStyle : dark;
+        const activeStyle = resolveHighlightStyle(language);
         const overCapacity = code.length > HIGHLIGHT_CAPACITY_BYTES;
-        const plainCodeColor = activeStyle['code[class*="language-"]']?.color ?? "#d4d4d4";
-        const languageReady = useLanguageReady(language);
+        const plainCodeColor = plainCodeColorOf(activeStyle);
         const eventBus = useEventBus();
         const { t } = useTranslate();
         const scrollRef = useRef(null);
@@ -17439,6 +18227,9 @@ var init_CodeBlock = __esm({
         const activeFile = files?.[activeFileIndex];
         const activeCode = activeFile?.code ?? code;
         const activeLanguage = activeFile?.language ?? language;
+        const languageReady = useLanguageReady(activeLanguage);
+        const viewerStyle = resolveHighlightStyle(activeLanguage);
+        const viewerPlainCodeColor = plainCodeColorOf(viewerStyle);
         const diffLines = useMemo(() => {
           if (propDiff) return propDiff;
           if (mode === "diff" && oldValue !== void 0 && newValue !== void 0) {
@@ -17468,28 +18259,28 @@ var init_CodeBlock = __esm({
             ov.scrollLeft = ta.scrollLeft;
           }
         }, []);
-        const errorLineProps = useMemo(() => {
-          if (!errorLines || errorLines.size === 0) {
-            return LINE_PROPS_FN;
-          }
-          return (lineNumber) => {
-            const severity = errorLines.get(lineNumber);
-            if (!severity) {
-              return { "data-line": String(lineNumber - 1) };
-            }
-            return {
-              "data-line": String(lineNumber - 1),
-              style: {
-                display: "block",
-                backgroundColor: severity === "error" ? "rgba(248, 113, 113, 0.18)" : "rgba(251, 191, 36, 0.18)",
-                // amber-400 @ 18%
-                borderLeft: `3px solid ${severity === "error" ? "#ef4444" : "#f59e0b"}`,
-                paddingLeft: "0.5rem",
-                marginLeft: "-0.5rem"
-              }
-            };
-          };
-        }, [errorLines]);
+        const handleEditableChange = useCallback((v) => {
+          lastPropCodeRef.current = v;
+          setEditableValue(v);
+          onChange?.(v);
+        }, [onChange]);
+        const { caretMode } = useEditorCapabilities({
+          editorId: editable ? editorId : void 0,
+          textareaRef: editableTextareaRef,
+          events: { onMotion, onOperate, onInsertText, onSetMode },
+          applyChange: handleEditableChange
+        });
+        const [caretIndex, setCaretIndex] = useState(0);
+        const caretRowCol = useMemo(() => {
+          const before = editableValue.slice(0, Math.min(caretIndex, editableValue.length));
+          const lines = before.split("\n");
+          return { row: lines.length - 1, col: lines[lines.length - 1].length };
+        }, [editableValue, caretIndex]);
+        const errorLineProps = useMemo(() => buildLineProps(errorLines), [errorLines]);
+        const viewerLineProps = useMemo(
+          () => buildLineProps(errorLines, "px-4 py-0.5 hover:bg-muted/50"),
+          [errorLines]
+        );
         const isFoldable = foldableProp ?? true;
         const [collapsed, setCollapsed] = useState(() => /* @__PURE__ */ new Set());
         const foldRegions = useMemo(
@@ -17612,6 +18403,110 @@ var init_CodeBlock = __esm({
           ),
           [code, overCapacity, plainCodeColor, language, activeStyle, languageReady]
         );
+        const viewerOverCapacity = activeCode.length > HIGHLIGHT_CAPACITY_BYTES;
+        const viewerHighlightedElement = useMemo(
+          () => viewerOverCapacity ? /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "px-4 py-0.5",
+              style: {
+                margin: 0,
+                whiteSpace: wrap ? "pre-wrap" : "pre",
+                wordBreak: wrap ? "break-all" : "normal",
+                color: viewerPlainCodeColor,
+                fontFamily: MONO_FONT_FAMILY,
+                fontSize: "12px",
+                lineHeight: "1.6"
+              },
+              children: activeCode
+            }
+          ) : /* @__PURE__ */ jsx(
+            SyntaxHighlighter,
+            {
+              PreTag: "div",
+              language: activeLanguage,
+              style: viewerStyle,
+              wrapLines: true,
+              wrapLongLines: wrap,
+              showLineNumbers,
+              lineNumberStyle: VIEWER_LINE_NUMBER_STYLE,
+              lineProps: viewerLineProps,
+              customStyle: {
+                backgroundColor: "transparent",
+                borderRadius: 0,
+                padding: "0.25rem 0",
+                margin: 0,
+                whiteSpace: wrap ? "pre-wrap" : "pre",
+                wordBreak: wrap ? "break-all" : "normal",
+                fontFamily: MONO_FONT_FAMILY,
+                fontSize: "12px",
+                lineHeight: "1.6"
+              },
+              codeTagProps: { style: { fontFamily: MONO_FONT_FAMILY, fontSize: "12px", lineHeight: "1.6" } },
+              children: activeCode
+            }
+          ),
+          [activeCode, viewerOverCapacity, viewerPlainCodeColor, activeLanguage, viewerStyle, wrap, showLineNumbers, viewerLineProps, languageReady]
+        );
+        const diffOverCapacity = useMemo(
+          () => !!diffLines && diffLines.reduce((n, l) => n + l.content.length + 1, 0) > HIGHLIGHT_CAPACITY_BYTES,
+          [diffLines]
+        );
+        const diffRowElements = useMemo(() => {
+          if (!diffLines) return null;
+          return diffLines.map((line, idx) => {
+            const style = DIFF_STYLES[line.type] ?? DIFF_STYLE_FALLBACK;
+            return /* @__PURE__ */ jsxs(HStack, { gap: "none", align: "start", className: cn(style.bg, "px-4 py-0.5"), children: [
+              showLineNumbers && /* @__PURE__ */ jsx(
+                Typography,
+                {
+                  variant: "caption",
+                  color: "secondary",
+                  className: "w-8 text-right mr-3 select-none tabular-nums flex-shrink-0",
+                  children: line.lineNumber ?? ""
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                Typography,
+                {
+                  variant: "caption",
+                  className: cn("font-mono flex-1 min-w-0", style.text, wrap ? "whitespace-pre-wrap break-all" : "whitespace-pre"),
+                  children: [
+                    /* @__PURE__ */ jsx(Box, { as: "span", className: "select-none opacity-50 mr-2", children: style.prefix }),
+                    diffOverCapacity ? line.content || " " : /* @__PURE__ */ jsx(
+                      SyntaxHighlighter,
+                      {
+                        PreTag: "span",
+                        CodeTag: "span",
+                        language: activeLanguage,
+                        style: viewerStyle,
+                        customStyle: {
+                          display: "inline",
+                          background: "transparent",
+                          padding: 0,
+                          margin: 0,
+                          whiteSpace: wrap ? "pre-wrap" : "pre",
+                          wordBreak: wrap ? "break-all" : "normal",
+                          fontFamily: "inherit",
+                          fontSize: "inherit",
+                          lineHeight: "inherit"
+                        },
+                        codeTagProps: {
+                          style: {
+                            whiteSpace: wrap ? "pre-wrap" : "pre",
+                            fontFamily: "inherit",
+                            fontSize: "inherit"
+                          }
+                        },
+                        children: line.content || " "
+                      }
+                    )
+                  ]
+                }
+              )
+            ] }, idx);
+          });
+        }, [diffLines, showLineNumbers, wrap, diffOverCapacity, activeLanguage, viewerStyle, languageReady]);
         useLayoutEffect(() => {
           const container = codeRef.current;
           if (!container) return;
@@ -17755,7 +18650,6 @@ var init_CodeBlock = __esm({
             label: file.label,
             content: null
           }));
-          const lines = activeCode.split("\n");
           return /* @__PURE__ */ jsx(Card, { className: cn("overflow-hidden", className), children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column" }, children: [
             tabItems && tabItems.length > 1 && /* @__PURE__ */ jsx(Box, { className: "border-b border-border", children: /* @__PURE__ */ jsx(
               Tabs,
@@ -17818,49 +18712,7 @@ var init_CodeBlock = __esm({
                 ]
               }
             ),
-            /* @__PURE__ */ jsx(Box, { className: "overflow-auto bg-muted/20", style: { maxHeight }, children: diffLines ? /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column" }, className: "font-mono text-xs", children: diffLines.map((line, idx) => {
-              const style = DIFF_STYLES[line.type] ?? DIFF_STYLE_FALLBACK;
-              return /* @__PURE__ */ jsxs(HStack, { gap: "none", align: "start", className: cn(style.bg, "px-4 py-0.5"), children: [
-                showLineNumbers && /* @__PURE__ */ jsx(
-                  Typography,
-                  {
-                    variant: "caption",
-                    color: "secondary",
-                    className: "w-8 text-right mr-3 select-none tabular-nums flex-shrink-0",
-                    children: line.lineNumber ?? ""
-                  }
-                ),
-                /* @__PURE__ */ jsxs(
-                  Typography,
-                  {
-                    variant: "caption",
-                    className: cn("font-mono flex-1 min-w-0", style.text, wrap ? "whitespace-pre-wrap break-all" : "whitespace-pre"),
-                    children: [
-                      /* @__PURE__ */ jsx(Box, { as: "span", className: "select-none opacity-50 mr-2", children: style.prefix }),
-                      line.content
-                    ]
-                  }
-                )
-              ] }, idx);
-            }) }) : /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column" }, className: "font-mono text-xs", children: lines.map((line, idx) => /* @__PURE__ */ jsxs(HStack, { gap: "none", align: "start", className: "px-4 py-0.5 hover:bg-muted/50", children: [
-              showLineNumbers && /* @__PURE__ */ jsx(
-                Typography,
-                {
-                  variant: "caption",
-                  color: "secondary",
-                  className: "w-8 text-right mr-4 select-none tabular-nums flex-shrink-0",
-                  children: idx + 1
-                }
-              ),
-              /* @__PURE__ */ jsx(
-                Typography,
-                {
-                  variant: "caption",
-                  className: cn("font-mono flex-1 min-w-0", wrap ? "whitespace-pre-wrap break-all" : "whitespace-pre"),
-                  children: line || " "
-                }
-              )
-            ] }, idx)) }) })
+            /* @__PURE__ */ jsx(Box, { className: "overflow-auto bg-muted/20", style: { maxHeight }, children: diffLines ? /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column" }, className: "font-mono text-xs", children: diffRowElements }) : /* @__PURE__ */ jsx("div", { className: "font-mono text-xs", children: viewerHighlightedElement }) })
           ] }) });
         }
         const hasHeader = showLanguageBadge || effectiveCopy;
@@ -17947,13 +18799,11 @@ var init_CodeBlock = __esm({
                     {
                       ref: editableTextareaRef,
                       defaultValue: code,
-                      onChange: (e) => {
-                        const v = e.target.value;
-                        lastPropCodeRef.current = v;
-                        setEditableValue(v);
-                        onChange?.(v);
-                      },
+                      onChange: (e) => handleEditableChange(e.target.value),
                       onScroll: handleEditableScroll,
+                      onSelect: (e) => setCaretIndex(e.currentTarget.selectionStart),
+                      onFocus: editorId ? () => eventBus.emit(`UI:${onEditorFocus}`, { editorId }) : void 0,
+                      onBlur: editorId ? () => eventBus.emit(`UI:${onEditorBlur}`, { editorId }) : void 0,
                       spellCheck: false,
                       style: {
                         position: "absolute",
@@ -17968,7 +18818,7 @@ var init_CodeBlock = __esm({
                         resize: "none",
                         backgroundColor: "transparent",
                         color: "transparent",
-                        caretColor: "#e6e6e6",
+                        caretColor: caretMode === "block" ? "transparent" : "#e6e6e6",
                         WebkitTextFillColor: "transparent",
                         fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, "Cascadia Mono", "Courier New", monospace',
                         fontSize: "13px",
@@ -17979,6 +18829,22 @@ var init_CodeBlock = __esm({
                       }
                     },
                     editableTextareaKey
+                  ),
+                  caretMode !== "bar" && /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      "aria-hidden": true,
+                      style: {
+                        position: "absolute",
+                        top: `calc(1rem + ${caretRowCol.row * 19.5}px)`,
+                        left: `calc(1rem + ${caretRowCol.col}ch)`,
+                        width: "1ch",
+                        height: caretMode === "block" ? "19.5px" : "2px",
+                        backgroundColor: caretMode === "block" ? "rgba(230, 230, 230, 0.5)" : void 0,
+                        borderBottom: caretMode === "underline" ? "2px solid #e6e6e6" : void 0,
+                        pointerEvents: "none"
+                      }
+                    }
                   )
                 ]
               }
@@ -18006,55 +18872,175 @@ var init_CodeBlock = __esm({
           )
         ] });
       },
-      (prev, next) => prev.language === next.language && prev.code === next.code && prev.showCopyButton === next.showCopyButton && prev.showCopy === next.showCopy && prev.maxHeight === next.maxHeight && prev.foldable === next.foldable && prev.editable === next.editable && prev.onChange === next.onChange && prev.errorLines === next.errorLines && prev.mode === next.mode && prev.title === next.title && prev.diff === next.diff && prev.files === next.files && prev.actions === next.actions && prev.isLoading === next.isLoading && prev.error === next.error
+      (prev, next) => prev.language === next.language && prev.code === next.code && prev.showCopyButton === next.showCopyButton && prev.showCopy === next.showCopy && prev.maxHeight === next.maxHeight && prev.foldable === next.foldable && prev.editable === next.editable && prev.onChange === next.onChange && prev.errorLines === next.errorLines && prev.mode === next.mode && prev.title === next.title && prev.diff === next.diff && prev.files === next.files && prev.actions === next.actions && prev.isLoading === next.isLoading && prev.error === next.error && prev.editorId === next.editorId && prev.onEditorFocus === next.onEditorFocus && prev.onEditorBlur === next.onEditorBlur && prev.onMotion === next.onMotion && prev.onOperate === next.onOperate && prev.onInsertText === next.onInsertText && prev.onSetMode === next.onSetMode && prev.motions === next.motions && prev.operators === next.operators
     );
     CodeBlock.displayName = "CodeBlock";
   }
 });
+
+// components/core/molecules/markdown/mermaidSource.ts
+function isQuoted(label) {
+  const trimmed = label.trim();
+  return trimmed.length === 0 || trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length > 1;
+}
+function quote(label) {
+  return `"${label.replace(/"/g, "#quot;")}"`;
+}
+function isIdentifierChar(ch) {
+  return /[A-Za-z0-9_\-.]/.test(ch);
+}
+function declaredType(code) {
+  for (const line of code.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("%%")) continue;
+    return trimmed;
+  }
+  return "";
+}
+function isFlowchart(code) {
+  return FLOWCHART_DIRECTIVE.test(declaredType(code));
+}
+function quoteNodeLabels(code) {
+  let out = "";
+  let i = 0;
+  while (i < code.length) {
+    const shape = NODE_SHAPES.find(([open2]) => code.startsWith(open2, i));
+    const precededByIdentifier = i > 0 && isIdentifierChar(code[i - 1] ?? "");
+    if (shape === void 0 || !precededByIdentifier) {
+      out += code[i];
+      i += 1;
+      continue;
+    }
+    const [open, close] = shape;
+    const contentStart = i + open.length;
+    const closeAt = code.indexOf(close, contentStart);
+    const newlineAt = code.indexOf("\n", contentStart);
+    if (closeAt === -1 || newlineAt !== -1 && newlineAt < closeAt) {
+      out += code[i];
+      i += 1;
+      continue;
+    }
+    const label = code.slice(contentStart, closeAt);
+    out += open + (isQuoted(label) ? label : quote(label)) + close;
+    i = closeAt + close.length;
+  }
+  return out;
+}
+function quoteEdgeLabels(code) {
+  return code.split("\n").map((line) => {
+    let out = "";
+    let rest = line;
+    for (; ; ) {
+      const open = rest.indexOf("|");
+      if (open === -1) break;
+      const close = rest.indexOf("|", open + 1);
+      if (close === -1) break;
+      const label = rest.slice(open + 1, close);
+      out += rest.slice(0, open + 1) + (isQuoted(label) ? label : quote(label)) + "|";
+      rest = rest.slice(close + 1);
+    }
+    return out + rest;
+  }).join("\n");
+}
+function quoteSubgraphTitles(code) {
+  return code.split("\n").map((line) => {
+    const match = /^(\s*subgraph\s+)(.+?)(\s*)$/.exec(line);
+    if (match === null) return line;
+    const [, prefix, title, trailing] = match;
+    if (title === void 0 || prefix === void 0) return line;
+    if (isQuoted(title) || title.includes("[")) return line;
+    return prefix + quote(title) + (trailing ?? "");
+  }).join("\n");
+}
+function mermaidRepairCandidates(code) {
+  if (!isFlowchart(code)) return [];
+  const nodes = quoteNodeLabels(code);
+  const nodesAndEdges = quoteEdgeLabels(nodes);
+  const all = quoteSubgraphTitles(nodesAndEdges);
+  const ordered2 = [nodes, nodesAndEdges, all];
+  const seen = /* @__PURE__ */ new Set([code]);
+  const candidates = [];
+  for (const candidate of ordered2) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    candidates.push(candidate);
+  }
+  return candidates;
+}
+var NODE_SHAPES, FLOWCHART_DIRECTIVE;
+var init_mermaidSource = __esm({
+  "components/core/molecules/markdown/mermaidSource.ts"() {
+    NODE_SHAPES = [
+      ["[[", "]]"],
+      ["[(", ")]"],
+      ["([", "])"],
+      ["((", "))"],
+      ["{{", "}}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["{", "}"]
+    ];
+    FLOWCHART_DIRECTIVE = /^(?:graph|flowchart)\b/;
+  }
+});
 function loadMermaid() {
   mermaidModule ?? (mermaidModule = import('mermaid').then((m) => m.default));
   return mermaidModule;
 }
-var mermaidModule, MermaidDiagram;
+var log7, mermaidModule, MermaidDiagram;
 var init_MermaidDiagram = __esm({
   "components/core/molecules/markdown/MermaidDiagram.tsx"() {
     init_Box();
     init_Typography();
     init_CodeBlock();
+    init_mermaidSource();
     init_cn();
+    log7 = createLogger("almadar:ui:mermaid-diagram");
     mermaidModule = null;
     MermaidDiagram = React87__default.memo(
       ({ code, className }) => {
         const { resolvedMode } = useTheme();
+        const { t } = useTranslate();
         const containerRef = useRef(null);
-        const [error, setError] = useState(null);
+        const [unrenderable, setUnrenderable] = useState(false);
         const reactId = useId();
         useEffect(() => {
           let active = true;
           void (async () => {
-            try {
-              const mermaid = await loadMermaid();
-              mermaid.initialize({
-                startOnLoad: false,
-                securityLevel: "strict",
-                theme: resolvedMode === "dark" ? "dark" : "default"
-              });
-              const domId = `mermaid-${reactId.replace(/[^a-zA-Z0-9]/g, "")}`;
-              const { svg } = await mermaid.render(domId, code);
-              if (!active || !containerRef.current) return;
-              containerRef.current.innerHTML = svg;
-              setError(null);
-            } catch (err) {
-              if (active) setError(err instanceof Error ? err.message : String(err));
+            const mermaid = await loadMermaid();
+            mermaid.initialize({
+              startOnLoad: false,
+              securityLevel: "strict",
+              theme: resolvedMode === "dark" ? "dark" : "default"
+            });
+            const domId = `mermaid-${reactId.replace(/[^a-zA-Z0-9]/g, "")}`;
+            let firstError = null;
+            for (const [index, source] of [code, ...mermaidRepairCandidates(code)].entries()) {
+              try {
+                const { svg } = await mermaid.render(domId, source);
+                if (!active) return;
+                const container = containerRef.current;
+                if (container === null) return;
+                container.innerHTML = svg;
+                container.dataset.mermaidRepaired = String(index > 0);
+                setUnrenderable(false);
+                if (index > 0) log7.debug("mermaid:repaired", { candidate: index });
+                return;
+              } catch (err) {
+                firstError ?? (firstError = err instanceof Error ? err : new Error(String(err)));
+              }
             }
+            if (!active) return;
+            log7.warn("mermaid:unrenderable", { error: firstError?.message ?? "", code });
+            setUnrenderable(true);
           })();
           return () => {
             active = false;
           };
         }, [code, resolvedMode, reactId]);
         return /* @__PURE__ */ jsxs(Box, { className: cn("not-prose my-4", className), children: [
-          error !== null && /* @__PURE__ */ jsxs(Box, { className: "space-y-2 mb-2", children: [
-            /* @__PURE__ */ jsx(Typography, { variant: "caption", className: "text-error whitespace-pre-wrap", children: error }),
+          unrenderable && /* @__PURE__ */ jsxs(Box, { className: "space-y-2 mb-2", "data-testid": "mermaid-unrenderable", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "caption", className: "text-muted-foreground", children: t("mermaid.unrenderable") }),
             /* @__PURE__ */ jsx(CodeBlock, { code, language: "mermaid" })
           ] }),
           /* @__PURE__ */ jsx(
@@ -18063,7 +19049,7 @@ var init_MermaidDiagram = __esm({
               ref: containerRef,
               "data-testid": "mermaid-diagram",
               className: "overflow-x-auto",
-              style: error !== null ? { display: "none" } : void 0
+              style: unrenderable ? { display: "none" } : void 0
             }
           )
         ] });
@@ -21418,14 +22404,14 @@ function useSafeEventBus2() {
     } };
   }
 }
-var log7, lookStyles4, ButtonGroup;
+var log8, lookStyles4, ButtonGroup;
 var init_ButtonGroup = __esm({
   "components/core/molecules/ButtonGroup.tsx"() {
     "use client";
     init_cn();
     init_atoms();
     init_useEventBus();
-    log7 = createLogger("almadar:ui:button-group");
+    log8 = createLogger("almadar:ui:button-group");
     lookStyles4 = {
       "right-aligned-buttons": "",
       "floating-bar": "fixed bottom-section left-1/2 -translate-x-1/2 shadow-elevation-toast bg-card p-card-sm rounded-container",
@@ -21506,7 +22492,7 @@ var init_ButtonGroup = __esm({
           {
             variant: "ghost",
             onClick: () => {
-              log7.debug("Filter clicked", { field: filter.field });
+              log8.debug("Filter clicked", { field: filter.field });
             },
             children: filter.label
           },
@@ -24223,6 +25209,12 @@ function commandMatches(command, query) {
   if (matchesQuery(query, command.label)) return true;
   return (command.keywords ?? []).some((keyword) => matchesQuery(query, keyword));
 }
+function dispatchCommandPaletteCommand(command, deps) {
+  if (command.disabled) return;
+  if (command.event) deps.emit(`UI:${command.event}`, { commandId: command.id });
+  if (command.action) deps.emit(`UI:${command.action}`, command.actionPayload ?? {});
+  deps.onSelect?.(command);
+}
 var UNGROUPED, CommandPalette;
 var init_CommandPalette = __esm({
   "components/core/molecules/CommandPalette.tsx"() {
@@ -24277,9 +25269,7 @@ var init_CommandPalette = __esm({
       const handleSelect = useCallback(
         (command) => {
           if (command.disabled) return;
-          if (command.event) eventBus.emit(`UI:${command.event}`, { commandId: command.id });
-          if (command.action) eventBus.emit(`UI:${command.action}`, command.actionPayload ?? {});
-          onSelect?.(command);
+          dispatchCommandPaletteCommand(command, { emit: eventBus.emit, onSelect });
           handleClose();
         },
         [eventBus, onSelect, handleClose]
@@ -29074,9 +30064,9 @@ function debug(...args) {
   const [first, ...rest] = args;
   const message = typeof first === "string" ? first : "<debug>";
   if (rest.length === 0 && typeof first === "string") {
-    log8.debug(message);
+    log9.debug(message);
   } else {
-    log8.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
+    log9.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
   }
 }
 function debugGroup(label) {
@@ -29104,11 +30094,11 @@ function toLogMetaValue(v) {
   }
   return String(v);
 }
-var NAMESPACE, log8;
+var NAMESPACE, log9;
 var init_debug = __esm({
   "lib/debug.ts"() {
     NAMESPACE = "almadar:ui:debug";
-    log8 = createLogger(NAMESPACE);
+    log9 = createLogger(NAMESPACE);
     createLogger("almadar:ui:debug:input");
     createLogger("almadar:ui:debug:collision");
     createLogger("almadar:ui:debug:physics");
@@ -30761,6 +31751,7 @@ var init_MathCanvas = __esm({
     init_perf();
     init_atoms();
     init_Stack();
+    init_gameFonts();
     init_LearningCanvas();
     MathCanvas = ({
       className,
@@ -30780,6 +31771,7 @@ var init_MathCanvas = __esm({
       showTickLabels = false,
       tickLabelFontSize = 10,
       labelFontSize = 12,
+      fontFamily: fontFamilyProp,
       showCurveLabels = false,
       curves = [],
       points = [],
@@ -30802,6 +31794,7 @@ var init_MathCanvas = __esm({
       error
     }) => {
       const eventBus = useEventBus();
+      const fontFamily = resolveGameFontFamily(fontFamilyProp);
       const keyMapKey = keyMap ? JSON.stringify(keyMap) : null;
       const keyUpMapKey = keyUpMap ? JSON.stringify(keyUpMap) : null;
       const stableKeyMap = useMemo(() => keyMap, [keyMapKey]);
@@ -30851,18 +31844,18 @@ var init_MathCanvas = __esm({
           let kx = 0;
           for (let x = Math.ceil(xMin / gridStep) * gridStep; x <= xMax; x += gridStep, kx++) {
             if (kx % labelEveryX === 0 && x !== 0) {
-              out.push({ type: "text", x: mapX(x), y: xAxisY + 12, text: formatTick(x), color: "#6b7280", fontSize: tickLabelFontSize, align: "center" });
+              out.push({ type: "text", fontFamily, x: mapX(x), y: xAxisY + 12, text: formatTick(x), color: "#6b7280", fontSize: tickLabelFontSize, align: "center" });
             }
           }
           const labelEveryY = Math.max(1, Math.ceil((yMax - yMin) / gridStep / Math.floor(plotH / 28)));
           let ky = 0;
           for (let y = Math.ceil(yMin / gridStep) * gridStep; y <= yMax; y += gridStep, ky++) {
             if (ky % labelEveryY === 0 && y !== 0) {
-              out.push({ type: "text", x: yAxisX - 6, y: mapY(y), text: formatTick(y), color: "#6b7280", fontSize: tickLabelFontSize, align: "right" });
+              out.push({ type: "text", fontFamily, x: yAxisX - 6, y: mapY(y), text: formatTick(y), color: "#6b7280", fontSize: tickLabelFontSize, align: "right" });
             }
           }
           if (xMin <= 0 && xMax >= 0 && yMin <= 0 && yMax >= 0) {
-            out.push({ type: "text", x: yAxisX - 6, y: xAxisY + 12, text: "0", color: "#6b7280", fontSize: tickLabelFontSize, align: "right" });
+            out.push({ type: "text", fontFamily, x: yAxisX - 6, y: xAxisY + 12, text: "0", color: "#6b7280", fontSize: tickLabelFontSize, align: "right" });
           }
         }
         for (const region of regions) {
@@ -30889,6 +31882,7 @@ var init_MathCanvas = __esm({
             const mid = Math.floor(region.samples.length / 2);
             out.push({
               type: "text",
+              fontFamily,
               x: mapX((first.x + last.x) / 2),
               y: (mapY(region.samples[mid].y) + mapY(baseline)) / 2,
               text: region.label,
@@ -30925,14 +31919,14 @@ var init_MathCanvas = __esm({
             const px = mapX(guide.at);
             out.push({ type: "line", x1: px, y1: margin, x2: px, y2: height - margin, color, dash });
             if (guide.label) {
-              out.push({ type: "text", x: px + 4, y: margin + 10, text: guide.label, color, fontSize: 11 });
+              out.push({ type: "text", fontFamily, x: px + 4, y: margin + 10, text: guide.label, color, fontSize: 11 });
             }
           } else {
             if (guide.at < yMin || guide.at > yMax) continue;
             const py = mapY(guide.at);
             out.push({ type: "line", x1: margin, y1: py, x2: width - margin, y2: py, color, dash });
             if (guide.label) {
-              out.push({ type: "text", x: width - margin - 4, y: py - 8, text: guide.label, color, fontSize: labelFontSize, align: "right" });
+              out.push({ type: "text", fontFamily, x: width - margin - 4, y: py - 8, text: guide.label, color, fontSize: labelFontSize, align: "right" });
             }
           }
         }
@@ -30971,6 +31965,7 @@ var init_MathCanvas = __esm({
           if (showCurveLabels && curve.label && lastInRange) {
             out.push({
               type: "text",
+              fontFamily,
               x: mapX(lastInRange.x) + 6,
               y: mapY(lastInRange.y) - 6,
               text: curve.label,
@@ -31008,6 +32003,7 @@ var init_MathCanvas = __esm({
           if (hop.label) {
             out.push({
               type: "text",
+              fontFamily,
               x: (x1 + x2) / 2,
               y: xAxisY - peak - 8,
               text: hop.label,
@@ -31035,6 +32031,7 @@ var init_MathCanvas = __esm({
             const rad = mid * Math.PI / 180;
             out.push({
               type: "text",
+              fontFamily,
               x: mapX(angle.x + 1.35 * radius * Math.cos(rad)),
               y: mapY(angle.y + 1.35 * radius * Math.sin(rad)),
               text: angle.label,
@@ -31056,7 +32053,7 @@ var init_MathCanvas = __esm({
             fill: isOpen ? "#ffffff" : p.color ?? "#dc2626"
           });
           if (p.label) {
-            out.push({ type: "text", x: mapX(p.x) + 8, y: mapY(p.y) - 8, text: p.label, color: p.color ?? "#111827", fontSize: labelFontSize });
+            out.push({ type: "text", fontFamily, x: mapX(p.x) + 8, y: mapY(p.y) - 8, text: p.label, color: p.color ?? "#111827", fontSize: labelFontSize });
           }
         }
         for (const v of vectors) {
@@ -31067,7 +32064,7 @@ var init_MathCanvas = __esm({
           const y2 = mapY(v.y + v.vy);
           out.push({ type: "arrow", x1, y1, x2, y2, color: v.color ?? "#7c3aed", lineWidth: 2 });
           if (v.label) {
-            out.push({ type: "text", x: x2 + 6, y: y2 - 6, text: v.label, color: v.color ?? "#7c3aed", fontSize: labelFontSize });
+            out.push({ type: "text", fontFamily, x: x2 + 6, y: y2 - 6, text: v.label, color: v.color ?? "#7c3aed", fontSize: labelFontSize });
           }
         }
         out.push(...shapes);
@@ -31088,6 +32085,7 @@ var init_MathCanvas = __esm({
         showTickLabels,
         tickLabelFontSize,
         labelFontSize,
+        fontFamily,
         showCurveLabels,
         curves,
         points,
@@ -31143,6 +32141,7 @@ var init_MathCanvas = __esm({
             width,
             height,
             backgroundColor,
+            fontFamily,
             shapes: derivedShapes,
             drawables,
             projector,
@@ -32375,13 +33374,13 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect64, useRef: useRef65, useCallback: useCallback93, useState: useState99 } = React87__default;
+      const { useEffect: useEffect67, useRef: useRef69, useCallback: useCallback95, useState: useState102 } = React87__default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus2 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
         const map = useMap();
-        const prevRef = useRef65({ centerLat, centerLng, zoom });
-        useEffect64(() => {
+        const prevRef = useRef69({ centerLat, centerLng, zoom });
+        useEffect67(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
             map.setView([centerLat, centerLng], zoom);
@@ -32392,7 +33391,7 @@ var init_MapView = __esm({
       }
       function MapClickHandler({ onMapClick }) {
         const map = useMap();
-        useEffect64(() => {
+        useEffect67(() => {
           if (!onMapClick) return;
           const handler = (e) => {
             onMapClick(e.latlng.lat, e.latlng.lng);
@@ -32420,8 +33419,8 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus2();
-        const [clickedPosition, setClickedPosition] = useState99(null);
-        const handleMapClick = useCallback93((lat, lng) => {
+        const [clickedPosition, setClickedPosition] = useState102(null);
+        const handleMapClick = useCallback95((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
           }
@@ -32430,7 +33429,7 @@ var init_MapView = __esm({
             eventBus.emit(`UI:${mapClickEvent}`, { latitude: lat, longitude: lng });
           }
         }, [onMapClick, mapClickEvent, eventBus, showClickedPin]);
-        const handleMarkerClick = useCallback93((marker) => {
+        const handleMarkerClick = useCallback95((marker) => {
           onMarkerClick?.(marker);
           if (markerClickEvent) {
             eventBus.emit(`UI:${markerClickEvent}`, { ...marker });
@@ -47010,7 +48009,7 @@ function getAllEvents(traits2) {
 function EventDispatcherTab({ traits: traits2, schema }) {
   const eventBus = useEventBus();
   const { t } = useTranslate();
-  const [log9, setLog] = React87.useState([]);
+  const [log11, setLog] = React87.useState([]);
   const prevStatesRef = React87.useRef(/* @__PURE__ */ new Map());
   React87.useEffect(() => {
     for (const trait of traits2) {
@@ -47074,9 +48073,9 @@ function EventDispatcherTab({ traits: traits2, schema }) {
       /* @__PURE__ */ jsx(Typography, { variant: "small", weight: "medium", className: "text-muted-foreground mb-1", children: t("debug.otherEvents") }),
       /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1", children: unavailableEvents.map((event) => /* @__PURE__ */ jsx(Badge, { variant: "default", size: "sm", className: "opacity-50", children: event }, event)) })
     ] }),
-    log9.length > 0 && /* @__PURE__ */ jsxs("div", { children: [
+    log11.length > 0 && /* @__PURE__ */ jsxs("div", { children: [
       /* @__PURE__ */ jsx(Typography, { variant: "small", weight: "medium", className: "text-muted-foreground mb-1", children: t("debug.recentTransitions") }),
-      /* @__PURE__ */ jsx(Stack, { gap: "xs", children: log9.map((entry, i) => /* @__PURE__ */ jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
+      /* @__PURE__ */ jsx(Stack, { gap: "xs", children: log11.map((entry, i) => /* @__PURE__ */ jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
         /* @__PURE__ */ jsx("span", { className: "text-primary", children: entry.traitName }),
         " ",
         /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: entry.from }),
@@ -49267,6 +50266,7 @@ var init_component_registry_generated = __esm({
     init_FormSection();
     init_FormSectionHeader();
     init_FxOverlay();
+    init_GameAudioCue();
     init_GameAudioToggle();
     init_GameHud();
     init_GameIcon();
@@ -49544,6 +50544,7 @@ var init_component_registry_generated = __esm({
       "FormLayout": FormLayout,
       "FormSectionHeader": FormSectionHeader,
       "FxOverlay": FxOverlay,
+      "GameAudioCue": GameAudioCue,
       "GameAudioToggle": GameAudioToggle,
       "GameHud": GameHud,
       "GameIcon": GameIcon,
@@ -51518,7 +52519,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     };
   }, [traitBindings]);
   const executeTransitionEffects = useCallback(async (params) => {
-    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log9 } = params;
+    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log11 } = params;
     const traitName = binding.trait.name;
     const linkedEntity = binding.linkedEntity || "";
     const entityId = payload?.entityId;
@@ -51647,7 +52648,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         if (sharedKey !== void 0) {
           sharedWrites.push({ field, value });
         }
-        log9.debug("set:write", {
+        log11.debug("set:write", {
           traitName,
           field,
           value: JSON.stringify(value),
@@ -51715,7 +52716,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
           mergeEntityFrame(sharedEntityStore.getSnapshot(sharedKey), sharedWrites)
         );
       }
-      log9.debug("effects:executed", () => ({
+      log11.debug("effects:executed", () => ({
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
@@ -51725,7 +52726,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         slotsTouched: Array.from(pendingSlots.keys()).join(",")
       }));
       for (const [slot, patterns] of pendingSlots) {
-        log9.debug("flush:slot", {
+        log11.debug("flush:slot", {
           traitName,
           slot,
           patternCount: patterns.length,
@@ -51743,7 +52744,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         publishBindingSnapshot(traitName, liveEntity);
       }
     } catch (error) {
-      log9.error("effects:error", {
+      log11.error("effects:error", {
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
@@ -52925,11 +53926,20 @@ function BrowserPlayground({
   mode = "mock",
   initialPagePath,
   height,
-  className
+  className,
+  paused
 }) {
   const [runtime] = useState(
     () => new OrbitalServerRuntime({ mode, debug: false })
   );
+  useEffect(() => {
+    if (paused === void 0) return;
+    if (paused) {
+      runtime.pauseTicks();
+    } else {
+      runtime.resumeTicks();
+    }
+  }, [runtime, paused]);
   const registrationReady = useMemo(() => {
     const orbitalNames = schema.orbitals.map((o) => o.name);
     playgroundLog.debug("register:start", { schema: schema.name, orbitalNames });
@@ -52984,7 +53994,317 @@ function BrowserPlayground({
   );
 }
 
+// runtime/OrbitalPluginHost.tsx
+init_useEventBus();
+var log10 = createLogger("almadar:ui:plugin-host");
+var UI_SLOT_SET = new Set(UI_SLOTS);
+function isUISlot(value) {
+  return UI_SLOT_SET.has(value);
+}
+var OrbitalPluginHostContext = createContext(null);
+function useOrbitalPluginHostContext(caller) {
+  const ctx = useContext(OrbitalPluginHostContext);
+  if (!ctx) {
+    throw new Error(`${caller} must be used within an <OrbitalPluginHost>.`);
+  }
+  return ctx;
+}
+function isTraitState(value) {
+  return value !== void 0 && typeof value.currentState === "string";
+}
+function toTraitState(runtime, orbital, trait, stateName, lastEvent) {
+  if (runtime) {
+    const raw = runtime.getState(orbital, trait);
+    if (isTraitState(raw)) return raw;
+  }
+  return { traitName: trait, currentState: stateName, previousState: null, lastEvent, context: {} };
+}
+function isKeymapValue(value) {
+  if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((entry) => Array.isArray(entry) && entry.every((k) => typeof k === "string"));
+}
+function findInlineTrait(schema, orbitalName, traitName) {
+  const orbital = schema.orbitals.find((o) => o.name === orbitalName);
+  if (!orbital) return void 0;
+  for (const ref of orbital.traits) {
+    if (typeof ref === "string") continue;
+    if ("ref" in ref) continue;
+    if (ref.name === traitName) return ref;
+  }
+  return void 0;
+}
+function readKeymapConfig(trait, knob) {
+  const declared = trait?.config?.[knob]?.default;
+  return isKeymapValue(declared) ? declared : {};
+}
+function traitNamesOf(orbital) {
+  const names = [];
+  for (const ref of orbital.traits) {
+    if (typeof ref === "string") {
+      names.push(ref);
+    } else if ("ref" in ref) {
+      if (ref.name) names.push(ref.name);
+    } else {
+      names.push(ref.name);
+    }
+  }
+  return names;
+}
+function useDeclaredCaptureTable(opts) {
+  const { pluginId, orbital, trait, keymapKnob = "keymap", target = "shell" } = opts;
+  const ctx = useOrbitalPluginHostContext("useDeclaredCaptureTable");
+  return useMemo(() => {
+    const schema = ctx.getPluginSchema(pluginId);
+    const inlineTrait = schema ? findInlineTrait(schema, orbital, trait) : void 0;
+    const keymap = readKeymapConfig(inlineTrait, keymapKnob);
+    const currentState = ctx.getState(pluginId, orbital, trait)?.currentState;
+    const keys = currentState !== void 0 ? keymap[currentState] ?? [] : [];
+    return { [target]: { mode: currentState ?? "unknown", keys: new Set(keys) } };
+  }, [ctx, pluginId, orbital, trait, keymapKnob, target]);
+}
+function useOrbitalPluginHost() {
+  const ctx = useOrbitalPluginHostContext("useOrbitalPluginHost");
+  return { getState: ctx.getState, lastEvent: ctx.lastEvent, errors: ctx.errors };
+}
+function buildMockEffectHandlers(opts) {
+  const { pluginId, denySet, slotsRef, navigateRef, notifyRef } = opts;
+  const handlers = {
+    renderUI: (slot, pattern, props, priority) => {
+      if (!isUISlot(slot)) {
+        log10.warn("renderUI:unknown-slot", { pluginId, slot });
+        return;
+      }
+      if (pattern === null) {
+        slotsRef.current.clear(slot);
+        return;
+      }
+      slotsRef.current.render({ target: slot, pattern: pattern.type, props, priority, sourceTrait: pluginId });
+    }
+  };
+  if (denySet.has("navigate")) {
+    handlers.navigate = (path) => log10.warn("navigate:denied", { pluginId, path });
+  } else if (navigateRef.current) {
+    handlers.navigate = (path) => navigateRef.current?.(path);
+  }
+  if (denySet.has("notify")) {
+    handlers.notify = (message, type) => log10.warn("notify:denied", { pluginId, message, type });
+  } else if (notifyRef.current) {
+    handlers.notify = (message, type) => notifyRef.current?.(message, type);
+  }
+  if (denySet.has("persist")) {
+    handlers.persist = async (action, entityType) => {
+      log10.warn("persist:denied", { pluginId, action, entityType });
+      return void 0;
+    };
+  }
+  if (denySet.has("call-service")) {
+    handlers.callService = async (service, action) => {
+      log10.warn("call-service:denied", { pluginId, service, action });
+      return null;
+    };
+  }
+  return handlers;
+}
+function PluginRuntimeMount({
+  plugin,
+  mode,
+  transport,
+  deny,
+  navigate,
+  notify,
+  onTransition,
+  onDispatched,
+  onError
+}) {
+  const bus = useEventBus();
+  const slots = useUISlots();
+  const slotsRef = useRef(slots);
+  slotsRef.current = slots;
+  const navigateRef = useRef(navigate);
+  navigateRef.current = navigate;
+  const notifyRef = useRef(notify);
+  notifyRef.current = notify;
+  const [mockRuntime] = useState(() => {
+    if (mode !== "mock") return void 0;
+    return new OrbitalServerRuntime({
+      mode: "mock",
+      debug: false,
+      effectHandlers: buildMockEffectHandlers({
+        pluginId: plugin.id,
+        denySet: new Set(deny ?? []),
+        slotsRef,
+        navigateRef,
+        notifyRef
+      })
+    });
+  });
+  const registrationReady = useMemo(() => {
+    if (mockRuntime) return mockRuntime.register(plugin.schema);
+    if (mode === "server" && transport) return transport.register(plugin.schema);
+    return Promise.resolve();
+  }, [mockRuntime, transport, mode, plugin.schema]);
+  useEffect(() => {
+    if (mode === "server" && !transport) {
+      onError(plugin.id, 'OrbitalPluginHost: mode "server" requires a transport');
+    }
+  }, [mode, transport, plugin.id, onError]);
+  const teardownTimerRef = useRef(null);
+  useEffect(() => {
+    if (teardownTimerRef.current !== null) {
+      clearTimeout(teardownTimerRef.current);
+      teardownTimerRef.current = null;
+    }
+    return () => {
+      teardownTimerRef.current = setTimeout(() => {
+        teardownTimerRef.current = null;
+        if (mockRuntime) {
+          mockRuntime.unregisterAll();
+        } else if (mode === "server" && transport) {
+          void transport.unregister();
+        }
+      }, 0);
+    };
+  }, [mockRuntime, transport, mode]);
+  const ownOrbitals = useMemo(
+    () => new Set(plugin.schema.orbitals.map((o) => o.name)),
+    [plugin.schema]
+  );
+  useEffect(() => {
+    let cancelled = false;
+    void registrationReady.then(() => {
+      if (cancelled || !mockRuntime) return;
+      const states = [];
+      for (const orbital of plugin.schema.orbitals) {
+        for (const traitName of traitNamesOf(orbital)) {
+          const raw = mockRuntime.getState(orbital.name, traitName);
+          if (isTraitState(raw)) states.push([orbital.name, traitName, raw]);
+        }
+      }
+      if (states.length > 0) onDispatched(plugin.id, null, states);
+    }).catch((err) => {
+      if (!cancelled) onError(plugin.id, err instanceof Error ? err.message : String(err));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [registrationReady, mockRuntime, plugin, onDispatched, onError]);
+  const dispatch = useCallback(
+    async (row, payload) => {
+      await registrationReady;
+      let response;
+      if (mockRuntime) {
+        response = await mockRuntime.processOrbitalEvent(row.orbital, {
+          event: row.trigger,
+          payload,
+          targetTrait: row.trait
+        });
+      } else if (mode === "server" && transport) {
+        response = await transport.sendEvent(row.orbital, row.trigger, payload);
+      } else {
+        return;
+      }
+      if (!response.success) {
+        onError(plugin.id, response.error ?? `${plugin.id}: ${row.trigger} failed`);
+      }
+      for (const entry of response.emittedEvents ?? []) {
+        if (entry.event === row.trigger) continue;
+        const sourceOrbital = entry.source?.orbital;
+        if (sourceOrbital !== void 0 && ownOrbitals.has(sourceOrbital)) {
+          bus.emit(`UI:${entry.event}`, entry.payload, entry.source);
+        }
+      }
+      const states = [];
+      for (const [traitName, stateName] of Object.entries(response.states)) {
+        states.push([row.orbital, traitName, toTraitState(mockRuntime, row.orbital, traitName, stateName, row.trigger)]);
+        onTransition?.(plugin.id, row.orbital, traitName, stateName);
+      }
+      onDispatched(plugin.id, row.trigger, states);
+    },
+    [registrationReady, mockRuntime, mode, transport, plugin, bus, ownOrbitals, onError, onTransition, onDispatched]
+  );
+  useEffect(() => {
+    const unsubs = plugin.inbound.map(
+      (row) => bus.on(`UI:${row.busEvent}`, (event) => {
+        void dispatch(row, event.payload).catch((err) => {
+          onError(plugin.id, err instanceof Error ? err.message : String(err));
+        });
+      })
+    );
+    return () => {
+      for (const unsub of unsubs) unsub();
+    };
+  }, [bus, plugin, dispatch, onError]);
+  return null;
+}
+function OrbitalPluginHost({
+  plugins,
+  mode = "mock",
+  transport,
+  deny,
+  navigate,
+  notify,
+  onTransition,
+  children
+}) {
+  const [tick, setTick] = useState(0);
+  const [errors, setErrors] = useState({});
+  const statesRef = useRef(/* @__PURE__ */ new Map());
+  const lastEventRef = useRef(/* @__PURE__ */ new Map());
+  const pluginSchemas = useMemo(
+    () => new Map(plugins.map((plugin) => [plugin.id, plugin.schema])),
+    [plugins]
+  );
+  const handleDispatched = useCallback(
+    (pluginId, trigger, states) => {
+      if (trigger !== null) {
+        lastEventRef.current.set(pluginId, trigger);
+      }
+      let byKey = statesRef.current.get(pluginId);
+      if (!byKey) {
+        byKey = /* @__PURE__ */ new Map();
+        statesRef.current.set(pluginId, byKey);
+      }
+      for (const [orbital, trait, state] of states) {
+        byKey.set(`${orbital}.${trait}`, state);
+      }
+      setTick((t) => t + 1);
+    },
+    []
+  );
+  const handleError = useCallback((pluginId, message) => {
+    setErrors((prev) => prev[pluginId] === message ? prev : { ...prev, [pluginId]: message });
+  }, []);
+  const contextValue = useMemo(
+    () => ({
+      getState: (pluginId, orbital, trait) => statesRef.current.get(pluginId)?.get(`${orbital}.${trait}`),
+      lastEvent: (pluginId) => lastEventRef.current.get(pluginId),
+      errors,
+      tick,
+      getPluginSchema: (pluginId) => pluginSchemas.get(pluginId)
+    }),
+    [errors, tick, pluginSchemas]
+  );
+  return /* @__PURE__ */ jsxs(OrbitalPluginHostContext.Provider, { value: contextValue, children: [
+    plugins.map((plugin) => /* @__PURE__ */ jsx(
+      PluginRuntimeMount,
+      {
+        plugin,
+        mode,
+        transport,
+        deny,
+        navigate,
+        notify,
+        onTransition,
+        onDispatched: handleDispatched,
+        onError: handleError
+      },
+      plugin.id
+    )),
+    children ?? null
+  ] });
+}
+
 // runtime/index.ts
 init_perf();
 
-export { BrowserPlayground, OrbPreview, clearSchemaCache, createClientEffectHandlers, profilerOnRender, usePerfBuffer, useResolvedSchema, useTraitStateMachine };
+export { BrowserPlayground, OrbPreview, OrbitalPluginHost, clearSchemaCache, createClientEffectHandlers, profilerOnRender, useDeclaredCaptureTable, useOrbitalPluginHost, usePerfBuffer, useResolvedSchema, useTraitStateMachine };