@sebastianwessel/isostate 0.4.0 → 0.6.0

package/dist/chunks/index-C3qcXbPI.js

@@ -1,1542 +0,0 @@
-import { o as getResolvedViewBox, k as getCurrentElementBounds, m as getGridAreaBounds, t as updateElementTransforms, b as applySceneViewBox, l as getElementState, u as unhideElementOnReadd, p as hideElementAfterExit, j as getConnectorState, a as animateElement, d as buildSceneDOM, s as resolveTheme } from './rendering-engine-BUUV3Qq-.js';
-import { C as ControllerError, R as RenderError } from './errors-DyqEkrm5.js';
-import { s as sha256 } from './sha256-4JuurR-b.js';
-
-/**
- * Animation engine — resolves progress against compiled RuntimeBundle scene stops.
- *
- * The engine does not manipulate DOM. It computes interpolation data and lifecycle
- * transitions that the controller applies to the rendering engine.
- */
-class AnimationEngine {
-    _bundle = null;
-    _progress = 0;
-    _paused = false;
-    _prevFrameMap = new Map();
-    _elementFrameMap = new Map();
-    _prevConnectorFrameMap = new Map();
-    _connectorFrameMap = new Map();
-    get bundle() {
-        return this._bundle;
-    }
-    get progress() {
-        return this._progress;
-    }
-    getProgress() {
-        return this._progress;
-    }
-    get paused() {
-        return this._paused;
-    }
-    isPaused() {
-        return this._paused;
-    }
-    get elementsCount() {
-        return this._elementFrameMap.size;
-    }
-    get connectorsCount() {
-        return this._connectorFrameMap.size;
-    }
-    /** Initialize with a compiled runtime bundle. */
-    init(bundle) {
-        this._bundle = bundle;
-        this._progress = 0;
-        this._paused = false;
-        this._prevFrameMap.clear();
-        this._elementFrameMap.clear();
-        this._prevConnectorFrameMap.clear();
-        this._connectorFrameMap.clear();
-        const initial = resolveFrameMap(bundle, 0);
-        this._elementFrameMap = initial;
-        this._prevFrameMap = cloneFrameMap(initial);
-        const initialConnectors = resolveConnectorFrameMap(bundle, 0);
-        this._connectorFrameMap = initialConnectors;
-        this._prevConnectorFrameMap = cloneConnectorFrameMap(initialConnectors);
-    }
-    /** Set current scroll progress (0-1) and compute frame update. */
-    setProgress(progress) {
-        const clamped = Math.max(0, Math.min(1, progress));
-        if (this._paused)
-            return;
-        this._progress = clamped;
-        if (!this._bundle)
-            return;
-        this._prevFrameMap = cloneFrameMap(this._elementFrameMap);
-        this._elementFrameMap = resolveFrameMap(this._bundle, clamped);
-        this._prevConnectorFrameMap = cloneConnectorFrameMap(this._connectorFrameMap);
-        this._connectorFrameMap = resolveConnectorFrameMap(this._bundle, clamped);
-    }
-    /** Get interpolated FrameUpdate for an element id or runtime element. */
-    getElementUpdate(element) {
-        const id = typeof element === "string" ? element : element.id;
-        const frame = this._elementFrameMap.get(id);
-        if (!frame) {
-            return {
-                id,
-                asset: "",
-                lifecycle: "removed",
-                ambient: [],
-                pos: [0, 0],
-                size: 1,
-                layer: "",
-            };
-        }
-        return frameToUpdate(frame);
-    }
-    getFrameUpdates() {
-        return [...this._elementFrameMap.values()].map(frameToUpdate);
-    }
-    /** Get interpolated ConnectorFrameUpdate for a connector id or runtime connector. */
-    getConnectorUpdate(connector) {
-        const id = typeof connector === "string" ? connector : connector.id;
-        const frame = this._connectorFrameMap.get(id);
-        if (!frame)
-            return connectorFrameToUpdate(removedConnectorFrame(id));
-        return connectorFrameToUpdate(frame);
-    }
-    getConnectorFrameUpdates() {
-        return [...this._connectorFrameMap.values()].map(connectorFrameToUpdate);
-    }
-    /** Compute lifecycle transition between previous and current frame. */
-    getLifecycleTransition(elId) {
-        const prev = this._prevFrameMap.get(elId);
-        const current = this._elementFrameMap.get(elId);
-        const from = (prev?.lifecycle ?? "removed");
-        const to = (current?.lifecycle ?? "removed");
-        if (from === to)
-            return null;
-        return {
-            from,
-            to,
-        };
-    }
-    /** Compute lifecycle transition between previous and current connector frame. */
-    getConnectorLifecycleTransition(connectorId) {
-        const prev = this._prevConnectorFrameMap.get(connectorId);
-        const current = this._connectorFrameMap.get(connectorId);
-        const from = (prev?.lifecycle ?? "removed");
-        const to = (current?.lifecycle ?? "removed");
-        if (from === to)
-            return null;
-        return {
-            from,
-            to,
-        };
-    }
-    getCurrentState() {
-        const bundle = this._bundle;
-        if (!bundle)
-            return null;
-        const pair = findSurroundingStops(bundle.scenes, this._progress);
-        return pair?.nextStop ?? bundle.scenes[0] ?? null;
-    }
-    pause() {
-        this._paused = true;
-    }
-    resume() {
-        this._paused = false;
-    }
-    destroy() {
-        this._bundle = null;
-        this._progress = 0;
-        this._paused = false;
-        this._elementFrameMap.clear();
-        this._prevFrameMap.clear();
-        this._connectorFrameMap.clear();
-        this._prevConnectorFrameMap.clear();
-    }
-}
-// ── Interpolation helpers ──────────────────────────────────────────────────
-function resolveFrameMap(bundle, progress) {
-    const pair = findSurroundingStops(bundle.scenes, progress);
-    const result = new Map();
-    if (!pair)
-        return result;
-    const ids = new Set();
-    for (const stop of bundle.scenes) {
-        for (const element of stop.elements ?? [])
-            ids.add(element.id);
-    }
-    for (const element of pair.prevStop.elements ?? [])
-        ids.add(element.id);
-    for (const element of pair.nextStop.elements ?? [])
-        ids.add(element.id);
-    for (const id of ids) {
-        const frame = withRemovedElementGeometry(interpolateElement(id, pair.prevStop, pair.nextStop, pair.t), bundle.scenes, id, progress);
-        result.set(id, frame);
-    }
-    return result;
-}
-function resolveConnectorFrameMap(bundle, progress) {
-    const pair = findSurroundingStops(bundle.scenes, progress);
-    const result = new Map();
-    if (!pair)
-        return result;
-    const ids = new Set();
-    for (const stop of bundle.scenes) {
-        for (const connector of stop.connectors ?? [])
-            ids.add(connector.id);
-    }
-    for (const connector of pair.prevStop.connectors ?? [])
-        ids.add(connector.id);
-    for (const connector of pair.nextStop.connectors ?? [])
-        ids.add(connector.id);
-    for (const id of ids) {
-        const frame = interpolateConnector(id, pair.prevStop, pair.nextStop, pair.t);
-        result.set(id, frame);
-    }
-    return result;
-}
-function findSurroundingStops(stops, progress) {
-    if (stops.length === 0)
-        return null;
-    const sorted = [...stops].sort((a, b) => a.progress - b.progress);
-    if (sorted.length === 1 || progress <= sorted[0].progress) {
-        return { prevStop: sorted[0], nextStop: sorted[0], t: 0, nextIndex: 0 };
-    }
-    const lastIndex = sorted.length - 1;
-    if (progress >= sorted[lastIndex].progress) {
-        return {
-            prevStop: sorted[lastIndex - 1] ?? sorted[lastIndex],
-            nextStop: sorted[lastIndex],
-            t: 1,
-            nextIndex: lastIndex,
-        };
-    }
-    for (let i = 1; i < sorted.length; i++) {
-        const nextStop = sorted[i];
-        if (nextStop.progress >= progress) {
-            const prevStop = sorted[i - 1];
-            const range = nextStop.progress - prevStop.progress;
-            const t = range > 0 ? (progress - prevStop.progress) / range : 0;
-            return { prevStop, nextStop, t, nextIndex: i };
-        }
-    }
-    return null;
-}
-function interpolateElement(id, prevStop, nextStop, t) {
-    const prev = findElement(prevStop, id);
-    const next = findElement(nextStop, id);
-    const source = next ?? prev;
-    if (!source) {
-        return removedFrame(id);
-    }
-    if (!prev || prev.presence === "removed") {
-        return frameFromElement(source, source.presence === "removed" || t < 1 ? "removed" : source.presence);
-    }
-    if (!next || next.presence === "removed") {
-        return frameFromElement(prev, t < 1 ? prev.presence : "removed");
-    }
-    const lifecycle = t < 1 ? prev.presence : next.presence;
-    return {
-        id,
-        asset: next.asset,
-        pos: interpolatePos(prev.pos, next.pos, t),
-        size: prev.size + (next.size - prev.size) * t,
-        lifecycle,
-        ambient: cloneAmbient(next.ambient),
-        layer: t < 1 ? prev.layer : next.layer,
-        entry: next.enter ?? prev.enter,
-        exit: next.exit ?? prev.exit,
-        text: cloneText(next.text ?? prev.text),
-        primitive: clonePrimitive(next.primitive ?? prev.primitive),
-    };
-}
-function interpolateConnector(id, prevStop, nextStop, t) {
-    const prev = findConnector(prevStop, id);
-    const next = findConnector(nextStop, id);
-    const source = next ?? prev;
-    if (!source)
-        return removedConnectorFrame(id);
-    if (!prev || prev.presence === "removed") {
-        return frameFromConnector(source, source.presence === "removed" || t < 1 ? "removed" : source.presence);
-    }
-    if (!next || next.presence === "removed") {
-        return frameFromConnector(prev, t < 1 ? prev.presence : "removed");
-    }
-    const lifecycle = t < 1 ? prev.presence : next.presence;
-    return {
-        id,
-        route: interpolateRoute(prev.route, next.route, t),
-        layer: t < 1 ? prev.layer : next.layer,
-        lifecycle,
-        style: cloneConnectorStyle(t < 1 ? prev.style : next.style),
-        start: next.start,
-        end: next.end,
-        direction: next.direction,
-        ambient: cloneAmbient(next.ambient),
-        entry: next.enter ?? prev.enter,
-        exit: next.exit ?? prev.exit,
-    };
-}
-function findElement(stop, id) {
-    return (stop.elements ?? []).find((element) => element.id === id);
-}
-function findConnector(stop, id) {
-    return (stop.connectors ?? []).find((connector) => connector.id === id);
-}
-function withRemovedElementGeometry(frame, stops, id, progress) {
-    if (frame.lifecycle !== "removed")
-        return frame;
-    const reference = findNearestElementGeometry(stops, id, progress);
-    if (!reference)
-        return frame;
-    return {
-        ...frame,
-        asset: reference.asset,
-        pos: [...reference.pos],
-        size: reference.size,
-        ambient: cloneAmbient(reference.ambient),
-        layer: reference.layer,
-        entry: reference.enter,
-        exit: reference.exit,
-        text: cloneText(reference.text),
-        primitive: clonePrimitive(reference.primitive),
-    };
-}
-function findNearestElementGeometry(stops, id, progress) {
-    const sorted = [...stops].sort((a, b) => a.progress - b.progress);
-    const next = sorted
-        .filter((stop) => stop.progress >= progress)
-        .flatMap((stop) => stop.elements ?? [])
-        .find((element) => element.id === id && element.presence !== "removed");
-    if (next)
-        return next;
-    for (let index = sorted.length - 1; index >= 0; index -= 1) {
-        if (sorted[index].progress > progress)
-            continue;
-        const previous = (sorted[index].elements ?? []).find((element) => element.id === id && element.presence !== "removed");
-        if (previous)
-            return previous;
-    }
-    return undefined;
-}
-function frameFromElement(element, lifecycle = element.presence) {
-    return {
-        id: element.id,
-        asset: element.asset,
-        pos: [...element.pos],
-        size: element.size,
-        lifecycle,
-        ambient: cloneAmbient(element.ambient),
-        layer: element.layer,
-        entry: element.enter,
-        exit: element.exit,
-        text: cloneText(element.text),
-        primitive: clonePrimitive(element.primitive),
-    };
-}
-function frameFromConnector(connector, lifecycle = connector.presence) {
-    return {
-        id: connector.id,
-        route: cloneRoute(connector.route),
-        layer: connector.layer,
-        lifecycle,
-        style: cloneConnectorStyle(connector.style),
-        start: connector.start,
-        end: connector.end,
-        direction: connector.direction,
-        ambient: cloneAmbient(connector.ambient),
-        entry: connector.enter,
-        exit: connector.exit,
-    };
-}
-function removedFrame(id) {
-    return {
-        id,
-        asset: "",
-        pos: [0, 0],
-        size: 1,
-        lifecycle: "removed",
-        ambient: [],
-        layer: "",
-    };
-}
-function removedConnectorFrame(id) {
-    return {
-        id,
-        route: [],
-        layer: "",
-        lifecycle: "removed",
-        style: {
-            variant: "line",
-            pattern: "solid",
-            stroke: "#2563eb",
-            strokeWidth: 3,
-            opacity: 1,
-            outlineWidth: 0,
-            lane: "none",
-        },
-        start: "none",
-        end: "none",
-        direction: "route",
-        ambient: [],
-    };
-}
-function interpolatePos(prev, next, t) {
-    return [prev[0] + (next[0] - prev[0]) * t, prev[1] + (next[1] - prev[1]) * t];
-}
-function interpolateRoute(prev, next, t) {
-    if (prev.length !== next.length)
-        return cloneRoute(t < 1 ? prev : next);
-    return prev.map((point, index) => interpolatePos(point, next[index], t));
-}
-function cloneRoute(route) {
-    return route.map((point) => [point[0], point[1]]);
-}
-function cloneConnectorStyle(style) {
-    return {
-        ...style,
-        ...(style.dash ? { dash: [...style.dash] } : {}),
-    };
-}
-function cloneAmbient(ambient) {
-    return (ambient ?? []).map((item) => ({ ...item }));
-}
-function frameToUpdate(frame) {
-    return {
-        id: frame.id,
-        asset: frame.asset,
-        lifecycle: frame.lifecycle,
-        ambient: cloneAmbient(frame.ambient),
-        pos: [...frame.pos],
-        size: frame.size,
-        layer: frame.layer,
-        entry: frame.entry,
-        exit: frame.exit,
-        text: cloneText(frame.text),
-        primitive: clonePrimitive(frame.primitive),
-    };
-}
-function connectorFrameToUpdate(frame) {
-    return {
-        id: frame.id,
-        route: cloneRoute(frame.route),
-        layer: frame.layer,
-        lifecycle: frame.lifecycle,
-        style: cloneConnectorStyle(frame.style),
-        start: frame.start,
-        end: frame.end,
-        direction: frame.direction,
-        ambient: cloneAmbient(frame.ambient),
-        entry: frame.entry,
-        exit: frame.exit,
-    };
-}
-function cloneFrameMap(map) {
-    const clone = new Map();
-    for (const [id, frame] of map) {
-        clone.set(id, {
-            ...frame,
-            pos: [...frame.pos],
-            ambient: cloneAmbient(frame.ambient),
-            text: cloneText(frame.text),
-            primitive: clonePrimitive(frame.primitive),
-        });
-    }
-    return clone;
-}
-function cloneText(text) {
-    return text ? { ...text } : undefined;
-}
-function clonePrimitive(primitive) {
-    if (!primitive)
-        return undefined;
-    return {
-        ...(primitive.rectangle
-            ? {
-                rectangle: {
-                    ...primitive.rectangle,
-                    dash: cloneDash(primitive.rectangle.dash),
-                },
-            }
-            : {}),
-        ...(primitive.circle
-            ? {
-                circle: {
-                    ...primitive.circle,
-                    dash: cloneDash(primitive.circle.dash),
-                },
-            }
-            : {}),
-        ...(primitive.polygon
-            ? {
-                polygon: {
-                    ...primitive.polygon,
-                    dash: cloneDash(primitive.polygon.dash),
-                    points: cloneRoute(primitive.polygon.points),
-                },
-            }
-            : {}),
-        ...(primitive.line
-            ? {
-                line: {
-                    ...primitive.line,
-                    dash: cloneDash(primitive.line.dash),
-                    points: cloneRoute(primitive.line.points),
-                },
-            }
-            : {}),
-    };
-}
-function cloneDash(dash) {
-    return dash ? [dash[0], dash[1]] : undefined;
-}
-function cloneConnectorFrameMap(map) {
-    const clone = new Map();
-    for (const [id, frame] of map) {
-        clone.set(id, {
-            ...frame,
-            route: cloneRoute(frame.route),
-            style: cloneConnectorStyle(frame.style),
-            ambient: cloneAmbient(frame.ambient),
-        });
-    }
-    return clone;
-}
-
-/**
- * Linear easing (no interpolation).
- */
-function linear(t) {
-    return t;
-}
-/**
- * Cubic ease-in: starts slowly, accelerates.
- */
-function easeInCubic(t) {
-    return t * t * t;
-}
-/**
- * Cubic ease-out: starts fast, decelerates.
- */
-function easeOutCubic(t) {
-    return 1 - (1 - t) ** 3;
-}
-/**
- * Cubic ease-in-out: slow start, fast middle, slow end.
- */
-function easeInOutCubic(t) {
-    return t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
-}
-/**
- * Resolve an easing type string to a function.
- */
-function resolveEasing(type) {
-    switch (type) {
-        case "linear":
-            return linear;
-        case "easeInCubic":
-            return easeInCubic;
-        case "easeOutCubic":
-            return easeOutCubic;
-        case "easeInOutCubic":
-            return easeInOutCubic;
-    }
-}
-
-const DEFAULT_CONFIG = {
-    scrollDirection: "vertical",
-    scrollOffset: {},
-    minProgress: 0,
-    maxProgress: 1,
-    keyboardControls: false,
-    touchControls: false,
-    scrollSensitivity: 1.0,
-    transitionDuration: 600,
-    transitionEasing: "ease-in-out",
-};
-// ── Controller implementation ──────────────────────────────────────────────
-/**
- * Animation controller — manages scroll progress, scene navigation,
- * and delegates to the animation engine for frame updates.
- */
-class AnimationController {
-    _engine = new AnimationEngine();
-    _bundle = null;
-    _sceneIndex = 0;
-    _progress = 0;
-    _paused = false;
-    _config = DEFAULT_CONFIG;
-    _container = null;
-    _sceneElement = null;
-    _ownsEngine = true;
-    _rafId = null;
-    _pendingProgress = null;
-    _destroyed = false;
-    _listeners = new Map();
-    _cameraAnim = null;
-    _cameraState = null;
-    // Scroll tracking state
-    _minScroll = 0;
-    _maxScroll = 0;
-    _touchStartY = 0;
-    _touchStartX = 0;
-    _isDragging = false;
-    // Transition animation state
-    _transitionAnim = null;
-    get engine() {
-        return this._engine;
-    }
-    get progress() {
-        return this._progress;
-    }
-    getProgress() {
-        this._assertNotDestroyed();
-        return this._progress;
-    }
-    get sceneIndex() {
-        return this._sceneIndex;
-    }
-    getSceneIndex() {
-        this._assertNotDestroyed();
-        return this._sceneIndex;
-    }
-    get scenes() {
-        return this._bundle?.scenes ?? [];
-    }
-    get paused() {
-        return this._paused;
-    }
-    get currentScene() {
-        return this.scenes[this._sceneIndex];
-    }
-    /**
-     * Initialize the controller with a compiled bundle and optional runtime resources.
-     */
-    init(bundle, config = {}, runtime = {}) {
-        this._assertNotDestroyed();
-        if (!bundle.scenes || bundle.scenes.length === 0) {
-            throw new ControllerError("CONTROLLER_NO_SCENES", "init() requires at least one compiled scene stop");
-        }
-        this._cancelFrame();
-        this._bundle = bundle;
-        this._engine = runtime.engine ?? new AnimationEngine();
-        this._ownsEngine = !runtime.engine;
-        this._sceneIndex = 0;
-        this._progress = 0;
-        this._paused = false;
-        this._config = { ...DEFAULT_CONFIG, ...config };
-        this._sceneElement = runtime.sceneElement ?? config.sceneElement ?? null;
-        this._cameraState = {
-            viewBox: getResolvedViewBox(bundle),
-            target: { type: "reset" },
-            isZoomed: false,
-        };
-        this._engine.init(bundle);
-        this._bindScroll();
-    }
-    /**
-     * Set scroll progress (0–1, clamped) and trigger frame update.
-     */
-    setProgress(progress) {
-        this._assertNotDestroyed();
-        if (!Number.isFinite(progress)) {
-            throw new ControllerError("CONTROLLER_PROGRESS_OUT_OF_RANGE", "setProgress() requires a finite progress value");
-        }
-        const clamped = Math.max(0, Math.min(1, progress));
-        if (clamped === this._progress && !this._paused && this._rafId !== null) {
-            return;
-        }
-        this._progress = clamped;
-        this._cancelCameraAnimation();
-        if (this._paused)
-            return;
-        this._scheduleProgressForward(clamped);
-    }
-    /**
-     * Navigate to next scene (wraps to 0 if at end).
-     */
-    nextScene() {
-        this._assertNotDestroyed();
-        if (this.scenes.length <= 1)
-            return;
-        const nextIndex = (this._sceneIndex + 1) % this.scenes.length;
-        this._transitionToScene(nextIndex);
-    }
-    /**
-     * Navigate to previous scene (wraps to last if at beginning).
-     */
-    prevScene() {
-        this._assertNotDestroyed();
-        if (this.scenes.length <= 1)
-            return;
-        const prevIndex = (this._sceneIndex - 1 + this.scenes.length) % this.scenes.length;
-        this._transitionToScene(prevIndex);
-    }
-    /**
-     * Set scene index directly.
-     */
-    setSceneIndex(index) {
-        this._assertNotDestroyed();
-        if (index < 0 || index >= this.scenes.length) {
-            throw new ControllerError("CONTROLLER_SCENE_INDEX_OUT_OF_RANGE", `Scene index ${index} is out of bounds [0, ${this.scenes.length - 1}]`);
-        }
-        this._transitionToScene(index);
-    }
-    /**
-     * Pause all animations.
-     */
-    pause() {
-        this._assertNotDestroyed();
-        if (this._paused)
-            return;
-        this._paused = true;
-        this._cancelFrame();
-        this._engine.pause();
-        this._applyPauseState(true);
-        this._emit("paused");
-    }
-    /**
-     * Resume from paused state.
-     */
-    resume() {
-        this._assertNotDestroyed();
-        if (!this._paused)
-            return;
-        this._paused = false;
-        this._engine.resume();
-        this._applyPauseState(false);
-        this._scheduleProgressForward(this._progress);
-        this._emit("resumed");
-    }
-    /**
-     * Check if controller is paused.
-     */
-    isPaused() {
-        this._assertNotDestroyed();
-        return this._paused;
-    }
-    zoomToElement(id, options = {}) {
-        this._assertNotDestroyed();
-        const svg = this._getSceneSvg();
-        if (!this._bundle || !svg) {
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "zoomToElement() requires an initialized scene SVG");
-        }
-        const elementBounds = getCurrentElementBounds(svg, id);
-        if (!elementBounds) {
-            throw new ControllerError("CAMERA_TARGET_NOT_FOUND", `Camera target element "${id}" was not found`, {
-                elementId: id,
-            });
-        }
-        this._applyCameraDestination(expandViewBox(elementBounds, this._resolveCameraPadding(options)), { type: "element", id }, options);
-    }
-    zoomToArea(area, options = {}) {
-        this._assertNotDestroyed();
-        if (!this._bundle || !this._getSceneSvg()) {
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "zoomToArea() requires an initialized scene SVG");
-        }
-        this._assertValidCameraArea(area);
-        const bounds = getGridAreaBounds(this._bundle, area);
-        this._applyCameraDestination(expandViewBox(bounds, this._resolveCameraPadding(options)), {
-            type: "area",
-            at: [...area.at],
-            size: [...area.size],
-        }, options);
-    }
-    resetZoom(options = {}) {
-        this._assertNotDestroyed();
-        if (!this._bundle || !this._getSceneSvg()) {
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "resetZoom() requires an initialized scene SVG");
-        }
-        this._applyCameraDestination(getResolvedViewBox(this._bundle), { type: "reset" }, options);
-    }
-    getCameraState() {
-        this._assertNotDestroyed();
-        if (!this._cameraState) {
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "Camera state is not initialized");
-        }
-        return copyCameraState(this._cameraState);
-    }
-    /**
-     * Destroy controller and clean up all listeners and resources.
-     */
-    destroy() {
-        this._assertNotDestroyed();
-        this._unbindScroll();
-        this._cancelFrame();
-        this._cancelTransition();
-        this._cancelCameraAnimation();
-        if (this._ownsEngine)
-            this._engine.destroy();
-        this._listeners.clear();
-        this._bundle = null;
-        this._container = null;
-        this._pendingProgress = null;
-        this._cameraState = null;
-        this._destroyed = true;
-    }
-    // ── Event system ───────────────────────────────────────────────────────
-    on(event, listener) {
-        this._assertNotDestroyed();
-        const set = this._listeners.get(event) ?? new Set();
-        set.add(listener);
-        this._listeners.set(event, set);
-    }
-    off(event, listener) {
-        this._assertNotDestroyed();
-        const set = this._listeners.get(event);
-        if (set) {
-            set.delete(listener);
-        }
-    }
-    _emit(event, ...args) {
-        const set = this._listeners.get(event);
-        if (set) {
-            for (const listener of set) {
-                try {
-                    listener(...args);
-                }
-                catch (error) {
-                    queueMicrotask(() => {
-                        throw error;
-                    });
-                }
-            }
-        }
-    }
-    // ── Frame update ───────────────────────────────────────────────────────
-    _scheduleProgressForward(progress) {
-        this._pendingProgress = progress;
-        if (this._rafId !== null)
-            return;
-        this._rafId = requestAnimationFrame(() => {
-            this._rafId = null;
-            const pending = this._pendingProgress;
-            this._pendingProgress = null;
-            if (pending === null || this._paused || this._destroyed)
-                return;
-            this._engine.setProgress(pending);
-            this._applyFrameUpdate();
-            this._emit("progress-change", pending);
-        });
-    }
-    _cancelFrame() {
-        if (this._rafId !== null) {
-            cancelAnimationFrame(this._rafId);
-            this._rafId = null;
-        }
-        this._pendingProgress = null;
-    }
-    _applyFrameUpdate() {
-        if (!this._bundle)
-            return;
-        const svg = (this._sceneElement ?? this._container?.querySelector("svg") ?? null);
-        if (!svg)
-            return;
-        const updates = this._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 = this._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, updates, connectors);
-        this._applyLifecycleChanges(updates);
-        this._applyConnectorLifecycleChanges(connectors);
-        this._applyCameraForProgress(this._progress);
-    }
-    _applyCameraForProgress(progress) {
-        const svg = this._getSceneSvg();
-        if (!this._bundle || !svg)
-            return;
-        const sceneStops = this.scenes;
-        if (sceneStops.length === 0)
-            return;
-        const { previous, next } = surroundingStops(sceneStops, progress);
-        const previousCamera = this._effectiveCameraAt(previous.index);
-        const nextCamera = this._effectiveCameraAt(next.index);
-        const previousViewBox = this._resolveCameraViewBox(previousCamera);
-        const nextViewBox = this._resolveCameraViewBox(nextCamera);
-        const range = next.scene.progress - previous.scene.progress;
-        const rawT = range <= 0 ? 0 : (progress - previous.scene.progress) / range;
-        const t = resolveCameraEasing(nextCamera.easing)(Math.max(0, Math.min(1, rawT)));
-        const viewBox = lerpViewBox(previousViewBox, nextViewBox, t);
-        const target = t < 1 ? previousCamera.target : nextCamera.target;
-        this._setCameraViewBox(svg, viewBox, target);
-    }
-    _effectiveCameraAt(index) {
-        for (let i = index; i >= 0; i--) {
-            const camera = this.scenes[i]?.camera;
-            if (camera) {
-                return {
-                    target: camera.target,
-                    padding: camera.padding,
-                    duration: camera.duration,
-                    easing: camera.easing,
-                };
-            }
-        }
-        return { target: { type: "reset" } };
-    }
-    _resolveCameraViewBox(camera) {
-        if (!this._bundle)
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "Camera requires an initialized bundle");
-        if (camera.target.type === "reset")
-            return getResolvedViewBox(this._bundle);
-        if (camera.target.type === "area") {
-            return expandViewBox(getGridAreaBounds(this._bundle, { at: camera.target.at, size: camera.target.size }), camera.padding ?? 32);
-        }
-        const svg = this._getSceneSvg();
-        if (!svg)
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "Camera requires an initialized scene SVG");
-        const bounds = getCurrentElementBounds(svg, camera.target.id);
-        if (!bounds) {
-            throw new ControllerError("CAMERA_TARGET_NOT_FOUND", `Camera target element "${camera.target.id}" was not found`, {
-                elementId: camera.target.id,
-            });
-        }
-        return expandViewBox(bounds, camera.padding ?? 32);
-    }
-    _applyCameraDestination(viewBox, target, options) {
-        const svg = this._getSceneSvg();
-        if (!svg)
-            throw new ControllerError("CAMERA_NOT_INITIALIZED", "Camera requires an initialized scene SVG");
-        this._cancelCameraAnimation();
-        const duration = this._resolveCameraDuration(options);
-        if (duration === 0) {
-            this._setCameraViewBox(svg, viewBox, target);
-            return;
-        }
-        const from = currentSvgViewBox(svg) ?? this._cameraState?.viewBox ?? viewBox;
-        const easing = resolveCameraEasing(options.easing ?? this._config.transitionEasing);
-        const start = performance.now();
-        const step = (now) => {
-            const t = Math.min((now - start) / duration, 1);
-            this._setCameraViewBox(svg, lerpViewBox(from, viewBox, easing(t)), target);
-            if (t < 1) {
-                this._cameraAnim = requestAnimationFrame(step);
-            }
-            else {
-                this._cameraAnim = null;
-            }
-        };
-        this._cameraAnim = requestAnimationFrame(step);
-    }
-    _setCameraViewBox(svg, viewBox, target) {
-        applySceneViewBox(svg, viewBox);
-        const full = this._bundle ? getResolvedViewBox(this._bundle) : viewBox;
-        this._cameraState = {
-            viewBox,
-            target,
-            isZoomed: !sameViewBox(viewBox, full),
-        };
-        this._emit("camera-change", this.getCameraState());
-    }
-    _getSceneSvg() {
-        return (this._sceneElement ?? this._container?.querySelector("svg") ?? null);
-    }
-    _resolveCameraPadding(options) {
-        const padding = options.padding ?? 32;
-        if (!Number.isFinite(padding) || padding < 0 || padding > 2048) {
-            throw new ControllerError("INVALID_CAMERA_OPTIONS", "Camera padding must be between 0 and 2048");
-        }
-        return padding;
-    }
-    _resolveCameraDuration(options) {
-        const duration = options.duration ?? this._config.transitionDuration;
-        if (!Number.isInteger(duration) || duration < 0 || duration > 10000) {
-            throw new ControllerError("INVALID_CAMERA_OPTIONS", "Camera duration must be an integer from 0 to 10000");
-        }
-        return duration;
-    }
-    _assertValidCameraArea(area) {
-        if (!Array.isArray(area.at) ||
-            area.at.length !== 2 ||
-            !area.at.every((value) => Number.isFinite(value) && value >= 0) ||
-            !Array.isArray(area.size) ||
-            area.size.length !== 2 ||
-            !area.size.every((value) => Number.isFinite(value) && value > 0)) {
-            throw new ControllerError("INVALID_CAMERA_OPTIONS", "Camera area must use non-negative at and positive size");
-        }
-    }
-    _applyLifecycleChanges(elements) {
-        for (const elDef of elements) {
-            const transition = this._engine.getLifecycleTransition(elDef.id);
-            if (!transition)
-                continue;
-            const svgForState = (this._sceneElement ?? this._container?.querySelector("svg"));
-            if (!svgForState)
-                continue;
-            const state = getElementState(svgForState, elDef.id);
-            if (!state)
-                continue;
-            if (transition.to === "entering" || transition.to === "present") {
-                state.isHidden = false;
-                unhideElementOnReadd(state.node);
-            }
-            if (isForwardEntryTransition(transition)) {
-                this._applyEntryAnimation(elDef, state);
-            }
-            if (isReverseExitTransition(transition)) {
-                this._applyExitAnimation({ ...elDef, exit: oppositeExitAnimation(elDef.enter ?? "fade-in") }, state);
-                continue;
-            }
-            if (isForwardExitTransition(transition)) {
-                this._applyExitAnimation(elDef, state);
-            }
-            if (isReverseEntryTransition(transition)) {
-                state.isHidden = false;
-                unhideElementOnReadd(state.node);
-                this._applyEntryAnimation({ ...elDef, enter: oppositeEntryAnimation(elDef.exit ?? "fade-out") }, state);
-                continue;
-            }
-            if (transition.to === "removed") {
-                state.isHidden = true;
-                hideElementAfterExit(state.node);
-            }
-        }
-    }
-    _applyConnectorLifecycleChanges(connectors) {
-        for (const connectorDef of connectors) {
-            const transition = this._engine.getConnectorLifecycleTransition(connectorDef.id);
-            if (!transition)
-                continue;
-            const svgForState = (this._sceneElement ?? this._container?.querySelector("svg"));
-            if (!svgForState)
-                continue;
-            const state = getConnectorState(svgForState, connectorDef.id);
-            if (!state)
-                continue;
-            if (transition.to === "entering" || transition.to === "present") {
-                state.isHidden = false;
-                unhideElementOnReadd(state.node);
-            }
-            if (isForwardEntryTransition(transition)) {
-                this._applyConnectorEntryAnimation(connectorDef, state);
-            }
-            if (isReverseExitTransition(transition)) {
-                this._applyConnectorExitAnimation({
-                    ...connectorDef,
-                    exit: oppositeExitAnimation(connectorDef.enter ?? "fade-in"),
-                }, state);
-                continue;
-            }
-            if (isForwardExitTransition(transition)) {
-                this._applyConnectorExitAnimation(connectorDef, state);
-            }
-            if (isReverseEntryTransition(transition)) {
-                state.isHidden = false;
-                unhideElementOnReadd(state.node);
-                this._applyConnectorEntryAnimation({
-                    ...connectorDef,
-                    enter: oppositeEntryAnimation(connectorDef.exit ?? "fade-out"),
-                }, state);
-                continue;
-            }
-            if (transition.to === "removed") {
-                state.isHidden = true;
-                hideElementAfterExit(state.node);
-            }
-        }
-    }
-    _applyEntryAnimation(elDef, state) {
-        const entryAnim = elDef.enter ?? "fade-in";
-        if (entryAnim === "none")
-            return;
-        animateElement(state.node, `iso-anim-${entryAnim}`, "enter");
-        const expectedAnimation = state.node.style.animation;
-        state.node.addEventListener("animationend", () => {
-            if (state.node.style.animation === expectedAnimation) {
-                state.node.style.animation = "";
-            }
-        }, { once: true });
-    }
-    _applyExitAnimation(elDef, state) {
-        const exitAnim = elDef.exit ?? "fade-out";
-        if (exitAnim === "none") {
-            hideElementAfterExit(state.node);
-            return;
-        }
-        animateElement(state.node, `iso-anim-${exitAnim}`, "exit");
-        const expectedAnimation = state.node.style.animation;
-        state.node.addEventListener("animationend", () => {
-            if (state.node.style.animation === expectedAnimation) {
-                hideElementAfterExit(state.node);
-            }
-        }, { once: true });
-    }
-    _applyConnectorEntryAnimation(connectorDef, state) {
-        const entryAnim = connectorDef.enter ?? "fade-in";
-        if (entryAnim === "none")
-            return;
-        animateElement(state.node, `iso-anim-${entryAnim}`, "enter");
-        const expectedAnimation = state.node.style.animation;
-        state.node.addEventListener("animationend", () => {
-            if (state.node.style.animation === expectedAnimation) {
-                state.node.style.animation = "";
-            }
-        }, { once: true });
-    }
-    _applyConnectorExitAnimation(connectorDef, state) {
-        const exitAnim = connectorDef.exit ?? "fade-out";
-        if (exitAnim === "none") {
-            hideElementAfterExit(state.node);
-            return;
-        }
-        animateElement(state.node, `iso-anim-${exitAnim}`, "exit");
-        const expectedAnimation = state.node.style.animation;
-        state.node.addEventListener("animationend", () => {
-            if (state.node.style.animation === expectedAnimation) {
-                hideElementAfterExit(state.node);
-            }
-        }, { once: true });
-    }
-    // ── Scene transitions ──────────────────────────────────────────────────
-    _transitionToScene(index) {
-        this._cancelTransition();
-        if (index === this._sceneIndex)
-            return;
-        this._sceneIndex = index;
-        this._emit("scene-change", index);
-        const stop = this.scenes[index];
-        const from = this._progress;
-        const to = stop.progress;
-        const duration = this._config.transitionDuration;
-        if (duration > 0 && from !== to) {
-            this._animateProgress(from, to, duration);
-            return;
-        }
-        this._progress = to;
-        this._scheduleProgressForward(to);
-    }
-    _animateProgress(from, to, duration) {
-        const easing = resolveEasing((this._config.transitionEasing === "ease-in-out"
-            ? "easeInOutCubic"
-            : this._config.transitionEasing === "ease-out"
-                ? "easeOutCubic"
-                : "linear"));
-        const start = performance.now();
-        const step = (now) => {
-            const elapsed = now - start;
-            const t = Math.min(elapsed / duration, 1);
-            const easedT = easing(t);
-            const currentProgress = from + (to - from) * easedT;
-            this.setProgress(currentProgress);
-            if (t < 1) {
-                this._transitionAnim = requestAnimationFrame(step);
-            }
-            else {
-                this._transitionAnim = null;
-            }
-        };
-        this._transitionAnim = requestAnimationFrame(step);
-    }
-    _cancelTransition() {
-        if (this._transitionAnim !== null) {
-            cancelAnimationFrame(this._transitionAnim);
-            this._transitionAnim = null;
-        }
-    }
-    _cancelCameraAnimation() {
-        if (this._cameraAnim !== null) {
-            cancelAnimationFrame(this._cameraAnim);
-            this._cameraAnim = null;
-        }
-    }
-    // ── Scroll binding ─────────────────────────────────────────────────────
-    _bindScroll() {
-        const container = this._config.container;
-        if (!container)
-            return;
-        this._container = container;
-        this._calculateScrollBounds();
-        container.addEventListener("scroll", this._onScroll, { passive: true });
-        window.addEventListener("resize", this._onResize, { passive: true });
-        if (this._config.keyboardControls) {
-            document.addEventListener("keydown", this._onKeyDown);
-        }
-        if (this._config.touchControls) {
-            container.addEventListener("touchstart", this._onTouchStart, {
-                passive: true,
-            });
-            container.addEventListener("touchmove", this._onTouchMove, {
-                passive: false,
-            });
-            container.addEventListener("touchend", this._onTouchEnd);
-        }
-    }
-    _unbindScroll() {
-        const container = this._config.container;
-        if (!container)
-            return;
-        container.removeEventListener("scroll", this._onScroll);
-        window.removeEventListener("resize", this._onResize);
-        document.removeEventListener("keydown", this._onKeyDown);
-        container.removeEventListener("touchstart", this._onTouchStart);
-        container.removeEventListener("touchmove", this._onTouchMove);
-        container.removeEventListener("touchend", this._onTouchEnd);
-    }
-    _calculateScrollBounds() {
-        const container = this._config.container;
-        if (!container)
-            return;
-        const offset = this._config.scrollOffset ?? {};
-        if (this._config.scrollDirection === "horizontal") {
-            this._minScroll = offset.left ?? 0;
-            this._maxScroll = container.scrollWidth - container.clientWidth - (offset.right ?? 0);
-            return;
-        }
-        this._minScroll = offset.top ?? 0;
-        this._maxScroll = container.scrollHeight - container.clientHeight - (offset.bottom ?? 0);
-    }
-    _onScroll = () => {
-        if (this._paused || this._destroyed)
-            return;
-        const container = this._config.container;
-        if (!container)
-            return;
-        const currentScroll = this._config.scrollDirection === "horizontal" ? container.scrollLeft : container.scrollTop;
-        const range = this._maxScroll - this._minScroll;
-        if (range <= 0)
-            return;
-        const rawProgress = (currentScroll - this._minScroll) / range;
-        const clampedProgress = Math.max(this._config.minProgress ?? 0, Math.min(this._config.maxProgress ?? 1, rawProgress));
-        const sensitivity = this._config.scrollSensitivity ?? 1;
-        if (clampedProgress !== this._progress) {
-            this.setProgress(clampedProgress * sensitivity);
-        }
-    };
-    _onResize = () => {
-        if (this._destroyed)
-            return;
-        this._calculateScrollBounds();
-    };
-    _onKeyDown = (e) => {
-        if (this._destroyed)
-            return;
-        if (e.key === "ArrowRight" || e.key === "ArrowDown" || e.key === " ") {
-            e.preventDefault();
-            this.nextScene();
-        }
-        else if (e.key === "ArrowLeft" || e.key === "ArrowUp") {
-            e.preventDefault();
-            this.prevScene();
-        }
-    };
-    _onTouchStart = (e) => {
-        if (this._destroyed)
-            return;
-        this._isDragging = true;
-        const touch = e.touches[0];
-        if (this._config.scrollDirection === "horizontal") {
-            this._touchStartX = touch.clientX;
-        }
-        else {
-            this._touchStartY = touch.clientY;
-        }
-    };
-    _onTouchMove = (e) => {
-        if (this._destroyed)
-            return;
-        if (!this._isDragging)
-            return;
-        const touch = e.touches[0];
-        const delta = this._config.scrollDirection === "horizontal"
-            ? this._touchStartX - touch.clientX
-            : this._touchStartY - touch.clientY;
-        const sensitivity = this._config.scrollSensitivity ?? 1.0;
-        const progressDelta = (delta / 300) * sensitivity;
-        const newProgress = Math.max(0, Math.min(1, this._progress + progressDelta));
-        this.setProgress(newProgress);
-    };
-    _onTouchEnd = () => {
-        if (this._destroyed)
-            return;
-        this._isDragging = false;
-    };
-    // ── Pause state ────────────────────────────────────────────────────────
-    _applyPauseState(pause) {
-        const container = this._config.container;
-        if (!container)
-            return;
-        const svg = container.querySelector("svg");
-        if (!svg)
-            return;
-        const playState = pause ? "paused" : "running";
-        const ambientElements = svg.querySelectorAll('[class*="iso-ambient-"]');
-        for (let i = 0; i < ambientElements.length; i++) {
-            const el = ambientElements[i];
-            el.style.animationPlayState = playState;
-        }
-    }
-    _assertNotDestroyed() {
-        if (!this._destroyed)
-            return;
-        throw new ControllerError("CONTROLLER_DESTROYED", "AnimationController has been destroyed");
-    }
-}
-function isForwardEntryTransition(transition) {
-    return transition.from === "removed" && transition.to === "entering";
-}
-function isForwardExitTransition(transition) {
-    return transition.to === "exiting";
-}
-function isReverseExitTransition(transition) {
-    return transition.to === "removed" && transition.from !== "exiting";
-}
-function isReverseEntryTransition(transition) {
-    return transition.from === "exiting" && transition.to !== "removed";
-}
-function oppositeExitAnimation(entry) {
-    switch (entry) {
-        case "fade-in":
-            return "fade-out";
-        case "fade-in-grow":
-            return "fade-out-shrink";
-        case "fall-in":
-            return "rise-away";
-        case "rise-from-ground":
-            return "fall-through-ground";
-        case "slide-in-left":
-            return "slide-out-left";
-        case "slide-in-right":
-            return "slide-out-right";
-        case "flip-in":
-            return "flip-out";
-        case "none":
-            return "none";
-    }
-}
-function oppositeEntryAnimation(exit) {
-    switch (exit) {
-        case "fade-out":
-            return "fade-in";
-        case "fade-out-shrink":
-            return "fade-in-grow";
-        case "fall-through-ground":
-            return "rise-from-ground";
-        case "rise-away":
-            return "fall-in";
-        case "slide-out-left":
-            return "slide-in-left";
-        case "slide-out-right":
-            return "slide-in-right";
-        case "flip-out":
-            return "flip-in";
-        case "none":
-            return "none";
-    }
-}
-function surroundingStops(scenes, progress) {
-    let previousIndex = 0;
-    let nextIndex = scenes.length - 1;
-    for (let i = 0; i < scenes.length; i++) {
-        if (scenes[i].progress <= progress)
-            previousIndex = i;
-        if (scenes[i].progress >= progress) {
-            nextIndex = i;
-            break;
-        }
-    }
-    return {
-        previous: { scene: scenes[previousIndex], index: previousIndex },
-        next: { scene: scenes[nextIndex], index: nextIndex },
-    };
-}
-function expandViewBox(viewBox, padding) {
-    return {
-        minX: roundCameraNumber(viewBox.minX - padding),
-        minY: roundCameraNumber(viewBox.minY - padding),
-        width: roundCameraNumber(Math.max(1, viewBox.width + padding * 2)),
-        height: roundCameraNumber(Math.max(1, viewBox.height + padding * 2)),
-    };
-}
-function lerpViewBox(from, to, t) {
-    return {
-        minX: roundCameraNumber(from.minX + (to.minX - from.minX) * t),
-        minY: roundCameraNumber(from.minY + (to.minY - from.minY) * t),
-        width: roundCameraNumber(from.width + (to.width - from.width) * t),
-        height: roundCameraNumber(from.height + (to.height - from.height) * t),
-    };
-}
-function sameViewBox(a, b) {
-    return a.minX === b.minX && a.minY === b.minY && a.width === b.width && a.height === b.height;
-}
-function currentSvgViewBox(svg) {
-    const raw = svg.getAttribute("viewBox");
-    if (!raw)
-        return undefined;
-    const parts = raw.trim().split(/\s+/).map(Number);
-    if (parts.length !== 4 || parts.some((part) => !Number.isFinite(part)))
-        return undefined;
-    return { minX: parts[0], minY: parts[1], width: parts[2], height: parts[3] };
-}
-function resolveCameraEasing(easing) {
-    return resolveEasing(easing === "ease-in-out" ? "easeInOutCubic" : easing === "ease-out" ? "easeOutCubic" : "linear");
-}
-function copyCameraState(state) {
-    return {
-        viewBox: { ...state.viewBox },
-        target: state.target?.type === "area"
-            ? { type: "area", at: [...state.target.at], size: [...state.target.size] }
-            : state.target
-                ? { ...state.target }
-                : undefined,
-        isZoomed: state.isZoomed,
-    };
-}
-function roundCameraNumber(value) {
-    return Math.round(value * 1000) / 1000;
-}
-
-const RUNTIME_BUNDLE_FORMAT = "isostate-runtime-bundle";
-const RUNTIME_VERSION = "0.4.0";
-const HEX_DIGEST_PATTERN = /^[a-f0-9]{64}$/;
-/** Mount a compiled runtime bundle into an HTML element. */
-function mountScene(target, bundle, options = {}) {
-    assertMountTarget(target);
-    validateRuntimeBundle(bundle);
-    const engine = new AnimationEngine();
-    engine.init(bundle);
-    const svg = buildSceneDOM(target, bundle, {
-        label: options.label,
-        themeVars: options.themeVars,
-    });
-    let controller;
-    if (options.controller !== undefined && options.controller !== false) {
-        controller = new AnimationController();
-        controller.init(bundle, {
-            ...options.controller,
-            container: options.controller.container ?? target,
-            sceneElement: svg,
-        }, {
-            engine,
-            sceneElement: svg,
-        });
-    }
-    let destroyed = false;
-    return {
-        svg,
-        engine,
-        controller,
-        getResolvedConfig: () => getResolvedConfig(bundle, options),
-        destroy: () => {
-            if (destroyed)
-                return;
-            destroyed = true;
-            controller?.destroy();
-            engine.destroy();
-            if (svg.parentNode === target) {
-                target.removeChild(svg);
-            }
-            else {
-                svg.parentNode?.removeChild(svg);
-            }
-        },
-    };
-}
-function assertMountTarget(target) {
-    if (!target || typeof target.appendChild !== "function" || typeof target.removeChild !== "function") {
-        throw new RenderError("INVALID_MOUNT_TARGET", "mountScene() requires a DOM HTMLElement target");
-    }
-}
-function validateRuntimeBundle(bundle) {
-    if (!bundle || typeof bundle !== "object") {
-        throw new RenderError("BUNDLE_FORMAT_MISSING", "Runtime bundle must be a plain object");
-    }
-    if (bundle._format !== RUNTIME_BUNDLE_FORMAT) {
-        throw new RenderError("BUNDLE_FORMAT_MISSING", "Runtime bundle format is missing or unsupported", {
-            expected: RUNTIME_BUNDLE_FORMAT,
-        });
-    }
-    if (!Array.isArray(bundle.scenes) || bundle.scenes.length === 0) {
-        throw new RenderError("BUNDLE_FORMAT_MISSING", "Runtime bundle must include compiled scenes[]");
-    }
-    if (majorVersion(bundle._version) !== majorVersion(RUNTIME_VERSION)) {
-        throw new RenderError("BUNDLE_VERSION_MISMATCH", `Runtime bundle version ${bundle._version} is not compatible with runtime ${RUNTIME_VERSION}`, { bundleVersion: bundle._version, runtimeVersion: RUNTIME_VERSION });
-    }
-    if (!bundle._digest) {
-        throw new RenderError("BUNDLE_DIGEST_MISSING", "Runtime bundle digest is missing");
-    }
-    if (typeof bundle._digest !== "string" || !HEX_DIGEST_PATTERN.test(bundle._digest)) {
-        throw new RenderError("BUNDLE_DIGEST_MISMATCH", "Runtime bundle digest is malformed");
-    }
-    const { _digest, ...bundleWithoutDigest } = bundle;
-    const actualDigest = sha256(canonicalStringify(bundleWithoutDigest));
-    if (actualDigest !== _digest) {
-        throw new RenderError("BUNDLE_DIGEST_MISMATCH", "Runtime bundle digest does not match bundle content", {
-            expected: _digest,
-            actual: actualDigest,
-        });
-    }
-}
-function getResolvedConfig(bundle, options = {}) {
-    return {
-        grid: { cellSize: bundle.grid.cellSize },
-        floor: { ...bundle.floor },
-        layout: {
-            ...bundle.layout,
-            padding: { ...bundle.layout.padding },
-            align: [...bundle.layout.align],
-        },
-        viewBox: getResolvedViewBox(bundle),
-        camera: {
-            viewBox: getResolvedViewBox(bundle),
-            isZoomed: false,
-        },
-        theme: bundle.theme,
-        themeVars: getResolvedThemeVars(bundle, options.themeVars),
-        scenes: bundle.scenes.map((scene) => ({
-            id: scene.id,
-            progress: scene.progress,
-        })),
-        layerOrder: bundle.layers
-            .map((layer) => ({ name: layer.name, order: layer.order }))
-            .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name)),
-    };
-}
-function getResolvedThemeVars(bundle, overrides = {}) {
-    return {
-        ...(resolveTheme(bundle.theme) ?? {}),
-        ...(bundle.themeVars ?? {}),
-        ...overrides,
-    };
-}
-function majorVersion(version) {
-    const major = Number.parseInt(String(version).split(".")[0] ?? "", 10);
-    return Number.isFinite(major) ? major : Number.NaN;
-}
-function canonicalStringify(value) {
-    return JSON.stringify(normalizeValue(value));
-}
-function normalizeValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => (item === undefined ? null : normalizeValue(item)));
-    }
-    if (!isPlainObject(value))
-        return value;
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-        const child = value[key];
-        if (child !== undefined) {
-            normalized[key] = normalizeValue(child);
-        }
-    }
-    return normalized;
-}
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-export { AnimationController as A, AnimationEngine as a, easeInOutCubic as b, easeOutCubic as c, easeInCubic as e, linear as l, mountScene as m, resolveEasing as r };
-//# sourceMappingURL=index-C3qcXbPI.js.map