@almadar/ui 6.5.0 → 6.7.0

package/dist/avl/index.cjs

@@ -13787,7 +13787,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":
@@ -13797,7 +13797,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":
@@ -13817,15 +13817,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 r2 = spriteRect(projector, { position: it.pos, anchor: it.anchor, width: it.width, height: it.height });
-    if (point.x >= r2.x && point.x <= r2.x + r2.w && point.y >= r2.y && point.y <= r2.y + r2.h) return it.id;
+    const test = it.rotation ? rotatePoint(point, { x: r2.x + r2.w / 2, y: r2.y + r2.h / 2 }, -it.rotation) : point;
+    if (test.x >= r2.x && test.x <= r2.x + r2.w && test.y >= r2.y && test.y <= r2.y + r2.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();
@@ -13834,6 +13858,41 @@ var init_hitTest = __esm({
 function normalizeBackdrop(bg) {
   return typeof bg === "string" ? { url: bg, role: "decoration", category: "background" } : bg;
 }
+function selectionOverlayNodes(projector, item) {
+  const r2 = 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 = (r2.x - cellTopLeft.x) / tw;
+  const offsetY = (r2.y - cellTopLeft.y) / tw;
+  const width = r2.w / tw;
+  const height = r2.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,
@@ -13847,6 +13906,12 @@ function Canvas2D({
   tileLeaveEvent,
   keyMap,
   keyUpMap,
+  editable = false,
+  selectedId = null,
+  onSelect,
+  onMove,
+  selectEvent,
+  moveEvent,
   camera = "pan-zoom",
   scale = 0.4,
   tileWidth,
@@ -14104,10 +14169,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]);
   React96.useEffect(() => {
     drawTimeRef.current = draw;
   }, [draw]);
@@ -14152,23 +14229,83 @@ function Canvas2D({
     };
   }, [camera, followTarget, lerpToTarget, draw]);
   const singlePointerActiveRef = React96.useRef(false);
+  const editDragRef = React96.useRef(null);
+  const pointerToScene = React96.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 = React96.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 = React96.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 = React96.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 = React96.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;
@@ -14179,16 +14316,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 = React96.useCallback(() => {
     handleMouseLeave();
     if (tileLeaveEvent) eventBus.emit(`UI:${tileLeaveEvent}`, {});
@@ -14207,7 +14342,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,
@@ -14339,7 +14474,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";
@@ -14364,8 +14499,12 @@ var init_Canvas2D = __esm({
     init_DrawGroup();
     init_registry();
     init_hitTest();
+    init_contract();
     init_isometric();
     canvas2DLog = logger.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";
   }
 });
@@ -14407,6 +14546,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 });
@@ -14484,6 +14629,12 @@ function Canvas({
       tileLeaveEvent,
       keyMap,
       keyUpMap,
+      editable,
+      selectedId,
+      onSelect,
+      onMove,
+      selectEvent,
+      moveEvent,
       ...children !== void 0 ? { children } : {}
     }
   );
@@ -14505,15 +14656,19 @@ function GameAudioToggle({
   size = "sm",
   className,
   onAsset,
-  offAsset
+  offAsset,
+  toggleEvent
 }) {
   const ctx = providers.useGameAudioContextOptional();
   const [localMuted, setLocalMuted] = React96.useState(false);
   const muted = ctx ? ctx.muted : localMuted;
   const setMuted = ctx ? ctx.setMuted : setLocalMuted;
+  const eventBus = useEventBus();
   const handleToggle = React96.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__ */ jsxRuntime.jsx(
     Button,
@@ -14532,10 +14687,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] = React96.useState(initialMuted);
+  const [masterVolume, setMasterVolumeState] = React96.useState(initialVolume);
+  const mutedRef = React96.useRef(muted);
+  const volumeRef = React96.useRef(masterVolume);
+  const manifestRef = React96.useRef(manifest);
+  mutedRef.current = muted;
+  volumeRef.current = masterVolume;
+  manifestRef.current = manifest;
+  const poolsRef = React96.useRef(/* @__PURE__ */ new Map());
+  const getOrCreateElement = React96.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 = React96.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 = React96.useCallback((key) => {
+    const pool = poolsRef.current.get(key);
+    if (!pool) return;
+    for (const audio of pool) {
+      audio.pause();
+      audio.currentTime = 0;
+    }
+  }, []);
+  const currentMusicKeyRef = React96.useRef(null);
+  const currentMusicElRef = React96.useRef(null);
+  const musicFadeRef = React96.useRef(null);
+  const pendingMusicKeyRef = React96.useRef(null);
+  const clearMusicFade = React96.useCallback(() => {
+    if (musicFadeRef.current) {
+      clearInterval(musicFadeRef.current);
+      musicFadeRef.current = null;
+    }
+  }, []);
+  const playMusic = React96.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 = React96.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 = React96.useCallback(() => {
+    for (const pool of poolsRef.current.values()) {
+      for (const audio of pool) {
+        audio.pause();
+        audio.currentTime = 0;
+      }
+    }
+    stopMusic(0);
+  }, [stopMusic]);
+  const setMuted = React96.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 = React96.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 = React96.useRef(false);
+  React96.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]);
+  React96.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 = React96.useRef(cueSeq);
+  React96.useEffect(() => {
+    if (cue && cueSeq !== void 0 && cueSeq !== prevCueSeqRef.current) {
+      play(cue);
+    }
+    prevCueSeqRef.current = cueSeq;
+  }, [cue, cueSeq, play]);
+  React96.useEffect(() => {
+    if (music) playMusic(music);
+    else stopMusic();
+  }, [music, playMusic, stopMusic]);
+  React96.useEffect(() => {
+    if (muted !== void 0) setMuted(muted);
+  }, [muted, setMuted]);
+  React96.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;
 }
@@ -15234,15 +15698,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",
@@ -15250,6 +15717,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,
@@ -15263,7 +15741,7 @@ var init_GameShell = __esm({
       fontFamily,
       "data-theme": dataTheme
     }) => {
-      const font = fontFamily ? GAME_FONTS[fontFamily] ?? fontFamily : void 0;
+      const displayFont = resolveGameFontFamily(fontFamily);
       return /* @__PURE__ */ jsxRuntime.jsxs(
         Box,
         {
@@ -15282,7 +15760,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__ */ jsxRuntime.jsx(
@@ -15493,14 +15971,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;
@@ -15622,7 +16101,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);
@@ -15664,7 +16143,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;
@@ -15688,13 +16167,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;
@@ -15748,14 +16228,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;
 }
@@ -15778,13 +16258,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,
@@ -15820,10 +16301,10 @@ var init_LearningCanvas = __esm({
       }, [shapes]);
       const derivedShapes = React96.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 = React96.useCallback(() => {
         const _perfT = ui.perfStart("learningcanvas:paint");
         const canvas = canvasRef.current;
@@ -15842,15 +16323,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);
           }
@@ -19622,6 +20103,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] = React96.useState("bar");
+  const registerRef = React96.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);
 }
@@ -19707,7 +20432,36 @@ function useLanguageReady(language) {
   }, [language]);
   return ready;
 }
-var dynamicallyLoaded, codeLanguageLoader, orbStyleOverrides, orbStyle, loloStyleOverrides, loloStyle, log4, 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__default.default;
+}
+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, log4, 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();
@@ -19723,6 +20477,7 @@ var init_CodeBlock = __esm({
     init_Textarea();
     init_Icon();
     init_useEventBus();
+    init_useEditorCapabilities();
     SyntaxHighlighter__default.default.registerLanguage("json", langJson__default.default);
     SyntaxHighlighter__default.default.registerLanguage("javascript", langJavascript__default.default);
     SyntaxHighlighter__default.default.registerLanguage("js", langJavascript__default.default);
@@ -19941,6 +20696,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 = React96__namespace.default.memo(
       ({
         code: rawCode,
@@ -19965,15 +20729,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__default.default;
+        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 } = hooks.useTranslate();
         const scrollRef = React96.useRef(null);
@@ -19985,6 +20773,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 = React96.useMemo(() => {
           if (propDiff) return propDiff;
           if (mode === "diff" && oldValue !== void 0 && newValue !== void 0) {
@@ -20014,28 +20805,28 @@ var init_CodeBlock = __esm({
             ov.scrollLeft = ta.scrollLeft;
           }
         }, []);
-        const errorLineProps = React96.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 = React96.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] = React96.useState(0);
+        const caretRowCol = React96.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 = React96.useMemo(() => buildLineProps(errorLines), [errorLines]);
+        const viewerLineProps = React96.useMemo(
+          () => buildLineProps(errorLines, "px-4 py-0.5 hover:bg-muted/50"),
+          [errorLines]
+        );
         const isFoldable = foldableProp ?? true;
         const [collapsed, setCollapsed] = React96.useState(() => /* @__PURE__ */ new Set());
         const foldRegions = React96.useMemo(
@@ -20158,6 +20949,110 @@ var init_CodeBlock = __esm({
           ),
           [code, overCapacity, plainCodeColor, language, activeStyle, languageReady]
         );
+        const viewerOverCapacity = activeCode.length > HIGHLIGHT_CAPACITY_BYTES;
+        const viewerHighlightedElement = React96.useMemo(
+          () => viewerOverCapacity ? /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
+            SyntaxHighlighter__default.default,
+            {
+              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 = React96.useMemo(
+          () => !!diffLines && diffLines.reduce((n, l) => n + l.content.length + 1, 0) > HIGHLIGHT_CAPACITY_BYTES,
+          [diffLines]
+        );
+        const diffRowElements = React96.useMemo(() => {
+          if (!diffLines) return null;
+          return diffLines.map((line, idx) => {
+            const style = DIFF_STYLES[line.type] ?? DIFF_STYLE_FALLBACK;
+            return /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "none", align: "start", className: cn(style.bg, "px-4 py-0.5"), children: [
+              showLineNumbers && /* @__PURE__ */ jsxRuntime.jsx(
+                Typography,
+                {
+                  variant: "caption",
+                  color: "secondary",
+                  className: "w-8 text-right mr-3 select-none tabular-nums flex-shrink-0",
+                  children: line.lineNumber ?? ""
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(Box, { as: "span", className: "select-none opacity-50 mr-2", children: style.prefix }),
+                    diffOverCapacity ? line.content || " " : /* @__PURE__ */ jsxRuntime.jsx(
+                      SyntaxHighlighter__default.default,
+                      {
+                        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]);
         React96.useLayoutEffect(() => {
           const container = codeRef.current;
           if (!container) return;
@@ -20301,7 +21196,6 @@ var init_CodeBlock = __esm({
             label: file.label,
             content: null
           }));
-          const lines = activeCode.split("\n");
           return /* @__PURE__ */ jsxRuntime.jsx(Card, { className: cn("overflow-hidden", className), children: /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", flexDirection: "column" }, children: [
             tabItems && tabItems.length > 1 && /* @__PURE__ */ jsxRuntime.jsx(Box, { className: "border-b border-border", children: /* @__PURE__ */ jsxRuntime.jsx(
               Tabs,
@@ -20364,49 +21258,7 @@ var init_CodeBlock = __esm({
                 ]
               }
             ),
-            /* @__PURE__ */ jsxRuntime.jsx(Box, { className: "overflow-auto bg-muted/20", style: { maxHeight }, children: diffLines ? /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(HStack, { gap: "none", align: "start", className: cn(style.bg, "px-4 py-0.5"), children: [
-                showLineNumbers && /* @__PURE__ */ jsxRuntime.jsx(
-                  Typography,
-                  {
-                    variant: "caption",
-                    color: "secondary",
-                    className: "w-8 text-right mr-3 select-none tabular-nums flex-shrink-0",
-                    children: line.lineNumber ?? ""
-                  }
-                ),
-                /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(Box, { as: "span", className: "select-none opacity-50 mr-2", children: style.prefix }),
-                      line.content
-                    ]
-                  }
-                )
-              ] }, idx);
-            }) }) : /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column" }, className: "font-mono text-xs", children: lines.map((line, idx) => /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "none", align: "start", className: "px-4 py-0.5 hover:bg-muted/50", children: [
-              showLineNumbers && /* @__PURE__ */ jsxRuntime.jsx(
-                Typography,
-                {
-                  variant: "caption",
-                  color: "secondary",
-                  className: "w-8 text-right mr-4 select-none tabular-nums flex-shrink-0",
-                  children: idx + 1
-                }
-              ),
-              /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(Box, { className: "overflow-auto bg-muted/20", style: { maxHeight }, children: diffLines ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column" }, className: "font-mono text-xs", children: diffRowElements }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-mono text-xs", children: viewerHighlightedElement }) })
           ] }) });
         }
         const hasHeader = showLanguageBadge || effectiveCopy;
@@ -20493,13 +21345,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",
@@ -20514,7 +21364,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",
@@ -20525,6 +21375,22 @@ var init_CodeBlock = __esm({
                       }
                     },
                     editableTextareaKey
+                  ),
+                  caretMode !== "bar" && /* @__PURE__ */ jsxRuntime.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"
+                      }
+                    }
                   )
                 ]
               }
@@ -20552,55 +21418,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 log5, mermaidModule, MermaidDiagram;
 var init_MermaidDiagram = __esm({
   "components/core/molecules/markdown/MermaidDiagram.tsx"() {
     init_Box();
     init_Typography();
     init_CodeBlock();
+    init_mermaidSource();
     init_cn();
+    log5 = logger.createLogger("almadar:ui:mermaid-diagram");
     mermaidModule = null;
     MermaidDiagram = React96__namespace.default.memo(
       ({ code, className }) => {
         const { resolvedMode } = context.useTheme();
+        const { t } = hooks.useTranslate();
         const containerRef = React96.useRef(null);
-        const [error, setError] = React96.useState(null);
+        const [unrenderable, setUnrenderable] = React96.useState(false);
         const reactId = React96.useId();
         React96.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) log5.debug("mermaid:repaired", { candidate: index });
+                return;
+              } catch (err) {
+                firstError ?? (firstError = err instanceof Error ? err : new Error(String(err)));
+              }
             }
+            if (!active) return;
+            log5.warn("mermaid:unrenderable", { error: firstError?.message ?? "", code });
+            setUnrenderable(true);
           })();
           return () => {
             active = false;
           };
         }, [code, resolvedMode, reactId]);
         return /* @__PURE__ */ jsxRuntime.jsxs(Box, { className: cn("not-prose my-4", className), children: [
-          error !== null && /* @__PURE__ */ jsxRuntime.jsxs(Box, { className: "space-y-2 mb-2", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "caption", className: "text-error whitespace-pre-wrap", children: error }),
+          unrenderable && /* @__PURE__ */ jsxRuntime.jsxs(Box, { className: "space-y-2 mb-2", "data-testid": "mermaid-unrenderable", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "caption", className: "text-muted-foreground", children: t("mermaid.unrenderable") }),
             /* @__PURE__ */ jsxRuntime.jsx(CodeBlock, { code, language: "mermaid" })
           ] }),
           /* @__PURE__ */ jsxRuntime.jsx(
@@ -20609,7 +21595,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
             }
           )
         ] });
@@ -24014,14 +25000,14 @@ function useSafeEventBus2() {
     } };
   }
 }
-var log5, lookStyles4, ButtonGroup;
+var log6, lookStyles4, ButtonGroup;
 var init_ButtonGroup = __esm({
   "components/core/molecules/ButtonGroup.tsx"() {
     "use client";
     init_cn();
     init_atoms();
     init_useEventBus();
-    log5 = logger.createLogger("almadar:ui:button-group");
+    log6 = logger.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",
@@ -24102,7 +25088,7 @@ var init_ButtonGroup = __esm({
           {
             variant: "ghost",
             onClick: () => {
-              log5.debug("Filter clicked", { field: filter.field });
+              log6.debug("Filter clicked", { field: filter.field });
             },
             children: filter.label
           },
@@ -26886,6 +27872,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"() {
@@ -26940,9 +27932,7 @@ var init_CommandPalette = __esm({
       const handleSelect = React96.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]
@@ -31921,9 +32911,9 @@ function debug(...args) {
   const [first, ...rest] = args;
   const message = typeof first === "string" ? first : "<debug>";
   if (rest.length === 0 && typeof first === "string") {
-    log6.debug(message);
+    log7.debug(message);
   } else {
-    log6.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
+    log7.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
   }
 }
 function debugGroup(label) {
@@ -31951,11 +32941,11 @@ function toLogMetaValue(v) {
   }
   return String(v);
 }
-var NAMESPACE, log6;
+var NAMESPACE, log7;
 var init_debug = __esm({
   "lib/debug.ts"() {
     NAMESPACE = "almadar:ui:debug";
-    log6 = logger.createLogger(NAMESPACE);
+    log7 = logger.createLogger(NAMESPACE);
     logger.createLogger("almadar:ui:debug:input");
     logger.createLogger("almadar:ui:debug:collision");
     logger.createLogger("almadar:ui:debug:physics");
@@ -33608,6 +34598,7 @@ var init_MathCanvas = __esm({
     init_perf();
     init_atoms();
     init_Stack();
+    init_gameFonts();
     init_LearningCanvas();
     MathCanvas = ({
       className,
@@ -33627,6 +34618,7 @@ var init_MathCanvas = __esm({
       showTickLabels = false,
       tickLabelFontSize = 10,
       labelFontSize = 12,
+      fontFamily: fontFamilyProp,
       showCurveLabels = false,
       curves = [],
       points = [],
@@ -33649,6 +34641,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 = React96.useMemo(() => keyMap, [keyMapKey]);
@@ -33698,18 +34691,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) {
@@ -33736,6 +34729,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,
@@ -33772,14 +34766,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" });
             }
           }
         }
@@ -33818,6 +34812,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,
@@ -33855,6 +34850,7 @@ var init_MathCanvas = __esm({
           if (hop.label) {
             out.push({
               type: "text",
+              fontFamily,
               x: (x1 + x2) / 2,
               y: xAxisY - peak - 8,
               text: hop.label,
@@ -33882,6 +34878,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,
@@ -33903,7 +34900,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) {
@@ -33914,7 +34911,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);
@@ -33935,6 +34932,7 @@ var init_MathCanvas = __esm({
         showTickLabels,
         tickLabelFontSize,
         labelFontSize,
+        fontFamily,
         showCurveLabels,
         curves,
         points,
@@ -33990,6 +34988,7 @@ var init_MathCanvas = __esm({
             width,
             height,
             backgroundColor,
+            fontFamily,
             shapes: derivedShapes,
             drawables,
             projector,
@@ -35222,13 +36221,13 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect68, useRef: useRef67, useCallback: useCallback99, useState: useState107 } = React96__namespace.default;
+      const { useEffect: useEffect70, useRef: useRef70, useCallback: useCallback100, useState: useState109 } = React96__namespace.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 = useRef67({ centerLat, centerLng, zoom });
-        useEffect68(() => {
+        const prevRef = useRef70({ centerLat, centerLng, zoom });
+        useEffect70(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
             map.setView([centerLat, centerLng], zoom);
@@ -35239,7 +36238,7 @@ var init_MapView = __esm({
       }
       function MapClickHandler({ onMapClick }) {
         const map = useMap();
-        useEffect68(() => {
+        useEffect70(() => {
           if (!onMapClick) return;
           const handler = (e) => {
             onMapClick(e.latlng.lat, e.latlng.lng);
@@ -35267,8 +36266,8 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus2();
-        const [clickedPosition, setClickedPosition] = useState107(null);
-        const handleMapClick = useCallback99((lat, lng) => {
+        const [clickedPosition, setClickedPosition] = useState109(null);
+        const handleMapClick = useCallback100((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
           }
@@ -35277,7 +36276,7 @@ var init_MapView = __esm({
             eventBus.emit(`UI:${mapClickEvent}`, { latitude: lat, longitude: lng });
           }
         }, [onMapClick, mapClickEvent, eventBus, showClickedPin]);
-        const handleMarkerClick = useCallback99((marker) => {
+        const handleMarkerClick = useCallback100((marker) => {
           onMarkerClick?.(marker);
           if (markerClickEvent) {
             eventBus.emit(`UI:${markerClickEvent}`, { ...marker });
@@ -49586,7 +50585,7 @@ function getAllEvents(traits2) {
 function EventDispatcherTab({ traits: traits2, schema }) {
   const eventBus = useEventBus();
   const { t } = hooks.useTranslate();
-  const [log11, setLog] = React96__namespace.useState([]);
+  const [log12, setLog] = React96__namespace.useState([]);
   const prevStatesRef = React96__namespace.useRef(/* @__PURE__ */ new Map());
   React96__namespace.useEffect(() => {
     for (const trait of traits2) {
@@ -49650,9 +50649,9 @@ function EventDispatcherTab({ traits: traits2, schema }) {
       /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "medium", className: "text-muted-foreground mb-1", children: t("debug.otherEvents") }),
       /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap gap-1", children: unavailableEvents.map((event) => /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "default", size: "sm", className: "opacity-50", children: event }, event)) })
     ] }),
-    log11.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+    log12.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
       /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "medium", className: "text-muted-foreground mb-1", children: t("debug.recentTransitions") }),
-      /* @__PURE__ */ jsxRuntime.jsx(Stack, { gap: "xs", children: log11.map((entry, i) => /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Stack, { gap: "xs", children: log12.map((entry, i) => /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-primary", children: entry.traitName }),
         " ",
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: entry.from }),
@@ -51843,6 +52842,7 @@ var init_component_registry_generated = __esm({
     init_FormSection();
     init_FormSectionHeader();
     init_FxOverlay();
+    init_GameAudioCue();
     init_GameAudioToggle();
     init_GameHud();
     init_GameIcon();
@@ -52120,6 +53120,7 @@ var init_component_registry_generated = __esm({
       "FormLayout": FormLayout,
       "FormSectionHeader": FormSectionHeader,
       "FxOverlay": FxOverlay,
+      "GameAudioCue": GameAudioCue,
       "GameAudioToggle": GameAudioToggle,
       "GameHud": GameHud,
       "GameIcon": GameIcon,
@@ -52568,7 +53569,9 @@ function UISlotComponentInner({
   className,
   children,
   pattern,
-  sourceTrait
+  sourceTrait,
+  fallback,
+  mode = "replace"
 }) {
   const { slots, clear } = context.useUISlots();
   const eventBus = useEventBus();
@@ -52620,12 +53623,26 @@ function UISlotComponentInner({
     );
   }
   if (!content) {
+    if (fallback !== void 0) {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Box,
+        {
+          id: `slot-${slot}`,
+          className: cn("ui-slot", `ui-slot-${slot}`, className),
+          "data-testid": `ui-slot-${slot}`,
+          "data-slot-mode": "fallback",
+          children: fallback
+        }
+      );
+    }
     if (!portal) {
       return /* @__PURE__ */ jsxRuntime.jsx(
         Box,
         {
           id: `slot-${slot}`,
-          className: cn("ui-slot", `ui-slot-${slot}`, className)
+          className: cn("ui-slot", `ui-slot-${slot}`, className),
+          "data-testid": `ui-slot-${slot}`,
+          "data-slot-mode": "empty"
         }
       );
     }
@@ -52642,29 +53659,51 @@ function UISlotComponentInner({
     clear(slot);
   };
   if (portal) {
-    if (contained) {
-      return renderContainedPortal(t, slot, content, handleDismiss);
-    }
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      SlotPortal,
+    const inlineFallback = mode === "append" && fallback !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+      Box,
       {
-        slot,
-        content,
-        position,
-        onDismiss: handleDismiss
+        id: `slot-${slot}-fallback`,
+        className: cn("ui-slot", `ui-slot-${slot}-fallback`, className),
+        "data-testid": `ui-slot-${slot}-fallback`,
+        "data-slot-mode": "append",
+        children: fallback
       }
-    );
+    ) : null;
+    if (contained) {
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        inlineFallback,
+        renderContainedPortal(t, slot, content, handleDismiss)
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      inlineFallback,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        SlotPortal,
+        {
+          slot,
+          content,
+          position,
+          onDismiss: handleDismiss
+        }
+      )
+    ] });
   }
   const slotContent = /* @__PURE__ */ jsxRuntime.jsx(SlotContentRenderer, { content, onDismiss: handleDismiss });
   const wrappedContent = suspenseConfig.enabled ? /* @__PURE__ */ jsxRuntime.jsx(ErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx(React96.Suspense, { fallback: getSlotFallback(slot, suspenseConfig), children: slotContent }) }) : /* @__PURE__ */ jsxRuntime.jsx(ErrorBoundary, { children: slotContent });
-  return /* @__PURE__ */ jsxRuntime.jsx(
+  const showFallback = mode === "append" && fallback !== void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
     Box,
     {
       id: `slot-${slot}`,
       className: cn("ui-slot", `ui-slot-${slot}`, className),
       "data-pattern": content.pattern,
       "data-source-trait": content.sourceTrait,
-      children: /* @__PURE__ */ jsxRuntime.jsx(MaybeTraitScope, { sourceTrait: content.sourceTrait, children: wrappedContent })
+      "data-testid": `ui-slot-${slot}`,
+      "data-slot-mode": showFallback ? "append" : "content",
+      children: [
+        showFallback ? fallback : null,
+        /* @__PURE__ */ jsxRuntime.jsx(MaybeTraitScope, { sourceTrait: content.sourceTrait, children: wrappedContent })
+      ]
     }
   );
 }
@@ -56916,7 +57955,7 @@ function convertFnFormLambdasInProps(props) {
 
 // hooks/index.ts
 init_useEventBus();
-var log7 = logger.createLogger("almadar:ui:shared-entity-store");
+var log8 = logger.createLogger("almadar:ui:shared-entity-store");
 var EMPTY_ENTITY_STATE = {};
 function createSharedEntityStore() {
   const states = /* @__PURE__ */ new Map();
@@ -56946,7 +57985,7 @@ function createSharedEntityStore() {
       try {
         callback();
       } catch (error) {
-        log7.error("Shared entity subscriber error", {
+        log8.error("Shared entity subscriber error", {
           entityId,
           error: error instanceof Error ? error : String(error)
         });
@@ -56977,7 +58016,7 @@ function runTickFrame(entityId, orderedWriters, store) {
   store.commit(entityId, scratch);
   return scratch;
 }
-var log8 = logger.createLogger("almadar:ui:effects:client-handlers");
+var log9 = logger.createLogger("almadar:ui:effects:client-handlers");
 function createClientEffectHandlers(options) {
   const { eventBus, slotSetter, navigate, navigateBack, notify, callService, liveEntity } = options;
   return {
@@ -56986,12 +58025,12 @@ function createClientEffectHandlers(options) {
       eventBus.emit(prefixedEvent, payload, source);
     },
     persist: async () => {
-      log8.warn("persist is server-side only, ignored on client");
+      log9.warn("persist is server-side only, ignored on client");
     },
     // @almadar/runtime EffectHandlers.set types value:unknown — should be FieldValue (upstream fix queued)
     set: ((_entityId, field, value) => {
       if (!liveEntity) {
-        log8.warn("set is server-side only, ignored on client (no live entity)");
+        log9.warn("set is server-side only, ignored on client (no live entity)");
         return;
       }
       liveEntity[field] = value;
@@ -57027,13 +58066,13 @@ function createClientEffectHandlers(options) {
         window.location.href = path;
         return;
       }
-      log8.warn("No navigate handler, ignoring", { path });
+      log9.warn("No navigate handler, ignoring", { path });
     }),
     navigateBack: navigateBack ?? (() => {
-      log8.warn("No navigate-back handler, ignoring");
+      log9.warn("No navigate-back handler, ignoring");
     }),
     notify: notify ?? ((msg, type) => {
-      log8.debug("notify", { type, message: msg });
+      log9.debug("notify", { type, message: msg });
     })
   };
 }
@@ -57468,7 +58507,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     };
   }, [traitBindings]);
   const executeTransitionEffects = React96.useCallback(async (params) => {
-    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log11 } = params;
+    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log12 } = params;
     const traitName = binding.trait.name;
     const linkedEntity = binding.linkedEntity || "";
     const entityId = payload?.entityId;
@@ -57597,7 +58636,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         if (sharedKey !== void 0) {
           sharedWrites.push({ field, value });
         }
-        log11.debug("set:write", {
+        log12.debug("set:write", {
           traitName,
           field,
           value: JSON.stringify(value),
@@ -57665,7 +58704,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
           core.mergeEntityFrame(sharedEntityStore.getSnapshot(sharedKey), sharedWrites)
         );
       }
-      log11.debug("effects:executed", () => ({
+      log12.debug("effects:executed", () => ({
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
@@ -57675,7 +58714,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         slotsTouched: Array.from(pendingSlots.keys()).join(",")
       }));
       for (const [slot, patterns] of pendingSlots) {
-        log11.debug("flush:slot", {
+        log12.debug("flush:slot", {
           traitName,
           slot,
           patternCount: patterns.length,
@@ -57693,7 +58732,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         publishBindingSnapshot(traitName, liveEntity);
       }
     } catch (error) {
-      log11.error("effects:error", {
+      log12.error("effects:error", {
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
@@ -58772,11 +59811,20 @@ function BrowserPlayground({
   mode = "mock",
   initialPagePath,
   height,
-  className
+  className,
+  paused
 }) {
   const [runtime] = React96.useState(
     () => new OrbitalServerRuntime.OrbitalServerRuntime({ mode, debug: false })
   );
+  React96.useEffect(() => {
+    if (paused === void 0) return;
+    if (paused) {
+      runtime.pauseTicks();
+    } else {
+      runtime.resumeTicks();
+    }
+  }, [runtime, paused]);
   const registrationReady = React96.useMemo(() => {
     const orbitalNames = schema.orbitals.map((o) => o.name);
     playgroundLog.debug("register:start", { schema: schema.name, orbitalNames });
@@ -58837,7 +59885,7 @@ init_useEventBus();
 // components/avl/hooks/useCanvasDnd.tsx
 init_useEventBus();
 init_useAlmadarDndCollision();
-var log9 = logger.createLogger("almadar:ui:canvas-dnd");
+var log10 = logger.createLogger("almadar:ui:canvas-dnd");
 function useCanvasDraggable({
   id,
   payload,
@@ -58875,7 +59923,7 @@ function defaultEmit(eventBus, drop) {
   if (payload.kind === "pattern") {
     const patternType = payload.data["type"];
     if (typeof patternType !== "string") {
-      log9.warn("default-emit:pattern:missing-type");
+      log10.warn("default-emit:pattern:missing-type");
       return;
     }
     const out = { patternType, containerNode: target.containerNode };
@@ -58884,26 +59932,26 @@ function defaultEmit(eventBus, drop) {
       out.index = resolved.index;
     }
     eventBus.emit("UI:PATTERN_DROP", out);
-    log9.info("default-emit:pattern", { patternType, level: target.level });
+    log10.info("default-emit:pattern", { patternType, level: target.level });
     return;
   }
   if (payload.kind === "behavior") {
     const behaviorName = payload.data["name"];
     if (typeof behaviorName !== "string") {
-      log9.warn("default-emit:behavior:missing-name");
+      log10.warn("default-emit:behavior:missing-name");
       return;
     }
     eventBus.emit("UI:BEHAVIOR_DROP", {
       behaviorName,
       containerNode: target.containerNode
     });
-    log9.info("default-emit:behavior", { behaviorName, level: target.level });
+    log10.info("default-emit:behavior", { behaviorName, level: target.level });
     return;
   }
   if (payload.kind === "pattern-instance") {
     const fromPath = payload.data["fromPath"];
     if (typeof fromPath !== "string") {
-      log9.warn("default-emit:pattern-instance:missing-fromPath");
+      log10.warn("default-emit:pattern-instance:missing-fromPath");
       return;
     }
     const out = { fromPath, loc: payload.data["loc"] };
@@ -58912,10 +59960,10 @@ function defaultEmit(eventBus, drop) {
       out.toIndex = resolved.index;
     }
     eventBus.emit("UI:PATTERN_MOVE", out);
-    log9.info("default-emit:pattern-instance", { fromPath, level: target.level });
+    log10.info("default-emit:pattern-instance", { fromPath, level: target.level });
     return;
   }
-  log9.debug("default-emit:unhandled-kind", { kind: payload.kind });
+  log10.debug("default-emit:unhandled-kind", { kind: payload.kind });
 }
 function CanvasDndProvider({
   children,
@@ -58938,9 +59986,9 @@ function CanvasDndProvider({
     if (payload) {
       setActivePayload(payload);
       eventBus.emit("UI:DRAG_START", { kind: payload.kind, data: payload.data });
-      log9.info("dragStart", { id: e.active.id, kind: payload.kind });
+      log10.info("dragStart", { id: e.active.id, kind: payload.kind });
     } else {
-      log9.warn("dragStart:missing-payload", { id: e.active.id });
+      log10.warn("dragStart:missing-payload", { id: e.active.id });
     }
   }, [eventBus, trackPointer]);
   const handleDragEnd = React96__namespace.default.useCallback((e) => {
@@ -58951,7 +59999,7 @@ function CanvasDndProvider({
     const overData = e.over?.data.current;
     const target = overData?.target;
     const accepts = overData?.accepts;
-    log9.info("dragEnd", {
+    log10.info("dragEnd", {
       activeId: e.active.id,
       overId: e.over?.id,
       hasPayload: !!payload,
@@ -58963,12 +60011,12 @@ function CanvasDndProvider({
     }
     if (!payload || !target) return;
     if (accepts && !accepts.includes(payload.kind)) {
-      log9.debug("dragEnd:rejected:kind", { kind: payload.kind, accepts: [...accepts] });
+      log10.debug("dragEnd:rejected:kind", { kind: payload.kind, accepts: [...accepts] });
       return;
     }
     const cursor = lastPointerRef.current;
     const resolved = target.resolvePath && cursor ? target.resolvePath(cursor) : null;
-    log9.debug("dragEnd:resolve", {
+    log10.debug("dragEnd:resolve", {
       hasResolver: !!target.resolvePath,
       cursorX: cursor?.x,
       cursorY: cursor?.y,
@@ -58982,7 +60030,7 @@ function CanvasDndProvider({
   const handleDragCancel = React96__namespace.default.useCallback(() => {
     setActivePayload(null);
     document.removeEventListener("pointermove", trackPointer);
-    log9.info("dragCancel");
+    log10.info("dragCancel");
   }, [trackPointer]);
   return /* @__PURE__ */ jsxRuntime.jsxs(
     core$1.DndContext,
@@ -61042,7 +62090,7 @@ init_AvlTransitionLane();
 init_AvlSwimLane();
 init_avl_atom_types();
 init_avl_elk_layout();
-var log10 = logger.createLogger("almadar:ui:avl:trait-scene");
+var log11 = logger.createLogger("almadar:ui:avl:trait-scene");
 var SWIM_GUTTER2 = 120;
 var CENTER_W2 = 360;
 var AvlTraitScene = ({
@@ -61055,7 +62103,7 @@ var AvlTraitScene = ({
   const dataKey = React96.useMemo(() => JSON.stringify(data), [data]);
   React96.useEffect(() => {
     computeTraitLayout(data).then(setLayout).catch((error) => {
-      log10.error("computeTraitLayout failed", { error: error instanceof Error ? error : String(error) });
+      log11.error("computeTraitLayout failed", { error: error instanceof Error ? error : String(error) });
     });
   }, [dataKey]);
   if (!layout) {