@sebastianwessel/isostate 0.5.0 → 0.6.0

package/dist/editor-support/index.js

@@ -1,428 +1,381 @@
-import { g as getResolvedProjectionLayout, p as projectToRaw, a as getResolvedViewBox, b as getCurrentElementBounds, c as getElementState, h as hideElementAfterExit, u as unhideElementOnReadd, d as getConnectorState, e as updateElementTransforms } from '../chunks/rendering-engine-nkqYx0qc.js';
-import { R as RenderError } from '../chunks/errors-DyqEkrm5.js';
+import { g as getResolvedProjectionLayout, p as projectToRaw, a as getResolvedViewBox, b as getElementState, c as getCurrentElementBounds, h as hideElementAfterExit, u as unhideElementOnReadd, d as getConnectorState, e as updateElementTransforms } from '../chunks/rendering-engine-DLaM1XbU.js';
+import { R as RenderError } from '../chunks/errors-2yA81Vfb.js';
 
-/**
- * Project an isometric grid point into SVG screen coordinates.
- * Uses the same projection, bounds, and padding as the renderer.
- */
 function projectGridPoint(bundle, point) {
-    const layout = getResolvedProjectionLayout(bundle);
-    const rawX = layout.cellSize * (point[0] - point[1]) * 0.5;
-    const rawY = layout.cellSize * (point[0] + point[1]) * 0.25;
-    return {
-        x: rawX - layout.selectedBounds.minX + layout.padding.x,
-        y: rawY - layout.selectedBounds.minY + layout.padding.y,
-    };
+  const layout = getResolvedProjectionLayout(bundle);
+  const rawX = layout.cellSize * (point[0] - point[1]) * 0.5;
+  const rawY = layout.cellSize * (point[0] + point[1]) * 0.25;
+  return {
+    x: rawX - layout.selectedBounds.minX + layout.padding.x,
+    y: rawY - layout.selectedBounds.minY + layout.padding.y
+  };
 }
-/**
- * Unproject an SVG screen point back into fractional isometric grid coordinates.
- * The editor owns snap-to-grid rounding.
- */
 function unprojectScreenPoint(bundle, point) {
-    const layout = getResolvedProjectionLayout(bundle);
-    const rawX = point.x + layout.selectedBounds.minX - layout.padding.x;
-    const rawY = point.y + layout.selectedBounds.minY - layout.padding.y;
-    const cellSize = layout.cellSize;
-    const gridX = rawX / cellSize + (2 * rawY) / cellSize;
-    const gridY = (2 * rawY) / cellSize - rawX / cellSize;
-    return [gridX, gridY];
+  const layout = getResolvedProjectionLayout(bundle);
+  const rawX = point.x + layout.selectedBounds.minX - layout.padding.x;
+  const rawY = point.y + layout.selectedBounds.minY - layout.padding.y;
+  const cellSize = layout.cellSize;
+  const gridX = rawX / cellSize + 2 * rawY / cellSize;
+  const gridY = 2 * rawY / cellSize - rawX / cellSize;
+  return [gridX, gridY];
 }
-/**
- * Convert browser pointer coordinates into SVG user units using the root SVG
- * screen CTM inverse.
- * @throws {RenderError} `EDITOR_GEOMETRY_UNAVAILABLE` when the CTM is missing or not invertible.
- */
 function clientPointToSvgPoint(svg, point) {
-    const ctm = svg.getScreenCTM();
-    if (!ctm) {
-        throw new RenderError("EDITOR_GEOMETRY_UNAVAILABLE", "SVG CTM is not available");
-    }
-    let inverse = null;
-    try {
-        inverse = ctm.inverse();
-    }
-    catch {
-        // non-invertible matrix
-    }
-    if (!inverse) {
-        throw new RenderError("EDITOR_GEOMETRY_UNAVAILABLE", "SVG CTM is not invertible");
-    }
-    const svgPoint = svg.createSVGPoint();
-    svgPoint.x = point.clientX;
-    svgPoint.y = point.clientY;
-    const result = svgPoint.matrixTransform(inverse);
-    return { x: result.x, y: result.y };
+  const ctm = svg.getScreenCTM();
+  if (!ctm) {
+    throw new RenderError("EDITOR_GEOMETRY_UNAVAILABLE", "SVG CTM is not available");
+  }
+  let inverse = null;
+  try {
+    inverse = ctm.inverse();
+  } catch {
+  }
+  if (!inverse) {
+    throw new RenderError("EDITOR_GEOMETRY_UNAVAILABLE", "SVG CTM is not invertible");
+  }
+  const svgPoint = svg.createSVGPoint();
+  svgPoint.x = point.clientX;
+  svgPoint.y = point.clientY;
+  const result = svgPoint.matrixTransform(inverse);
+  return { x: result.x, y: result.y };
 }
-/**
- * Return the four projected corners of a grid cell in clockwise order.
- */
 function getGridCellPolygon(bundle, cell) {
-    const [x, y] = cell;
-    return [
-        projectGridPoint(bundle, [x, y]),
-        projectGridPoint(bundle, [x + 1, y]),
-        projectGridPoint(bundle, [x + 1, y + 1]),
-        projectGridPoint(bundle, [x, y + 1]),
-    ];
+  const [x, y] = cell;
+  return [
+    projectGridPoint(bundle, [x, y]),
+    projectGridPoint(bundle, [x + 1, y]),
+    projectGridPoint(bundle, [x + 1, y + 1]),
+    projectGridPoint(bundle, [x, y + 1])
+  ];
 }
 
-/**
- * Find the topmost runtime object at a screen point.
- * Hit testing follows the current rendered depth order so the visually
- * topmost object wins.
- */
 function getRuntimeObjectAtPoint(adapter, point, options = {}) {
-    const kinds = options.kinds ?? ["element", "connection"];
-    const currentScene = adapter.mounted.engine.getCurrentState();
-    if (!currentScene)
-        return undefined;
-    const objects = adapter.getObjects(currentScene.id);
-    const layerOrder = adapter.getLayerOrder();
-    const layerRank = new Map(layerOrder.map((l, i) => [l.name, i]));
-    const candidates = objects
-        .filter((obj) => kinds.includes(obj.kind))
-        .filter((obj) => options.includeHidden || obj.present)
-        .sort((a, b) => {
-        const rankA = layerRank.get(a.layer) ?? -1;
-        const rankB = layerRank.get(b.layer) ?? -1;
-        return rankA - rankB;
-    });
-    // Check topmost (highest layer rank) first
-    for (let i = candidates.length - 1; i >= 0; i--) {
-        const obj = candidates[i];
-        if (pointInBounds(point, obj.bounds)) {
-            return {
-                id: obj.id,
-                kind: obj.kind,
-                layer: obj.layer,
-                bounds: obj.bounds,
-            };
-        }
+  const kinds = options.kinds ?? ["element", "connection"];
+  const currentScene = adapter.mounted.engine.getCurrentState();
+  if (!currentScene) return void 0;
+  const objects = adapter.getObjects(currentScene.id);
+  const layerOrder = adapter.getLayerOrder();
+  const layerRank = new Map(layerOrder.map((l, i) => [l.name, i]));
+  const candidates = objects.filter((obj) => kinds.includes(obj.kind)).filter((obj) => options.includeHidden || obj.present).sort((a, b) => {
+    const rankA = layerRank.get(a.layer) ?? -1;
+    const rankB = layerRank.get(b.layer) ?? -1;
+    return rankA - rankB;
+  });
+  for (let i = candidates.length - 1; i >= 0; i--) {
+    const obj = candidates[i];
+    if (pointInBounds(point, obj.bounds)) {
+      return {
+        id: obj.id,
+        kind: obj.kind,
+        layer: obj.layer,
+        bounds: obj.bounds
+      };
     }
-    return undefined;
+  }
+  return void 0;
 }
-/**
- * Compute the union bounds of a selection of runtime objects.
- * Missing ids are ignored. Returns `undefined` if no ids resolve.
- */
 function getRuntimeSelectionBounds(adapter, ids) {
-    let minX = Number.POSITIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let maxY = Number.NEGATIVE_INFINITY;
-    for (const id of ids) {
-        const obj = adapter.getObject(id);
-        if (!obj?.present)
-            continue;
-        const b = obj.bounds;
-        minX = Math.min(minX, b.minX);
-        minY = Math.min(minY, b.minY);
-        maxX = Math.max(maxX, b.minX + b.width);
-        maxY = Math.max(maxY, b.minY + b.height);
-    }
-    if (!Number.isFinite(minX))
-        return undefined;
-    return {
-        minX,
-        minY,
-        width: maxX - minX,
-        height: maxY - minY,
-    };
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const id of ids) {
+    const obj = adapter.getObject(id);
+    if (!obj?.present) continue;
+    const b = obj.bounds;
+    minX = Math.min(minX, b.minX);
+    minY = Math.min(minY, b.minY);
+    maxX = Math.max(maxX, b.minX + b.width);
+    maxY = Math.max(maxY, b.minY + b.height);
+  }
+  if (!Number.isFinite(minX)) return void 0;
+  return {
+    minX,
+    minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
 }
 function pointInBounds(point, bounds) {
-    return (point.x >= bounds.minX &&
-        point.x <= bounds.minX + bounds.width &&
-        point.y >= bounds.minY &&
-        point.y <= bounds.minY + bounds.height);
+  return point.x >= bounds.minX && point.x <= bounds.minX + bounds.width && point.y >= bounds.minY && point.y <= bounds.minY + bounds.height;
 }
-/** Compute screen-space bounds for a connector route. */
 function getConnectionBounds(route, bundle) {
-    const layout = resolveLayoutForBounds(bundle);
-    let minRawX = Number.POSITIVE_INFINITY;
-    let minRawY = Number.POSITIVE_INFINITY;
-    let maxRawX = Number.NEGATIVE_INFINITY;
-    let maxRawY = Number.NEGATIVE_INFINITY;
-    for (const [x, y] of route) {
-        const { rawX, rawY } = projectToRaw(x, y, layout.cellSize);
-        minRawX = Math.min(minRawX, rawX);
-        minRawY = Math.min(minRawY, rawY);
-        maxRawX = Math.max(maxRawX, rawX);
-        maxRawY = Math.max(maxRawY, rawY);
-    }
-    const offsetX = -layout.selectedBounds.minX + layout.padding.x;
-    const offsetY = -layout.selectedBounds.minY + layout.padding.y;
-    return {
-        minX: minRawX + offsetX,
-        minY: minRawY + offsetY,
-        width: maxRawX - minRawX,
-        height: maxRawY - minRawY,
-    };
+  const layout = resolveLayoutForBounds(bundle);
+  let minRawX = Number.POSITIVE_INFINITY;
+  let minRawY = Number.POSITIVE_INFINITY;
+  let maxRawX = Number.NEGATIVE_INFINITY;
+  let maxRawY = Number.NEGATIVE_INFINITY;
+  for (const [x, y] of route) {
+    const { rawX, rawY } = projectToRaw(x, y, layout.cellSize);
+    minRawX = Math.min(minRawX, rawX);
+    minRawY = Math.min(minRawY, rawY);
+    maxRawX = Math.max(maxRawX, rawX);
+    maxRawY = Math.max(maxRawY, rawY);
+  }
+  const offsetX = -layout.selectedBounds.minX + layout.padding.x;
+  const offsetY = -layout.selectedBounds.minY + layout.padding.y;
+  return {
+    minX: minRawX + offsetX,
+    minY: minRawY + offsetY,
+    width: maxRawX - minRawX,
+    height: maxRawY - minRawY
+  };
 }
-// Lightweight re-computation of the layout values needed for bounds projection.
 function resolveLayoutForBounds(bundle) {
-    const cellSize = bundle.grid.cellSize;
-    const padding = bundle.layout.padding;
-    // Reproduce content bounds calculation
-    let cMinX = Number.POSITIVE_INFINITY;
-    let cMinY = Number.POSITIVE_INFINITY;
-    let cMaxX = Number.NEGATIVE_INFINITY;
-    let cMaxY = Number.NEGATIVE_INFINITY;
-    for (const stop of bundle.scenes) {
-        for (const el of stop.elements ?? []) {
-            if (el.presence === "removed")
-                continue;
-            const { rawX, rawY } = projectToRaw(el.pos[0] + el.size, el.pos[1] + el.size, cellSize);
-            const visualSize = cellSize * el.size;
-            const anchor = bundle.assets?.[el.asset]?.anchor ?? [0.5, 1];
-            cMinX = Math.min(cMinX, rawX - visualSize * anchor[0]);
-            cMinY = Math.min(cMinY, rawY - visualSize * anchor[1]);
-            cMaxX = Math.max(cMaxX, rawX + visualSize * (1 - anchor[0]));
-            cMaxY = Math.max(cMaxY, rawY + visualSize * (1 - anchor[1]));
-        }
-        for (const conn of stop.connectors ?? []) {
-            if (conn.presence === "removed")
-                continue;
-            for (const [x, y] of conn.route) {
-                const { rawX, rawY } = projectToRaw(x, y, cellSize);
-                cMinX = Math.min(cMinX, rawX);
-                cMinY = Math.min(cMinY, rawY);
-                cMaxX = Math.max(cMaxX, rawX);
-                cMaxY = Math.max(cMaxY, rawY);
-            }
-        }
+  const cellSize = bundle.grid.cellSize;
+  const padding = bundle.layout.padding;
+  let cMinX = Number.POSITIVE_INFINITY;
+  let cMinY = Number.POSITIVE_INFINITY;
+  let cMaxX = Number.NEGATIVE_INFINITY;
+  let cMaxY = Number.NEGATIVE_INFINITY;
+  for (const stop of bundle.scenes) {
+    for (const el of stop.elements ?? []) {
+      if (el.presence === "removed") continue;
+      const { rawX, rawY } = projectToRaw(el.pos[0] + el.size, el.pos[1] + el.size, cellSize);
+      const visualSize = cellSize * el.size;
+      const anchor = bundle.assets?.[el.asset]?.anchor ?? [0.5, 1];
+      cMinX = Math.min(cMinX, rawX - visualSize * anchor[0]);
+      cMinY = Math.min(cMinY, rawY - visualSize * anchor[1]);
+      cMaxX = Math.max(cMaxX, rawX + visualSize * (1 - anchor[0]));
+      cMaxY = Math.max(cMaxY, rawY + visualSize * (1 - anchor[1]));
     }
-    if (!Number.isFinite(cMinX)) {
-        cMinX = 0;
-        cMinY = 0;
-        cMaxX = cellSize;
-        cMaxY = cellSize;
-    }
-    // Floor bounds
-    const [ox, oy] = bundle.floor.origin;
-    const [fw, fh] = bundle.floor.size;
-    const floorPoints = [
-        [ox, oy],
-        [ox + fw, oy],
-        [ox, oy + fh],
-        [ox + fw, oy + fh],
-    ];
-    let fMinX = Number.POSITIVE_INFINITY;
-    let fMinY = Number.POSITIVE_INFINITY;
-    let fMaxX = Number.NEGATIVE_INFINITY;
-    let fMaxY = Number.NEGATIVE_INFINITY;
-    for (const [x, y] of floorPoints) {
+    for (const conn of stop.connectors ?? []) {
+      if (conn.presence === "removed") continue;
+      for (const [x, y] of conn.route) {
         const { rawX, rawY } = projectToRaw(x, y, cellSize);
-        fMinX = Math.min(fMinX, rawX);
-        fMinY = Math.min(fMinY, rawY);
-        fMaxX = Math.max(fMaxX, rawX);
-        fMaxY = Math.max(fMaxY, rawY);
-    }
-    // Select bounds
-    let sMinX;
-    let sMinY;
-    let sMaxX;
-    let sMaxY;
-    const mode = bundle.layout.bounds;
-    if (mode === "content") {
-        sMinX = cMinX;
-        sMinY = cMinY;
-        sMaxX = cMaxX;
-        sMaxY = cMaxY;
-    }
-    else if (mode === "floor") {
-        sMinX = fMinX;
-        sMinY = fMinY;
-        sMaxX = fMaxX;
-        sMaxY = fMaxY;
+        cMinX = Math.min(cMinX, rawX);
+        cMinY = Math.min(cMinY, rawY);
+        cMaxX = Math.max(cMaxX, rawX);
+        cMaxY = Math.max(cMaxY, rawY);
+      }
     }
-    else {
-        sMinX = Math.min(cMinX, fMinX);
-        sMinY = Math.min(cMinY, fMinY);
-        sMaxX = Math.max(cMaxX, fMaxX);
-        sMaxY = Math.max(cMaxY, fMaxY);
-    }
-    return {
-        cellSize,
-        padding,
-        selectedBounds: { minX: sMinX, minY: sMinY, maxX: sMaxX, maxY: sMaxY },
-    };
+  }
+  if (!Number.isFinite(cMinX)) {
+    cMinX = 0;
+    cMinY = 0;
+    cMaxX = cellSize;
+    cMaxY = cellSize;
+  }
+  const [ox, oy] = bundle.floor.origin;
+  const [fw, fh] = bundle.floor.size;
+  const floorPoints = [
+    [ox, oy],
+    [ox + fw, oy],
+    [ox, oy + fh],
+    [ox + fw, oy + fh]
+  ];
+  let fMinX = Number.POSITIVE_INFINITY;
+  let fMinY = Number.POSITIVE_INFINITY;
+  let fMaxX = Number.NEGATIVE_INFINITY;
+  let fMaxY = Number.NEGATIVE_INFINITY;
+  for (const [x, y] of floorPoints) {
+    const { rawX, rawY } = projectToRaw(x, y, cellSize);
+    fMinX = Math.min(fMinX, rawX);
+    fMinY = Math.min(fMinY, rawY);
+    fMaxX = Math.max(fMaxX, rawX);
+    fMaxY = Math.max(fMaxY, rawY);
+  }
+  let sMinX;
+  let sMinY;
+  let sMaxX;
+  let sMaxY;
+  const mode = bundle.layout.bounds;
+  if (mode === "content") {
+    sMinX = cMinX;
+    sMinY = cMinY;
+    sMaxX = cMaxX;
+    sMaxY = cMaxY;
+  } else if (mode === "floor") {
+    sMinX = fMinX;
+    sMinY = fMinY;
+    sMaxX = fMaxX;
+    sMaxY = fMaxY;
+  } else {
+    sMinX = Math.min(cMinX, fMinX);
+    sMinY = Math.min(cMinY, fMinY);
+    sMaxX = Math.max(cMaxX, fMaxX);
+    sMaxY = Math.max(cMaxY, fMaxY);
+  }
+  return {
+    cellSize,
+    padding,
+    selectedBounds: { minX: sMinX, minY: sMinY, maxX: sMaxX, maxY: sMaxY }
+  };
 }
 
-/**
- * Create an editor runtime adapter around an already mounted scene.
- * The adapter does not mutate the mounted scene or create editor UI.
- */
 function createEditorRuntimeAdapter(mounted) {
-    const bundle = mounted.engine.bundle;
-    if (!bundle) {
-        throw new Error("EditorRuntimeAdapter requires an initialized mounted scene");
+  const bundle = mounted.engine.bundle;
+  if (!bundle) {
+    throw new Error("EditorRuntimeAdapter requires an initialized mounted scene");
+  }
+  const layerOrder = bundle.layers.map((layer) => ({ name: layer.name, order: layer.order })).sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
+  return {
+    mounted,
+    setActiveScene(sceneId) {
+      const scene = bundle.scenes.find((candidate) => candidate.id === sceneId);
+      if (!scene) return false;
+      this.setProgress(scene.progress);
+      return true;
+    },
+    setProgress(progress) {
+      if (mounted.controller) {
+        mounted.controller.setProgress(progress);
+        return;
+      }
+      mounted.engine.setProgress(progress);
+      applyEditorFrame(mounted);
+    },
+    getObjects(sceneId) {
+      const currentState = mounted.engine.getCurrentState();
+      if (!currentState || currentState.id !== sceneId) return [];
+      const result = [];
+      for (const update of mounted.engine.getFrameUpdates()) {
+        const bounds = getEditorElementBounds(mounted, update.id, update.asset);
+        result.push({
+          id: update.id,
+          kind: "element",
+          sceneId: currentState.id,
+          layer: update.layer,
+          present: update.lifecycle !== "removed",
+          bounds: bounds ?? { minX: 0, minY: 0, width: 0, height: 0 },
+          grid: { kind: "element", at: update.pos, size: update.size }
+        });
+      }
+      for (const update of mounted.engine.getConnectorFrameUpdates()) {
+        const bounds = getConnectionBounds(update.route, bundle);
+        result.push({
+          id: update.id,
+          kind: "connection",
+          sceneId: currentState.id,
+          layer: update.layer,
+          present: update.lifecycle !== "removed",
+          bounds,
+          grid: { kind: "connection", route: update.route }
+        });
+      }
+      return result;
+    },
+    getObject(id) {
+      const currentState = mounted.engine.getCurrentState();
+      if (!currentState) return void 0;
+      const elementUpdate = mounted.engine.getElementUpdate(id);
+      if (elementUpdate && elementUpdate.asset !== "") {
+        const bounds = getEditorElementBounds(mounted, id, elementUpdate.asset);
+        return {
+          id: elementUpdate.id,
+          kind: "element",
+          sceneId: currentState.id,
+          layer: elementUpdate.layer,
+          present: elementUpdate.lifecycle !== "removed",
+          bounds: bounds ?? { minX: 0, minY: 0, width: 0, height: 0 },
+          grid: { kind: "element", at: elementUpdate.pos, size: elementUpdate.size }
+        };
+      }
+      const connectorUpdate = mounted.engine.getConnectorUpdate(id);
+      if (connectorUpdate && connectorUpdate.route.length > 0) {
+        const bounds = getConnectionBounds(connectorUpdate.route, bundle);
+        return {
+          id: connectorUpdate.id,
+          kind: "connection",
+          sceneId: currentState.id,
+          layer: connectorUpdate.layer,
+          present: connectorUpdate.lifecycle !== "removed",
+          bounds,
+          grid: { kind: "connection", route: connectorUpdate.route }
+        };
+      }
+      return void 0;
+    },
+    getLayerOrder() {
+      return layerOrder.slice();
+    },
+    getResolvedViewBox() {
+      return getResolvedViewBox(bundle);
+    },
+    projectGridPoint(point) {
+      return projectGridPoint(bundle, point);
+    },
+    unprojectScreenPoint(point) {
+      return unprojectScreenPoint(bundle, point);
+    },
+    clientPointToSvgPoint(point) {
+      return clientPointToSvgPoint(mounted.svg, point);
+    },
+    getGridCellPolygon(cell) {
+      return getGridCellPolygon(bundle, cell);
+    },
+    getObjectAtPoint(point, options) {
+      return getRuntimeObjectAtPoint(this, point, options);
+    },
+    getSelectionBounds(ids) {
+      return getRuntimeSelectionBounds(this, ids);
+    },
+    destroy() {
+    }
+  };
+}
+function getEditorElementBounds(mounted, id, asset) {
+  if (asset === "text") {
+    const rect = getElementState(mounted.svg, id)?.node.getBoundingClientRect();
+    if (rect && rect.width > 0 && rect.height > 0) {
+      const topLeft = clientPointToSvgPoint(mounted.svg, { clientX: rect.left, clientY: rect.top });
+      const bottomRight = clientPointToSvgPoint(mounted.svg, { clientX: rect.right, clientY: rect.bottom });
+      return { minX: topLeft.x, minY: topLeft.y, width: bottomRight.x - topLeft.x, height: bottomRight.y - topLeft.y };
     }
-    // Cache layer order since it is static for the bundle
-    const layerOrder = bundle.layers
-        .map((layer) => ({ name: layer.name, order: layer.order }))
-        .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
-    return {
-        mounted,
-        setActiveScene(sceneId) {
-            const scene = bundle.scenes.find((candidate) => candidate.id === sceneId);
-            if (!scene)
-                return false;
-            this.setProgress(scene.progress);
-            return true;
-        },
-        setProgress(progress) {
-            mounted.engine.setProgress(progress);
-            applyEditorFrame(mounted);
-        },
-        getObjects(sceneId) {
-            const currentState = mounted.engine.getCurrentState();
-            if (!currentState || currentState.id !== sceneId)
-                return [];
-            const result = [];
-            // Elements from current engine frame
-            for (const update of mounted.engine.getFrameUpdates()) {
-                const bounds = getCurrentElementBounds(mounted.svg, update.id);
-                result.push({
-                    id: update.id,
-                    kind: "element",
-                    sceneId: currentState.id,
-                    layer: update.layer,
-                    present: update.lifecycle !== "removed",
-                    bounds: bounds ?? { minX: 0, minY: 0, width: 0, height: 0 },
-                    grid: { kind: "element", at: update.pos, size: update.size },
-                });
-            }
-            // Connections from current engine frame
-            for (const update of mounted.engine.getConnectorFrameUpdates()) {
-                const bounds = getConnectionBounds(update.route, bundle);
-                result.push({
-                    id: update.id,
-                    kind: "connection",
-                    sceneId: currentState.id,
-                    layer: update.layer,
-                    present: update.lifecycle !== "removed",
-                    bounds,
-                    grid: { kind: "connection", route: update.route },
-                });
-            }
-            return result;
-        },
-        getObject(id) {
-            const currentState = mounted.engine.getCurrentState();
-            if (!currentState)
-                return undefined;
-            const elementUpdate = mounted.engine.getElementUpdate(id);
-            if (elementUpdate && elementUpdate.asset !== "") {
-                const bounds = getCurrentElementBounds(mounted.svg, id);
-                return {
-                    id: elementUpdate.id,
-                    kind: "element",
-                    sceneId: currentState.id,
-                    layer: elementUpdate.layer,
-                    present: elementUpdate.lifecycle !== "removed",
-                    bounds: bounds ?? { minX: 0, minY: 0, width: 0, height: 0 },
-                    grid: { kind: "element", at: elementUpdate.pos, size: elementUpdate.size },
-                };
-            }
-            const connectorUpdate = mounted.engine.getConnectorUpdate(id);
-            if (connectorUpdate && connectorUpdate.route.length > 0) {
-                const bounds = getConnectionBounds(connectorUpdate.route, bundle);
-                return {
-                    id: connectorUpdate.id,
-                    kind: "connection",
-                    sceneId: currentState.id,
-                    layer: connectorUpdate.layer,
-                    present: connectorUpdate.lifecycle !== "removed",
-                    bounds,
-                    grid: { kind: "connection", route: connectorUpdate.route },
-                };
-            }
-            return undefined;
-        },
-        getLayerOrder() {
-            return layerOrder.slice();
-        },
-        getResolvedViewBox() {
-            return getResolvedViewBox(bundle);
-        },
-        projectGridPoint(point) {
-            return projectGridPoint(bundle, point);
-        },
-        unprojectScreenPoint(point) {
-            return unprojectScreenPoint(bundle, point);
-        },
-        clientPointToSvgPoint(point) {
-            return clientPointToSvgPoint(mounted.svg, point);
-        },
-        getGridCellPolygon(cell) {
-            return getGridCellPolygon(bundle, cell);
-        },
-        getObjectAtPoint(point, options) {
-            return getRuntimeObjectAtPoint(this, point, options);
-        },
-        getSelectionBounds(ids) {
-            return getRuntimeSelectionBounds(this, ids);
-        },
-        destroy() {
-            // Adapter owns no listeners or caches that outlive this call.
-            // The editor is responsible for mounted scene cleanup.
-        },
-    };
+  }
+  return getCurrentElementBounds(mounted.svg, id);
 }
 function applyEditorFrame(mounted) {
-    const elements = mounted.engine.getFrameUpdates().map((update) => ({
-        id: update.id,
-        asset: update.asset,
-        pos: update.pos,
-        size: update.size,
-        layer: update.layer,
-        presence: update.lifecycle,
-        enter: update.entry,
-        exit: update.exit,
-        ambient: update.ambient,
-        text: update.text,
-        primitive: update.primitive,
-    }));
-    const connectors = mounted.engine.getConnectorFrameUpdates().map((update) => ({
-        id: update.id,
-        route: update.route,
-        layer: update.layer,
-        presence: update.lifecycle,
-        style: update.style,
-        start: update.start,
-        end: update.end,
-        direction: update.direction,
-        enter: update.entry,
-        exit: update.exit,
-        ambient: update.ambient,
-    }));
-    for (const element of elements) {
-        const state = getElementState(mounted.svg, element.id);
-        if (!state)
-            continue;
-        if (element.presence === "removed") {
-            state.isHidden = true;
-            hideElementAfterExit(state.node);
-        }
-        else {
-            state.isHidden = false;
-            unhideElementOnReadd(state.node);
-        }
+  const elements = mounted.engine.getFrameUpdates().map((update) => ({
+    id: update.id,
+    asset: update.asset,
+    pos: update.pos,
+    size: update.size,
+    layer: update.layer,
+    presence: update.lifecycle,
+    enter: update.entry,
+    exit: update.exit,
+    ambient: update.ambient,
+    text: update.text,
+    primitive: update.primitive,
+    activity: update.activity
+  }));
+  const connectors = mounted.engine.getConnectorFrameUpdates().map((update) => ({
+    id: update.id,
+    route: update.route,
+    layer: update.layer,
+    presence: update.lifecycle,
+    style: update.style,
+    start: update.start,
+    end: update.end,
+    direction: update.direction,
+    enter: update.entry,
+    exit: update.exit,
+    ambient: update.ambient,
+    message: update.message
+  }));
+  for (const element of elements) {
+    const state = getElementState(mounted.svg, element.id);
+    if (!state) continue;
+    if (element.presence === "removed") {
+      state.isHidden = true;
+      hideElementAfterExit(state.node);
+    } else {
+      state.isHidden = false;
+      unhideElementOnReadd(state.node);
     }
-    for (const connector of connectors) {
-        const state = getConnectorState(mounted.svg, connector.id);
-        if (!state)
-            continue;
-        if (connector.presence === "removed") {
-            state.isHidden = true;
-            hideElementAfterExit(state.node);
-        }
-        else {
-            state.isHidden = false;
-            unhideElementOnReadd(state.node);
-        }
+  }
+  for (const connector of connectors) {
+    const state = getConnectorState(mounted.svg, connector.id);
+    if (!state) continue;
+    if (connector.presence === "removed") {
+      state.isHidden = true;
+      hideElementAfterExit(state.node);
+    } else {
+      state.isHidden = false;
+      unhideElementOnReadd(state.node);
     }
-    updateElementTransforms(mounted.svg, elements, connectors);
+  }
+  updateElementTransforms(mounted.svg, elements, connectors);
 }
 
 export { clientPointToSvgPoint, createEditorRuntimeAdapter, getGridCellPolygon, getRuntimeObjectAtPoint, getRuntimeSelectionBounds, projectGridPoint, unprojectScreenPoint };