@sebastianwessel/isostate 0.4.0 → 0.6.0

package/dist/chunks/index-WmsNtuaZ.js

@@ -0,0 +1,1685 @@
+import { A as AnimationError, C as ControllerError, R as RenderError } from './errors-2yA81Vfb.js';
+import { a as getResolvedViewBox, c as getCurrentElementBounds, b as getElementState, q as getGridAreaBounds, e as updateElementTransforms, g as getResolvedProjectionLayout, f as projectToScreen, l as calculateVisualSize, s as applySceneViewBox, u as unhideElementOnReadd, h as hideElementAfterExit, d as getConnectorState, t as animateElement, j as buildSceneDOM, r as resolveTheme } from './rendering-engine-DLaM1XbU.js';
+import { s as sha256 } from './sha256-BkgWUdh1.js';
+
+class AnimationEngine {
+  _bundle = null;
+  _progress = 0;
+  _paused = false;
+  _prevFrameMap = /* @__PURE__ */ new Map();
+  _elementFrameMap = /* @__PURE__ */ new Map();
+  _prevConnectorFrameMap = /* @__PURE__ */ new Map();
+  _connectorFrameMap = /* @__PURE__ */ 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) {
+    if (!Number.isFinite(progress)) {
+      throw new AnimationError("INVALID_PROGRESS", "setProgress() requires a finite progress value");
+    }
+    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();
+  }
+}
+function resolveFrameMap(bundle, progress) {
+  const pair = findSurroundingStops(bundle.scenes, progress);
+  const result = /* @__PURE__ */ new Map();
+  if (!pair) return result;
+  const ids = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+  if (!pair) return result;
+  const ids = /* @__PURE__ */ 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);
+    const reference = frame.lifecycle === "removed" ? findNearestGeometry(bundle.scenes, id, progress, (stop) => stop.connectors ?? []) : void 0;
+    result.set(id, reference ? frameFromConnector(reference, "removed") : 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: t < 1 ? prev.asset : next.asset,
+    pos: interpolatePos(prev.pos, next.pos, t),
+    size: prev.size + (next.size - prev.size) * t,
+    lifecycle,
+    ambient: cloneAmbient(t < 1 ? prev.ambient : 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),
+    activity: cloneOptional(t < 1 ? prev.activity : next.activity)
+  };
+}
+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: t < 1 ? prev.start : next.start,
+    end: t < 1 ? prev.end : next.end,
+    direction: t < 1 ? prev.direction : next.direction,
+    message: cloneOptional(t < 1 ? prev.message : next.message),
+    ambient: cloneAmbient(t < 1 ? prev.ambient : 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 = findNearestGeometry(stops, id, progress, (stop) => stop.elements ?? []);
+  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),
+    activity: cloneOptional(reference.activity)
+  };
+}
+function findNearestGeometry(stops, id, progress, states) {
+  const sorted = [...stops].sort((a, b) => a.progress - b.progress);
+  const next = sorted.filter((stop) => stop.progress >= progress).flatMap(states).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 = states(sorted[index]).find((element) => element.id === id && element.presence !== "removed");
+    if (previous) return previous;
+  }
+  return void 0;
+}
+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),
+    activity: cloneOptional(element.activity)
+  };
+}
+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,
+    message: cloneOptional(connector.message),
+    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),
+    activity: cloneOptional(frame.activity)
+  };
+}
+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,
+    message: cloneOptional(frame.message),
+    ambient: cloneAmbient(frame.ambient),
+    entry: frame.entry,
+    exit: frame.exit
+  };
+}
+function cloneFrameMap(map) {
+  const clone = /* @__PURE__ */ 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),
+      activity: cloneOptional(frame.activity)
+    });
+  }
+  return clone;
+}
+function cloneText(text) {
+  return text ? { ...text } : void 0;
+}
+function clonePrimitive(primitive) {
+  if (!primitive) return void 0;
+  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]] : void 0;
+}
+function cloneConnectorFrameMap(map) {
+  const clone = /* @__PURE__ */ 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;
+}
+function cloneOptional(value) {
+  return value ? { ...value } : void 0;
+}
+
+function linear(t) {
+  return t;
+}
+function easeInCubic(t) {
+  return t * t * t;
+}
+function easeOutCubic(t) {
+  return 1 - (1 - t) ** 3;
+}
+function easeInOutCubic(t) {
+  return t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+}
+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,
+  transitionDuration: 600,
+  transitionEasing: "ease-in-out"
+};
+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 = /* @__PURE__ */ new Map();
+  _cameraAnim = null;
+  _cameraState = null;
+  // Scroll tracking state
+  _minScroll = 0;
+  _maxScroll = 0;
+  _lastTouchY = 0;
+  _lastTouchX = 0;
+  _isDragging = false;
+  // Transition animation state
+  _transitionAnim = null;
+  _backward = false;
+  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");
+    }
+    this._cancelTransition();
+    this._setProgress(progress);
+  }
+  _setProgress(progress) {
+    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._cancelTransition();
+    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) {
+      if (getElementState(svg, id)) {
+        throw new ControllerError("CAMERA_TARGET_NOT_VISIBLE", `Camera target element "${id}" is currently removed`, {
+          elementId: id
+        });
+      }
+      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();
+    this._getSceneSvg()?.classList.add("iso-motion-stopped");
+    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) ?? /* @__PURE__ */ 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._backward = pending < this._engine.getProgress();
+      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,
+      activity: update.activity
+    }));
+    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,
+      message: update.message,
+      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, { forInterpolation: true });
+    const nextViewBox = this._resolveCameraViewBox(nextCamera, { forInterpolation: true });
+    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, options = {}) {
+    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 = options.forInterpolation ? this._resolveElementBoundsForInterpolation(svg, camera.target.id) : 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);
+  }
+  /**
+   * Resolve element bounds for scroll/setProgress camera interpolation.
+   *
+   * Unlike `getCurrentElementBounds()`, this tolerates an element whose
+   * resolved presence is transiently "removed" because progress has not yet
+   * reached the stop that introduces it (the engine still carries valid
+   * authored geometry for it via nearest-geometry fallback). It falls back to
+   * that geometry instead of reporting the target as missing so a scene that
+   * both adds an element and focuses the camera on it in the same stop can be
+   * interpolated into smoothly. A genuinely unknown element id still resolves
+   * to `undefined` so callers can throw `CAMERA_TARGET_NOT_FOUND`.
+   */
+  _resolveElementBoundsForInterpolation(svg, id) {
+    const direct = getCurrentElementBounds(svg, id);
+    if (direct) return direct;
+    const state = getElementState(svg, id);
+    if (!state || !this._bundle) return void 0;
+    const layout = getResolvedProjectionLayout(this._bundle);
+    const element = state.current;
+    const screen = projectToScreen(
+      element.pos[0] + element.size,
+      element.pos[1] + element.size,
+      layout.cellSize,
+      layout.selectedBounds.minX,
+      layout.selectedBounds.minY,
+      layout.padding.x,
+      layout.padding.y
+    );
+    const visualSize = calculateVisualSize(element.size, layout.cellSize);
+    const [anchorX, anchorY] = state.anchor;
+    return {
+      minX: roundCameraNumber(screen.screenX - visualSize * anchorX),
+      minY: roundCameraNumber(screen.screenY - visualSize * anchorY),
+      width: roundCameraNumber(Math.max(1, visualSize)),
+      height: roundCameraNumber(Math.max(1, visualSize))
+    };
+  }
+  _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 > 1e4) {
+      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._backward)) {
+        this._applyEntryAnimation(elDef, state);
+      }
+      if (isReverseExitTransition(transition, this._backward)) {
+        this._applyExitAnimation({ ...elDef, exit: oppositeExitAnimation(elDef.enter ?? "fade-in") }, state);
+        continue;
+      }
+      if (isForwardExitTransition(transition, this._backward)) {
+        this._applyExitAnimation(elDef, state);
+        continue;
+      }
+      if (isReverseEntryTransition(transition, this._backward)) {
+        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._backward)) {
+        this._applyConnectorEntryAnimation(connectorDef, state);
+      }
+      if (isReverseExitTransition(transition, this._backward)) {
+        this._applyConnectorExitAnimation(
+          {
+            ...connectorDef,
+            exit: oppositeExitAnimation(connectorDef.enter ?? "fade-in")
+          },
+          state
+        );
+        continue;
+      }
+      if (isForwardExitTransition(transition, this._backward)) {
+        this._applyConnectorExitAnimation(connectorDef, state);
+        continue;
+      }
+      if (isReverseEntryTransition(transition, this._backward)) {
+        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();
+    const stop = this.scenes[index];
+    const from = this._progress;
+    const to = stop.progress;
+    if (index === this._sceneIndex && from === to) return;
+    this._sceneIndex = index;
+    this._emit("scene-change", index);
+    const duration = this._config.transitionDuration;
+    if (duration > 0 && from !== to) {
+      this._animateProgress(from, to, duration);
+      return;
+    }
+    this._progress = to;
+    this._cancelCameraAnimation();
+    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() {
+    if (this._config.keyboardControls) {
+      document.addEventListener("keydown", this._onKeyDown);
+    }
+    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.touchControls) {
+      container.addEventListener("touchstart", this._onTouchStart, {
+        passive: true
+      });
+      container.addEventListener("touchmove", this._onTouchMove, {
+        passive: false
+      });
+      container.addEventListener("touchend", this._onTouchEnd);
+    }
+  }
+  _unbindScroll() {
+    document.removeEventListener("keydown", this._onKeyDown);
+    const container = this._config.container;
+    if (!container) return;
+    container.removeEventListener("scroll", this._onScroll);
+    window.removeEventListener("resize", this._onResize);
+    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 sensitivity = this._config.scrollSensitivity ?? 1;
+    const scaledProgress = rawProgress * sensitivity;
+    const clampedProgress = Math.max(
+      this._config.minProgress ?? 0,
+      Math.min(this._config.maxProgress ?? 1, scaledProgress)
+    );
+    if (clampedProgress !== this._progress) {
+      this.setProgress(clampedProgress);
+    }
+  };
+  _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._lastTouchX = touch.clientX;
+    } else {
+      this._lastTouchY = touch.clientY;
+    }
+  };
+  _onTouchMove = (e) => {
+    if (this._destroyed) return;
+    if (!this._isDragging) return;
+    const touch = e.touches[0];
+    const isHorizontal = this._config.scrollDirection === "horizontal";
+    const delta = isHorizontal ? this._lastTouchX - touch.clientX : this._lastTouchY - touch.clientY;
+    if (isHorizontal) {
+      this._lastTouchX = touch.clientX;
+    } else {
+      this._lastTouchY = touch.clientY;
+    }
+    const sensitivity = this._config.scrollSensitivity ?? 1;
+    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 svg = this._getSceneSvg();
+    if (!svg) return;
+    if (pause) svg.classList.add("iso-motion-paused");
+    else svg.classList.remove("iso-motion-paused");
+    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, backward) {
+  return !backward && (transition.from === "removed" || transition.from === "exiting") && (transition.to === "entering" || transition.to === "present");
+}
+function isForwardExitTransition(transition, backward) {
+  return !backward && (transition.to === "exiting" || transition.to === "removed" && transition.from !== "exiting");
+}
+function isReverseExitTransition(transition, backward) {
+  return backward && (transition.to === "removed" || transition.to === "exiting") && (transition.from === "entering" || transition.from === "present");
+}
+function isReverseEntryTransition(transition, backward) {
+  return backward && (transition.from === "exiting" || transition.from === "removed") && (transition.to === "present" || transition.to === "entering");
+}
+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 void 0;
+  const parts = raw.trim().split(/\s+/).map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isFinite(part))) return void 0;
+  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 } : void 0,
+    isZoomed: state.isZoomed
+  };
+}
+function roundCameraNumber(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+
+const CSS_CLASS_INTERACTIVE_ROOT = "iso-interactive";
+const CSS_CLASS_HOVER = "iso-hover";
+class SceneInteractivity {
+  svg;
+  listeners = /* @__PURE__ */ new Map();
+  destroyed = false;
+  attached = false;
+  onClick = (event) => this.handleClick(event);
+  onPointerOver = (event) => this.handlePointerOver(event);
+  onPointerOut = (event) => this.handlePointerOut(event);
+  constructor(svg, interactive) {
+    this.svg = svg;
+    if (interactive) {
+      svg.classList.add(CSS_CLASS_INTERACTIVE_ROOT);
+      svg.addEventListener("click", this.onClick);
+      svg.addEventListener("pointerover", this.onPointerOver);
+      svg.addEventListener("pointerout", this.onPointerOut);
+      this.attached = true;
+    }
+  }
+  /** Subscribe to interactivity events. Returns an unsubscribe function. */
+  on(event, listener) {
+    if (this.destroyed) {
+      throw new RenderError("MOUNT_DESTROYED", "Cannot call on() after destroy()");
+    }
+    const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(event, set);
+    return () => {
+      set.delete(listener);
+    };
+  }
+  /** Remove the three delegated listeners and all subscriptions. Safe to call more than once. */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.attached) {
+      this.svg.removeEventListener("click", this.onClick);
+      this.svg.removeEventListener("pointerover", this.onPointerOver);
+      this.svg.removeEventListener("pointerout", this.onPointerOut);
+      this.attached = false;
+    }
+    this.listeners.clear();
+  }
+  handleClick(event) {
+    const id = this.resolveVisibleElementId(event.target);
+    if (!id) return;
+    this.emit("element-click", { id, originalEvent: event });
+  }
+  handlePointerOver(event) {
+    const enteredId = this.resolveVisibleElementId(event.target);
+    if (!enteredId) return;
+    const previousId = this.resolveVisibleElementId(event.relatedTarget);
+    if (enteredId === previousId) return;
+    this.toggleHoverClass(enteredId, true);
+    this.emit("element-enter", { id: enteredId, originalEvent: event });
+  }
+  handlePointerOut(event) {
+    const leftId = this.resolveVisibleElementId(event.target);
+    if (!leftId) return;
+    const nextId = this.resolveVisibleElementId(event.relatedTarget);
+    if (leftId === nextId) return;
+    this.toggleHoverClass(leftId, false);
+    this.emit("element-leave", { id: leftId, originalEvent: event });
+  }
+  toggleHoverClass(id, hovered) {
+    const state = getElementState(this.svg, id);
+    if (!state) return;
+    state.node.classList.toggle(CSS_CLASS_HOVER, hovered);
+  }
+  /**
+   * Resolve the scene element id for a pointer event target: walk up
+   * `parentNode` from the event target until the root SVG, looking for the
+   * first ancestor `<g>` that is a member of the engine's element state map
+   * (connector groups also carry `data-id` but are never members of this
+   * map, and floor/defs/diagnostics nodes carry no `data-id` at all). An
+   * element whose current presence is `removed` never resolves.
+   */
+  resolveVisibleElementId(target) {
+    let node = target;
+    while (node && node !== this.svg) {
+      const id = node.getAttribute?.("data-id");
+      if (id) {
+        const state = getElementState(this.svg, id);
+        if (state && state.current.presence !== "removed") return id;
+        return void 0;
+      }
+      node = node.parentNode;
+    }
+    return void 0;
+  }
+  /**
+   * Invoke every listener for `event`. Exceptions are not caught: consistent
+   * with `AnimationController`'s event system, a throwing listener is
+   * rethrown asynchronously (via `queueMicrotask`) rather than swallowed, so
+   * it surfaces as an unhandled error without breaking delivery to sibling
+   * listeners in the same `Set`.
+   */
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const listener of set) {
+      try {
+        listener(payload);
+      } catch (error) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+    }
+  }
+}
+
+const RUNTIME_BUNDLE_FORMAT = "isostate-runtime-bundle";
+const RUNTIME_VERSION = "0.6.0";
+const HEX_DIGEST_PATTERN = /^[a-f0-9]{64}$/;
+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 !== void 0 && options.controller !== false) {
+    controller = new AnimationController();
+    controller.init(
+      bundle,
+      {
+        ...options.controller,
+        container: options.controller.container ?? target,
+        sceneElement: svg
+      },
+      {
+        engine,
+        sceneElement: svg
+      }
+    );
+  }
+  const interactivity = new SceneInteractivity(svg, options.interactive === true);
+  let destroyed = false;
+  return {
+    svg,
+    engine,
+    controller,
+    getResolvedConfig: () => getResolvedConfig(bundle, options, controller),
+    on: (event, listener) => interactivity.on(event, listener),
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      interactivity.destroy();
+      destroyControllerSafely(controller);
+      engine.destroy();
+      if (svg.parentNode === target) {
+        target.removeChild(svg);
+      } else {
+        svg.parentNode?.removeChild(svg);
+      }
+    }
+  };
+}
+function destroyControllerSafely(controller) {
+  if (!controller) return;
+  try {
+    controller.destroy();
+  } catch (error) {
+    if (error instanceof ControllerError && error.code === "CONTROLLER_DESTROYED") return;
+    throw error;
+  }
+}
+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 = {}, controller) {
+  return {
+    grid: { cellSize: bundle.grid.cellSize },
+    floor: { ...bundle.floor, size: [...bundle.floor.size], origin: [...bundle.floor.origin] },
+    layout: {
+      ...bundle.layout,
+      padding: { ...bundle.layout.padding },
+      align: [...bundle.layout.align]
+    },
+    viewBox: getResolvedViewBox(bundle),
+    camera: resolveCameraState(bundle, controller),
+    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 || compareCodePointOrder(a.name, b.name))
+  };
+}
+function resolveCameraState(bundle, controller) {
+  if (controller) {
+    try {
+      return controller.getCameraState();
+    } catch (error) {
+      if (!(error instanceof ControllerError)) throw error;
+    }
+  }
+  return {
+    viewBox: getResolvedViewBox(bundle),
+    isZoomed: false
+  };
+}
+function compareCodePointOrder(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+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 === void 0 ? null : normalizeValue(item));
+  }
+  if (!isPlainObject(value)) return value;
+  const normalized = {};
+  for (const key of Object.keys(value).sort()) {
+    const child = value[key];
+    if (child !== void 0) {
+      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-WmsNtuaZ.js.map