@sebastianwessel/isostate 0.4.0 → 0.5.0

package/dist/dsl/index.js

@@ -1,4 +1,4 @@
-export { c as compileScene, d as deriveProgresses, f as fromJs, a as fromJson, p as parseScene, r as resolveSceneSnapshots, t as toJs, b as toJson, v as validateScene } from '../chunks/scene-parser-B9SPDLYs.js';
+export { c as compileScene, d as deriveProgresses, f as fromJs, a as fromJson, p as parseScene, r as resolveSceneSnapshots, t as toJs, b as toJson, v as validateScene } from '../chunks/scene-parser-F69XGE0l.js';
 import '../chunks/sha256-4JuurR-b.js';
 import '../chunks/errors-DyqEkrm5.js';
 import 'yaml';

package/dist/dsl/scene-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-parser.d.ts","sourceRoot":"","sources":["../../src/dsl/scene-parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAmBX,aAAa,EAIb,MAAM,mBAAmB,CAAC;AAmvB3B;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAkBrD"}
+{"version":3,"file":"scene-parser.d.ts","sourceRoot":"","sources":["../../src/dsl/scene-parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAmBX,aAAa,EAIb,MAAM,mBAAmB,CAAC;AAovB3B;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAkBrD"}

package/dist/dsl/scene-validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-validator.d.ts","sourceRoot":"","sources":["../../src/dsl/scene-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAeX,kBAAkB,EAClB,qBAAqB,EAErB,mBAAmB,EACnB,aAAa,EACb,SAAS,EAGT,gBAAgB,EAEhB,MAAM,mBAAmB,CAAC;AAwE3B,MAAM,WAAW,qBAAqB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC,MAAM,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAitDD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,gBAAgB,CAiBvE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,qBAAqB,EAAE,CA0GtF;AAsBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CAK9D"}
+{"version":3,"file":"scene-validator.d.ts","sourceRoot":"","sources":["../../src/dsl/scene-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAeX,kBAAkB,EAClB,qBAAqB,EAErB,mBAAmB,EACnB,aAAa,EACb,SAAS,EAGT,gBAAgB,EAEhB,MAAM,mBAAmB,CAAC;AAwE3B,MAAM,WAAW,qBAAqB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC,MAAM,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAqxDD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,gBAAgB,CAiBvE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,qBAAqB,EAAE,CA0GtF;AAsBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CAK9D"}

package/dist/editor-support/index.js

@@ -1,4 +1,4 @@
-import { n as getResolvedProjectionLayout, q as projectToRaw, o as getResolvedViewBox, k as getCurrentElementBounds, l as getElementState, p as hideElementAfterExit, u as unhideElementOnReadd, j as getConnectorState, t as updateElementTransforms } from '../chunks/rendering-engine-BUUV3Qq-.js';
+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';
 
 /**

package/dist/index.d.ts

@@ -3,10 +3,13 @@ export type { CameraGridArea, CameraState, CameraZoomOptions, ControllerConfig,
 export { AnimationController } from "./animation/controller.ts";
 export { buildSceneDOM, type RenderConfig, } from "./rendering/rendering-engine.ts";
 export { applyThemeToElement } from "./rendering/theme.ts";
+export { attachDiagnosticsOverlay, type DiagnosticsOverlayHandle, type DiagnosticsOverlayOptions, } from "./runtime/diagnostics-overlay.ts";
+export { exportScenePng, exportSceneSvg, type PngSnapshotOptions, type SnapshotOptions, } from "./runtime/export.ts";
+export type { ElementPointerEvent, MountedSceneEvents } from "./runtime/index.ts";
 export { type MountedScene, type MountSceneOptions, mountScene, type ResolvedRuntimeConfig, type RuntimeBundle, } from "./runtime/index.ts";
 export { AssetRegistryImpl, composeTheme, createAssetRegistry, createDefaultRegistry, resolveTheme, } from "./types/asset-registry.ts";
 export { AnimationError, ControllerError, ParseError, RenderError, ValidationErrorClass, } from "./types/errors.ts";
-export type { AmbientAnimation, AssetCatalogEntry, AssetCategory, AssetDefinition, AssetRegistry, CameraEasing, CameraFocus, CameraTarget, CompiledAsset, CompiledFloor, CompiledLayer, CompiledLayout, ElementPatch, ElementPlacement, ElementRemoval, EntryAnimation, ExitAnimation, FloorConfig, GridConfig, LayerDefinition, LayoutBounds, LayoutFit, LifecycleStatus, ResolvedLayoutConfig, RuntimeElementState, RuntimeSceneStop, SceneDocument, SceneHeader, SceneStep, Theme, ValidationError, ValidationReport, ValidationWarning, } from "./types/index.ts";
+export type { AmbientAnimation, AssetCatalogEntry, AssetCategory, AssetDefinition, AssetRegistry, CameraEasing, CameraFocus, CameraTarget, CompiledAsset, CompiledFloor, CompiledLayer, CompiledLayout, ConnectionPatch, ConnectionPlacement, ConnectionRemoval, ElementPatch, ElementPlacement, ElementRemoval, EntryAnimation, ExitAnimation, FloorConfig, GridConfig, LayerDefinition, LayoutBounds, LayoutFit, LifecycleStatus, PrimitiveContent, ResolvedLayoutConfig, RuntimeElementState, RuntimeSceneStop, SceneDocument, SceneHeader, SceneStep, TextContent, Theme, ValidationError, ValidationReport, ValidationWarning, } from "./types/index.ts";
 export { guardEntryAnimation, guardExitAnimation, guardLifecycleStatus, } from "./types/node.ts";
 export { calculateTransform, calculateVisualSize, DEFAULT_CELL_SIZE, type EasingFn, type EasingType, easeInCubic, easeInOutCubic, easeOutCubic, linear, projectToScreen, resolveEasing, } from "./utils/index.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,GACjB,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACX,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACN,aAAa,EACb,KAAK,YAAY,GACjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,qBAAqB,EAC1B,KAAK,aAAa,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACN,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,YAAY,GACZ,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACN,cAAc,EACd,eAAe,EACf,UAAU,EACV,WAAW,EACX,oBAAoB,GACpB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACX,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,aAAa,EACb,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,EACb,WAAW,EACX,UAAU,EACV,eAAe,EACf,YAAY,EACZ,SAAS,EACT,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,SAAS,EACT,KAAK,EACL,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACN,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,WAAW,EACX,cAAc,EACd,YAAY,EACZ,MAAM,EACN,eAAe,EACf,aAAa,GACb,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,GACjB,MAAM,iCAAiC,CAAC;AACzC,YAAY,EACX,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACN,aAAa,EACb,KAAK,YAAY,GACjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACN,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,GAC9B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACN,cAAc,EACd,cAAc,EACd,KAAK,kBAAkB,EACvB,KAAK,eAAe,GACpB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAClF,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,qBAAqB,EAC1B,KAAK,aAAa,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACN,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,YAAY,GACZ,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACN,cAAc,EACd,eAAe,EACf,UAAU,EACV,WAAW,EACX,oBAAoB,GACpB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACX,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,aAAa,EACb,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,EACb,WAAW,EACX,UAAU,EACV,eAAe,EACf,YAAY,EACZ,SAAS,EACT,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,SAAS,EACT,WAAW,EACX,KAAK,EACL,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACN,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,WAAW,EACX,cAAc,EACd,YAAY,EACZ,MAAM,EACN,eAAe,EACf,aAAa,GACb,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,6 +1,8 @@
-export { A as AnimationController, a as AnimationEngine, e as easeInCubic, b as easeInOutCubic, c as easeOutCubic, l as linear, m as mountScene, r as resolveEasing } from './chunks/index-C3qcXbPI.js';
-export { A as AssetRegistryImpl, D as DEFAULT_CELL_SIZE, c as applyThemeToElement, d as buildSceneDOM, e as calculateTransform, f as calculateVisualSize, g as composeTheme, h as createAssetRegistry, i as createDefaultRegistry, r as projectToScreen, s as resolveTheme } from './chunks/rendering-engine-BUUV3Qq-.js';
-export { A as AnimationError, C as ControllerError, P as ParseError, R as RenderError, V as ValidationErrorClass } from './chunks/errors-DyqEkrm5.js';
+export { A as AnimationController, a as AnimationEngine, e as easeInCubic, b as easeInOutCubic, c as easeOutCubic, l as linear, m as mountScene, r as resolveEasing } from './chunks/index-CB6XEsbY.js';
+import { g as getResolvedProjectionLayout, a as getResolvedViewBox, f as projectToScreen, e as updateElementTransforms, c as getElementState, h as hideElementAfterExit, u as unhideElementOnReadd, d as getConnectorState } from './chunks/rendering-engine-nkqYx0qc.js';
+export { A as AssetRegistryImpl, D as DEFAULT_CELL_SIZE, i as applyThemeToElement, j as buildSceneDOM, k as calculateTransform, l as calculateVisualSize, m as composeTheme, n as createAssetRegistry, o as createDefaultRegistry, r as resolveTheme } from './chunks/rendering-engine-nkqYx0qc.js';
+import { R as RenderError } from './chunks/errors-DyqEkrm5.js';
+export { A as AnimationError, C as ControllerError, P as ParseError, V as ValidationErrorClass } from './chunks/errors-DyqEkrm5.js';
 import './chunks/sha256-4JuurR-b.js';
 
 /** Runtime set of valid entry animation strings */
@@ -47,5 +49,469 @@ function guardLifecycleStatus(v) {
     return LIFECYCLE_STATUSES.has(v) ? v : undefined;
 }
 
-export { guardEntryAnimation, guardExitAnimation, guardLifecycleStatus };
+const SVG_NS = "http://www.w3.org/2000/svg";
+const DIAGNOSTICS_ATTR = "data-iso-diagnostics";
+const GRID_STROKE = "var(--iso-diag-grid, rgba(37, 99, 235, 0.35))";
+const TEXT_FILL = "var(--iso-diag-text, #1e3a8a)";
+const ANCHOR_FILL = "var(--iso-diag-anchor, #dc2626)";
+const ROUTE_FILL = "var(--iso-diag-route, #059669)";
+const registryBySvg = new WeakMap();
+/**
+ * Attach a development-time diagnostics overlay (grid, coordinates, element
+ * anchors, connector route points, and a scene/progress readout) to a mounted
+ * scene. See `specs/02-capabilities/diagnostics-overlay.md` for the full
+ * normative behavior.
+ */
+function attachDiagnosticsOverlay(mounted, options = {}) {
+    assertMounted(mounted);
+    const registry = registryBySvg.get(mounted.svg) ?? {};
+    registryBySvg.set(mounted.svg, registry);
+    // Replace any previously attached overlay: retire its token so its
+    // `update()`/`destroy()` become no-ops, then remove its DOM group.
+    registry.current?.handle.destroy();
+    const token = Symbol("diagnostics-overlay");
+    const group = document.createElementNS(SVG_NS, "g");
+    group.setAttribute(DIAGNOSTICS_ATTR, "");
+    mounted.svg.appendChild(group);
+    const render = () => renderOverlay(group, mounted, options);
+    render();
+    const unsubscribe = subscribeToLiveUpdates(mounted, render);
+    const isCurrent = () => registry.current?.token === token;
+    const handle = {
+        update() {
+            if (!isCurrent())
+                return;
+            render();
+        },
+        destroy() {
+            if (!isCurrent())
+                return;
+            unsubscribe();
+            group.parentNode?.removeChild(group);
+            registry.current = undefined;
+        },
+    };
+    registry.current = { token, handle };
+    return handle;
+}
+function assertMounted(mounted) {
+    if (!mounted.svg.isConnected) {
+        throw new RenderError("MOUNT_DESTROYED", "Cannot attach a diagnostics overlay to a destroyed mount");
+    }
+}
+/**
+ * When the mount has a controller, re-render on `progress-change` and
+ * `camera-change` so the overlay tracks live scroll/camera state. Without a
+ * controller, consumers call `update()` manually — returns a no-op teardown.
+ */
+function subscribeToLiveUpdates(mounted, render) {
+    const controller = mounted.controller;
+    if (!controller)
+        return () => undefined;
+    const onProgressChange = () => render();
+    const onCameraChange = () => render();
+    controller.on("progress-change", onProgressChange);
+    controller.on("camera-change", onCameraChange);
+    return () => {
+        controller.off("progress-change", onProgressChange);
+        controller.off("camera-change", onCameraChange);
+    };
+}
+// ── Rendering ────────────────────────────────────────────────────────────────
+function renderOverlay(group, mounted, options) {
+    clearChildren(group);
+    const bundle = mounted.engine.bundle;
+    if (!bundle)
+        return;
+    const layout = getResolvedProjectionLayout(bundle);
+    const project = (x, y) => {
+        const screen = projectToScreen(x, y, layout.cellSize, layout.selectedBounds.minX, layout.selectedBounds.minY, layout.padding.x, layout.padding.y);
+        return { x: screen.screenX, y: screen.screenY };
+    };
+    const showGrid = options.grid ?? true;
+    const showCoordinates = options.coordinates ?? false;
+    const showAnchors = options.anchors ?? true;
+    const showRoutes = options.routes ?? true;
+    const showReadout = options.readout ?? true;
+    if (showGrid)
+        appendGrid(group, bundle, project);
+    if (showCoordinates)
+        appendCoordinates(group, bundle, project);
+    if (showAnchors)
+        appendAnchors(group, mounted, project);
+    if (showRoutes)
+        appendRoutes(group, mounted, project);
+    if (showReadout)
+        appendReadout(group, mounted, bundle);
+}
+function appendGrid(group, bundle, project) {
+    const [originX, originY] = bundle.floor.origin;
+    const [columns, rows] = bundle.floor.size;
+    for (let x = 0; x <= columns; x++) {
+        appendGridLine(group, project(originX + x, originY), project(originX + x, originY + rows));
+    }
+    for (let y = 0; y <= rows; y++) {
+        appendGridLine(group, project(originX, originY + y), project(originX + columns, originY + y));
+    }
+}
+function appendGridLine(group, start, end) {
+    const path = document.createElementNS(SVG_NS, "path");
+    path.setAttribute("d", `M ${start.x} ${start.y} L ${end.x} ${end.y}`);
+    path.setAttribute("stroke", GRID_STROKE);
+    path.setAttribute("stroke-width", "1");
+    path.setAttribute("fill", "none");
+    path.setAttribute("vector-effect", "non-scaling-stroke");
+    group.appendChild(path);
+}
+function appendCoordinates(group, bundle, project) {
+    const [originX, originY] = bundle.floor.origin;
+    const [columns, rows] = bundle.floor.size;
+    for (let x = 0; x <= columns; x++) {
+        for (let y = 0; y <= rows; y++) {
+            const gridX = originX + x;
+            const gridY = originY + y;
+            const point = project(gridX, gridY);
+            const text = document.createElementNS(SVG_NS, "text");
+            text.setAttribute("x", String(point.x));
+            text.setAttribute("y", String(point.y));
+            text.setAttribute("font-size", "8");
+            text.setAttribute("fill", TEXT_FILL);
+            text.textContent = `${gridX},${gridY}`;
+            group.appendChild(text);
+        }
+    }
+}
+function appendAnchors(group, mounted, project) {
+    for (const element of mounted.engine.getFrameUpdates()) {
+        if (element.lifecycle === "removed")
+            continue;
+        // The element's anchor is the node's local transform origin, which the
+        // renderer always places at `projectToScreen(pos + size, ...)` — see
+        // `applyElementTransform()` in rendering-engine.ts. No separate anchor
+        // ratio math is needed here to locate the point itself.
+        const point = project(element.pos[0] + element.size, element.pos[1] + element.size);
+        const circle = document.createElementNS(SVG_NS, "circle");
+        circle.setAttribute("cx", String(point.x));
+        circle.setAttribute("cy", String(point.y));
+        circle.setAttribute("r", "3");
+        circle.setAttribute("fill", ANCHOR_FILL);
+        group.appendChild(circle);
+    }
+}
+function appendRoutes(group, mounted, project) {
+    for (const connector of mounted.engine.getConnectorFrameUpdates()) {
+        if (connector.lifecycle === "removed")
+            continue;
+        for (const [x, y] of connector.route) {
+            const point = project(x, y);
+            const rect = document.createElementNS(SVG_NS, "rect");
+            rect.setAttribute("x", String(point.x - 2));
+            rect.setAttribute("y", String(point.y - 2));
+            rect.setAttribute("width", "4");
+            rect.setAttribute("height", "4");
+            rect.setAttribute("fill", ROUTE_FILL);
+            group.appendChild(rect);
+        }
+    }
+}
+function appendReadout(group, mounted, bundle) {
+    const viewBox = mounted.controller ? mounted.controller.getCameraState().viewBox : getResolvedViewBox(bundle);
+    const progress = mounted.controller ? mounted.controller.getProgress() : mounted.engine.getProgress();
+    // Resolved from the engine's own progress-to-stop mapping (not
+    // `controller.currentScene`, which only advances on explicit scene
+    // navigation and would go stale under scroll-driven progress changes).
+    const sceneId = mounted.controller ? mounted.engine.getCurrentState()?.id : undefined;
+    const text = document.createElementNS(SVG_NS, "text");
+    text.setAttribute("x", String(viewBox.minX + 4));
+    text.setAttribute("y", String(viewBox.minY + 10));
+    text.setAttribute("font-size", "10");
+    text.setAttribute("fill", TEXT_FILL);
+    text.textContent = sceneId
+        ? `scene ${sceneId} · progress ${roundProgress(progress)}`
+        : `progress ${roundProgress(progress)}`;
+    group.appendChild(text);
+}
+function roundProgress(progress) {
+    return Math.round(progress * 1000) / 1000;
+}
+function clearChildren(node) {
+    while (node.firstChild)
+        node.removeChild(node.firstChild);
+}
+
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+const DIAGNOSTICS_OVERLAY_SELECTOR = "[data-iso-diagnostics]";
+/**
+ * Serialize a mounted scene to a standalone SVG document string.
+ *
+ * The exported SVG carries the runtime stylesheet and current visual state
+ * as-is. Ambient/entry/exit CSS animations are not restarted or awaited by
+ * the export; the snapshot reflects the un-animated base state at the
+ * resolved progress.
+ */
+async function exportSceneSvg(mounted, options = {}) {
+    assertNotDestroyed(mounted);
+    assertValidSnapshotOptions(options);
+    return withRestoredProgress(mounted, options.progress, async () => {
+        const clone = prepareClone(mounted.svg, options);
+        if (options.inlineAssets ?? true) {
+            await inlineImageAssets(clone);
+        }
+        return serializeSvg(clone);
+    });
+}
+/** Rasterize a mounted scene to a PNG blob. */
+async function exportScenePng(mounted, options = {}) {
+    assertNotDestroyed(mounted);
+    assertValidPngSnapshotOptions(options);
+    const scale = options.scale ?? 2;
+    return withRestoredProgress(mounted, options.progress, async () => {
+        const clone = prepareClone(mounted.svg, options);
+        // PNG export always inlines assets: external hrefs taint or fail canvas rasterization.
+        await inlineImageAssets(clone);
+        const svgString = serializeSvg(clone);
+        const viewBox = readViewBox(clone);
+        return rasterize(svgString, viewBox, scale);
+    });
+}
+// ── Shared step 1-3: destroyed check, option validation, progress restore ──
+function assertNotDestroyed(mounted) {
+    if (!mounted.svg.isConnected) {
+        throw new RenderError("EXPORT_TARGET_DESTROYED", "Cannot export a scene whose mount was destroyed");
+    }
+}
+function assertValidSnapshotOptions(options) {
+    if (options.progress !== undefined && !isValidProgress(options.progress)) {
+        throw new RenderError("EXPORT_INVALID_OPTIONS", "progress must be a finite number within [0, 1]", {
+            progress: options.progress,
+        });
+    }
+}
+function assertValidPngSnapshotOptions(options) {
+    assertValidSnapshotOptions(options);
+    if (options.scale !== undefined && !isValidScale(options.scale)) {
+        throw new RenderError("EXPORT_INVALID_OPTIONS", "scale must be a finite number greater than 0", {
+            scale: options.scale,
+        });
+    }
+    if (options.inlineAssets === false) {
+        throw new RenderError("EXPORT_INVALID_OPTIONS", "exportScenePng() always inlines assets; inlineAssets: false is unsupported for PNG export");
+    }
+}
+function isValidProgress(progress) {
+    return Number.isFinite(progress) && progress >= 0 && progress <= 1;
+}
+function isValidScale(scale) {
+    return Number.isFinite(scale) && scale > 0;
+}
+/**
+ * Runs `run` at the requested `progress`, restoring the engine's prior
+ * progress afterwards on every code path (success or rejection). When
+ * `progress` is omitted, `run` executes at the scene's current progress and
+ * no restoration is needed.
+ */
+async function withRestoredProgress(mounted, progress, run) {
+    if (progress === undefined) {
+        return run();
+    }
+    const previousProgress = mounted.engine.getProgress();
+    try {
+        mounted.engine.setProgress(progress);
+        applyControllerFrame(mounted);
+        return await run();
+    }
+    finally {
+        mounted.engine.setProgress(previousProgress);
+        applyControllerFrame(mounted);
+    }
+}
+/**
+ * Applies the engine's current frame to the live SVG so DOM state (element
+ * transforms, generated content, connector routes, and lifecycle visibility)
+ * matches the engine's resolved progress. Mirrors the non-animated portion of
+ * `AnimationController`'s frame-apply path: transforms/content via
+ * `updateElementTransforms()`, plus visibility driven by the resolved
+ * lifecycle state. CSS entry/exit animation classes are intentionally not
+ * (re)triggered here, matching the spec's requirement that ambient/entry
+ * animations are irrelevant to export output.
+ */
+function applyControllerFrame(mounted) {
+    const svg = mounted.svg;
+    const elementUpdates = 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 connectorUpdates = 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,
+    }));
+    updateElementTransforms(svg, elementUpdates, connectorUpdates);
+    applyElementVisibility(svg, elementUpdates);
+    applyConnectorVisibility(svg, connectorUpdates);
+}
+function applyElementVisibility(svg, elements) {
+    for (const element of elements) {
+        const state = getElementState(svg, element.id);
+        if (!state)
+            continue;
+        if (element.presence === "removed") {
+            state.isHidden = true;
+            hideElementAfterExit(state.node);
+        }
+        else if (state.isHidden) {
+            state.isHidden = false;
+            unhideElementOnReadd(state.node);
+        }
+    }
+}
+function applyConnectorVisibility(svg, connectors) {
+    for (const connector of connectors) {
+        const state = getConnectorState(svg, connector.id);
+        if (!state)
+            continue;
+        if (connector.presence === "removed") {
+            state.isHidden = true;
+            hideElementAfterExit(state.node);
+        }
+        else if (state.isHidden) {
+            state.isHidden = false;
+            unhideElementOnReadd(state.node);
+        }
+    }
+}
+// ── Step 4-5: clone and prepare ────────────────────────────────────────────
+function prepareClone(svg, options) {
+    const clone = svg.cloneNode(true);
+    const viewBox = readViewBox(clone);
+    clone.setAttribute("width", String(viewBox.width));
+    clone.setAttribute("height", String(viewBox.height));
+    clone.setAttribute("xmlns", SVG_NAMESPACE);
+    clone.setAttribute("xmlns:xlink", XLINK_NAMESPACE);
+    if (options.background) {
+        const rect = document.createElementNS(SVG_NAMESPACE, "rect");
+        rect.setAttribute("x", String(viewBox.minX));
+        rect.setAttribute("y", String(viewBox.minY));
+        rect.setAttribute("width", String(viewBox.width));
+        rect.setAttribute("height", String(viewBox.height));
+        rect.setAttribute("fill", options.background);
+        insertAsFirstChild(clone, rect);
+    }
+    const diagnosticsOverlay = clone.querySelector(DIAGNOSTICS_OVERLAY_SELECTOR);
+    diagnosticsOverlay?.parentNode?.removeChild(diagnosticsOverlay);
+    return clone;
+}
+function insertAsFirstChild(parent, child) {
+    if (parent.firstChild) {
+        parent.insertBefore(child, parent.firstChild);
+    }
+    else {
+        parent.appendChild(child);
+    }
+}
+function readViewBox(svg) {
+    const raw = svg.getAttribute("viewBox");
+    const parts = (raw ?? "").trim().split(/\s+/).map(Number);
+    if (parts.length !== 4 || parts.some((part) => !Number.isFinite(part))) {
+        return { minX: 0, minY: 0, width: 0, height: 0 };
+    }
+    const [minX, minY, width, height] = parts;
+    return { minX, minY, width, height };
+}
+// ── Step 6: asset inlining ──────────────────────────────────────────────────
+async function inlineImageAssets(clone) {
+    const images = [...clone.querySelectorAll("image")];
+    await Promise.all(images.map((image) => inlineImageHref(image)));
+}
+async function inlineImageHref(image) {
+    const href = image.getAttribute("href") ?? image.getAttributeNS(XLINK_NAMESPACE, "href");
+    if (!href || href.startsWith("data:"))
+        return;
+    const dataUri = await fetchAsDataUri(href);
+    image.setAttribute("href", dataUri);
+    image.setAttributeNS(XLINK_NAMESPACE, "href", dataUri);
+}
+async function fetchAsDataUri(url) {
+    let response;
+    try {
+        response = await fetch(url);
+    }
+    catch {
+        throw new RenderError("EXPORT_ASSET_FETCH_FAILED", `Failed to fetch asset for inlining: ${url}`, { url });
+    }
+    if (!response.ok) {
+        throw new RenderError("EXPORT_ASSET_FETCH_FAILED", `Failed to fetch asset for inlining: ${url}`, { url });
+    }
+    const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+    const buffer = await response.arrayBuffer();
+    return `data:${contentType};base64,${arrayBufferToBase64(buffer)}`;
+}
+function arrayBufferToBase64(buffer) {
+    let binary = "";
+    const bytes = new Uint8Array(buffer);
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+// ── Step 7: SVG serialization ───────────────────────────────────────────────
+function serializeSvg(clone) {
+    const serializer = new XMLSerializer();
+    return `<?xml version="1.0" encoding="UTF-8"?>\n${serializer.serializeToString(clone)}`;
+}
+// ── Step 8: PNG rasterization ────────────────────────────────────────────────
+async function rasterize(svgString, viewBox, scale) {
+    const width = Math.ceil(viewBox.width * scale);
+    const height = Math.ceil(viewBox.height * scale);
+    const svgBlob = new Blob([svgString], { type: "image/svg+xml" });
+    const objectUrl = URL.createObjectURL(svgBlob);
+    try {
+        const image = await loadImage(objectUrl);
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        const context = canvas.getContext("2d");
+        if (!context) {
+            throw new RenderError("EXPORT_RASTERIZE_FAILED", "Canvas 2D context is unavailable");
+        }
+        context.drawImage(image, 0, 0, width, height);
+        const blob = await new Promise((resolve) => {
+            canvas.toBlob(resolve, "image/png");
+        });
+        if (!blob) {
+            throw new RenderError("EXPORT_RASTERIZE_FAILED", "Canvas failed to encode PNG output");
+        }
+        return blob;
+    }
+    finally {
+        URL.revokeObjectURL(objectUrl);
+    }
+}
+function loadImage(src) {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new RenderError("EXPORT_RASTERIZE_FAILED", "Failed to load rasterization source image"));
+        image.src = src;
+    });
+}
+
+export { RenderError, attachDiagnosticsOverlay, exportScenePng, exportSceneSvg, guardEntryAnimation, guardExitAnimation, guardLifecycleStatus, projectToScreen };
 //# sourceMappingURL=index.js.map