@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-PZCSADOV.js

@@ -0,0 +1,928 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/camera/index.ts
+var camera_exports = {};
+__export(camera_exports, {
+  CameraConstraints: () => CameraConstraints,
+  CameraController: () => CameraController,
+  CameraEffects: () => CameraEffects,
+  CameraPath: () => CameraPath,
+  CameraShake: () => CameraShake,
+  CinematicTrack: () => CinematicTrack
+});
+
+// src/camera/CameraConstraints.ts
+var CameraConstraints = class {
+  bounds = null;
+  deadZone = null;
+  softLimit = null;
+  smoothing = 0.1;
+  // Lerp factor (0 = no movement, 1 = instant)
+  lookAheadDistance = 0;
+  currentX = 0;
+  currentY = 0;
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setBounds(bounds) {
+    this.bounds = bounds;
+  }
+  setDeadZone(dz) {
+    this.deadZone = dz;
+  }
+  setSoftLimit(sl) {
+    this.softLimit = sl;
+  }
+  setSmoothing(factor) {
+    this.smoothing = Math.max(0, Math.min(1, factor));
+  }
+  setLookAhead(distance) {
+    this.lookAheadDistance = distance;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  follow(targetX, targetY, velocityX = 0, velocityY = 0) {
+    let desiredX = targetX;
+    let desiredY = targetY;
+    if (this.lookAheadDistance > 0) {
+      const speed = Math.sqrt(velocityX * velocityX + velocityY * velocityY) || 1;
+      desiredX += velocityX / speed * this.lookAheadDistance;
+      desiredY += velocityY / speed * this.lookAheadDistance;
+    }
+    if (this.deadZone) {
+      const dx = desiredX - this.currentX;
+      const dy = desiredY - this.currentY;
+      const halfW = this.deadZone.width / 2;
+      const halfH = this.deadZone.height / 2;
+      if (Math.abs(dx) < halfW) desiredX = this.currentX;
+      else desiredX = this.currentX + (dx > 0 ? dx - halfW : dx + halfW);
+      if (Math.abs(dy) < halfH) desiredY = this.currentY;
+      else desiredY = this.currentY + (dy > 0 ? dy - halfH : dy + halfH);
+    }
+    this.currentX += (desiredX - this.currentX) * this.smoothing;
+    this.currentY += (desiredY - this.currentY) * this.smoothing;
+    if (this.softLimit && this.bounds) {
+      this.applySoftLimit();
+    }
+    if (this.bounds) {
+      this.currentX = Math.max(this.bounds.minX, Math.min(this.bounds.maxX, this.currentX));
+      this.currentY = Math.max(this.bounds.minY, Math.min(this.bounds.maxY, this.currentY));
+    }
+    return { x: this.currentX, y: this.currentY };
+  }
+  // ---------------------------------------------------------------------------
+  // Soft Limits
+  // ---------------------------------------------------------------------------
+  applySoftLimit() {
+    if (!this.softLimit || !this.bounds) return;
+    const sl = this.softLimit;
+    if (this.currentX < this.bounds.minX + sl.distance) {
+      const over = this.bounds.minX + sl.distance - this.currentX;
+      this.currentX += over * sl.stiffness;
+    }
+    if (this.currentX > this.bounds.maxX - sl.distance) {
+      const over = this.currentX - (this.bounds.maxX - sl.distance);
+      this.currentX -= over * sl.stiffness;
+    }
+    if (this.currentY < this.bounds.minY + sl.distance) {
+      const over = this.bounds.minY + sl.distance - this.currentY;
+      this.currentY += over * sl.stiffness;
+    }
+    if (this.currentY > this.bounds.maxY - sl.distance) {
+      const over = this.currentY - (this.bounds.maxY - sl.distance);
+      this.currentY -= over * sl.stiffness;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getPosition() {
+    return { x: this.currentX, y: this.currentY };
+  }
+  setPosition(x, y) {
+    this.currentX = x;
+    this.currentY = y;
+  }
+};
+
+// src/camera/CameraController.ts
+var DEFAULT_CAMERA = {
+  mode: "follow",
+  smoothing: 0.1,
+  followOffset: { x: 0, y: 5, z: -10 },
+  orbitDistance: 10,
+  orbitMinDistance: 2,
+  orbitMaxDistance: 50,
+  orbitSpeed: 2,
+  zoomSpeed: 1,
+  minZoom: 0.5,
+  maxZoom: 5,
+  deadZone: { x: 0, y: 0 },
+  bounds: null,
+  fov: 60,
+  freeSpeed: 10
+};
+var CameraController = class {
+  config;
+  state;
+  target = { x: 0, y: 0, z: 0 };
+  orbitAngle = 0;
+  orbitPitch = 0.3;
+  /**
+   * Creates a new camera controller with optional configuration.
+   *
+   * @param config - Optional camera configuration overrides. Merged with defaults.
+   * @example
+   * ```typescript
+   * const camera = new CameraController({
+   *   mode: 'follow',
+   *   smoothing: 0.2,
+   *   followOffset: { x: 0, y: 3, z: -8 }
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.config = { ...DEFAULT_CAMERA, ...config };
+    this.state = {
+      position: [0, 5, -10],
+      rotation: { pitch: 0, yaw: 0, roll: 0 },
+      zoom: 1,
+      fov: this.config.fov
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  /**
+   * Updates camera position and rotation based on current mode and delta time.
+   *
+   * Call this every frame to animate camera movement. Different modes handle
+   * updates differently:
+   * - **follow**: Smoothly interpolates toward target + offset
+   * - **orbit**: Updates position based on orbit angle and pitch
+   * - **topDown**: Maintains overhead view with smooth target tracking
+   * - **free/fixed**: No automatic movement (controlled externally)
+   *
+   * @param dt - Delta time in seconds since last update
+   * @example
+   * ```typescript
+   * // In game loop
+   * const deltaTime = (now - lastTime) / 1000;
+   * camera.update(deltaTime);
+   * ```
+   */
+  update(dt) {
+    switch (this.config.mode) {
+      case "follow":
+        this.updateFollow(dt);
+        break;
+      case "orbit":
+        this.updateOrbit(dt);
+        break;
+      case "free":
+        break;
+      // Controlled externally via moveCamera
+      case "topDown":
+        this.updateTopDown(dt);
+        break;
+      case "fixed":
+        break;
+    }
+    if (this.config.bounds) this.clampToBounds();
+  }
+  updateFollow(dt) {
+    const off = this.config.followOffset;
+    const desiredX = this.target.x + off.x;
+    const desiredY = this.target.y + off.y;
+    const desiredZ = this.target.z + off.z;
+    const dx = Math.abs(this.target.x - this.state.position.x + off.x);
+    const dy = Math.abs(this.target.y - this.state.position.y + off.y);
+    const dz = this.config.deadZone;
+    if (dx < dz.x && dy < dz.y) return;
+    const s = 1 - Math.pow(1 - this.config.smoothing, dt * 60);
+    this.state.position.x = this.lerp(this.state.position.x, desiredX, s);
+    this.state.position.y = this.lerp(this.state.position.y, desiredY, s);
+    this.state.position.z = this.lerp(this.state.position.z, desiredZ, s);
+  }
+  updateOrbit(_dt) {
+    const d = this.config.orbitDistance * this.state.zoom;
+    this.state.position.x = this.target.x + Math.sin(this.orbitAngle) * Math.cos(this.orbitPitch) * d;
+    this.state.position.y = this.target.y + Math.sin(this.orbitPitch) * d;
+    this.state.position.z = this.target.z + Math.cos(this.orbitAngle) * Math.cos(this.orbitPitch) * d;
+    this.state.rotation.yaw = this.orbitAngle;
+    this.state.rotation.pitch = -this.orbitPitch;
+  }
+  updateTopDown(_dt) {
+    const height = 20 * this.state.zoom;
+    const s = 1 - Math.pow(1 - this.config.smoothing, 1);
+    this.state.position.x = this.lerp(this.state.position.x, this.target.x, s);
+    this.state.position.y = height;
+    this.state.position.z = this.lerp(this.state.position.z, this.target.z, s);
+    this.state.rotation.pitch = -Math.PI / 2;
+    this.state.rotation.yaw = 0;
+  }
+  clampToBounds() {
+    const b = this.config.bounds;
+    this.state.position.x = Math.max(b.min.x, Math.min(b.max.x, this.state.position.x));
+    this.state.position.y = Math.max(b.min.y, Math.min(b.max.y, this.state.position.y));
+    this.state.position.z = Math.max(b.min.z, Math.min(b.max.z, this.state.position.z));
+  }
+  // ---------------------------------------------------------------------------
+  // Controls
+  // ---------------------------------------------------------------------------
+  /**
+   * Sets the target point that the camera should focus on or track.
+   *
+   * Used by 'follow', 'orbit', and 'topDown' modes. In 'follow' mode, camera
+   * maintains offset from this target. In 'orbit' mode, camera rotates around
+   * this point. In 'topDown' mode, camera looks down at this location.
+   *
+   * @param x - Target X coordinate in world space
+   * @param y - Target Y coordinate in world space
+   * @param z - Target Z coordinate in world space
+   * @example
+   * ```typescript
+   * // Track a moving player
+   * camera.setTarget(player.x, player.y, player.z);
+   * ```
+   */
+  setTarget(x, y, z) {
+    this.target = { x, y, z };
+  }
+  /**
+   * Gets the current target position.
+   *
+   * @returns Copy of the current target coordinates
+   */
+  getTarget() {
+    return { ...this.target };
+  }
+  /**
+   * Rotates the camera in orbit mode by the specified angles.
+   *
+   * Only affects camera behavior when mode is set to 'orbit'. Angles are
+   * clamped to prevent the camera from flipping or going too extreme.
+   *
+   * @param deltaAngle - Horizontal rotation change (yaw) in radians
+   * @param deltaPitch - Vertical rotation change (pitch) in radians, clamped to [-1.4, 1.4]
+   * @example
+   * ```typescript
+   * // Rotate based on mouse movement
+   * camera.rotateOrbit(mouseX * 0.01, mouseY * 0.01);
+   * ```
+   */
+  rotateOrbit(deltaAngle, deltaPitch) {
+    this.orbitAngle += deltaAngle * this.config.orbitSpeed;
+    this.orbitPitch = Math.max(
+      -1.4,
+      Math.min(1.4, this.orbitPitch + deltaPitch * this.config.orbitSpeed)
+    );
+  }
+  /**
+   * Adjusts camera zoom by the specified delta amount.
+   *
+   * Zoom affects distance in 'orbit' mode, height in 'topDown' mode, and FOV scaling.
+   * Value is clamped between configured minZoom and maxZoom limits.
+   *
+   * @param delta - Amount to change zoom by (positive = zoom in, negative = zoom out)
+   * @example
+   * ```typescript
+   * // Zoom in on mouse wheel
+   * camera.zoom(-wheelDelta * 0.1);
+   * ```
+   */
+  zoom(delta) {
+    this.state.zoom = Math.max(
+      this.config.minZoom,
+      Math.min(this.config.maxZoom, this.state.zoom + delta * this.config.zoomSpeed)
+    );
+  }
+  /**
+   * Directly moves camera position by specified amounts.
+   *
+   * Primarily used in 'free' camera mode for manual camera control.
+   * Movement is scaled by the configured freeSpeed multiplier.
+   *
+   * @param dx - Change in X position (world units)
+   * @param dy - Change in Y position (world units)
+   * @param dz - Change in Z position (world units)
+   * @example
+   * ```typescript
+   * // WASD movement in free camera mode
+   * if (wPressed) camera.moveCamera(0, 0, 1);
+   * if (sPressed) camera.moveCamera(0, 0, -1);
+   * ```
+   */
+  moveCamera(dx, dy, dz) {
+    this.state.position.x += dx * this.config.freeSpeed;
+    this.state.position.y += dy * this.config.freeSpeed;
+    this.state.position.z += dz * this.config.freeSpeed;
+  }
+  /**
+   * Changes the camera's behavior mode.
+   *
+   * @param mode - New camera mode ('follow' | 'orbit' | 'free' | 'topDown' | 'fixed')
+   * @example
+   * ```typescript
+   * camera.setMode('orbit'); // Switch to orbital camera
+   * ```
+   */
+  setMode(mode) {
+    this.config.mode = mode;
+  }
+  /**
+   * Gets the current camera mode.
+   *
+   * @returns Current camera mode
+   */
+  getMode() {
+    return this.config.mode;
+  }
+  // ---------------------------------------------------------------------------
+  // State
+  // ---------------------------------------------------------------------------
+  /**
+   * Gets a copy of the current camera state.
+   *
+   * Returns position, rotation, zoom, and FOV values. All objects are cloned
+   * to prevent external modification of internal state.
+   *
+   * @returns Current camera state with position, rotation, zoom, and FOV
+   * @example
+   * ```typescript
+   * const state = camera.getState();
+   * renderer.setCamera(state.position, state.rotation);
+   * renderer.setFOV(state.fov);
+   * ```
+   */
+  getState() {
+    return {
+      position: { ...this.state.position },
+      rotation: { ...this.state.rotation },
+      zoom: this.state.zoom,
+      fov: this.state.fov
+    };
+  }
+  /**
+   * Directly sets the camera zoom level.
+   *
+   * Unlike zoom(), this sets an absolute value rather than a delta.
+   * Value is clamped to configured min/max zoom limits.
+   *
+   * @param z - New zoom level (clamped to minZoom/maxZoom)
+   * @example
+   * ```typescript
+   * camera.setZoom(1.0); // Reset to default zoom
+   * ```
+   */
+  setZoom(z) {
+    this.state.zoom = Math.max(this.config.minZoom, Math.min(this.config.maxZoom, z));
+  }
+  /**
+   * Sets the camera's field of view.
+   *
+   * @param fov - New field of view in degrees
+   * @example
+   * ```typescript
+   * camera.setFOV(90); // Wide angle
+   * camera.setFOV(30); // Telephoto
+   * ```
+   */
+  setFOV(fov) {
+    this.state.fov = fov;
+  }
+  /**
+   * Adjusts camera smoothing factor for interpolated movement modes.
+   *
+   * Affects 'follow' and 'topDown' modes. Higher values = more responsive,
+   * lower values = smoother but more delayed movement.
+   *
+   * @param s - Smoothing factor between 0.0 (no movement) and 1.0 (instant)
+   * @example
+   * ```typescript
+   * camera.setSmoothing(0.1); // Very smooth
+   * camera.setSmoothing(0.8); // Very responsive
+   * ```
+   */
+  setSmoothing(s) {
+    this.config.smoothing = Math.max(0, Math.min(1, s));
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  lerp(a, b, t) {
+    return a + (b - a) * t;
+  }
+};
+
+// src/camera/CameraEffects.ts
+var _effectId = 0;
+var CameraEffects = class {
+  effects = [];
+  shakeOffset = { x: 0, y: 0 };
+  zoomMultiplier = 1;
+  flashAlpha = 0;
+  flashColor = { r: 1, g: 1, b: 1 };
+  letterboxAmount = 0;
+  vignetteIntensity = 0;
+  fadeAlpha = 0;
+  // ---------------------------------------------------------------------------
+  // Effect Triggers
+  // ---------------------------------------------------------------------------
+  shake(duration, intensity = 5, frequency = 20, decay = 1) {
+    return this.addEffect("shake", duration, intensity, { frequency, decay });
+  }
+  zoomPulse(duration, targetZoom = 1.2, easeBack = true) {
+    return this.addEffect("zoom", duration, targetZoom, { targetZoom, easeBack });
+  }
+  flash(duration = 0.1, color = { r: 1, g: 1, b: 1 }, intensity = 1) {
+    return this.addEffect("flash", duration, intensity, { color });
+  }
+  letterbox(duration, ratio = 2.35) {
+    return this.addEffect("letterbox", duration, ratio, { ratio });
+  }
+  vignette(duration, intensity = 0.5) {
+    return this.addEffect("vignette", duration, intensity, {});
+  }
+  fade(duration, fadeIn = false, color = { r: 0, g: 0, b: 0 }) {
+    return this.addEffect("fade", duration, 1, { fadeIn, color });
+  }
+  addEffect(type, duration, intensity, params) {
+    const id = `fx_${_effectId++}`;
+    this.effects.push({ id, type, duration, elapsed: 0, intensity, params, active: true });
+    return id;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    this.shakeOffset = { x: 0, y: 0 };
+    this.zoomMultiplier = 1;
+    this.flashAlpha = 0;
+    this.vignetteIntensity = 0;
+    for (const effect of this.effects) {
+      if (!effect.active) continue;
+      effect.elapsed += dt;
+      const t = Math.min(effect.elapsed / effect.duration, 1);
+      switch (effect.type) {
+        case "shake": {
+          const p = effect.params;
+          const decay = 1 - t * p.decay;
+          if (decay > 0) {
+            this.shakeOffset.x += (Math.random() - 0.5) * 2 * effect.intensity * decay;
+            this.shakeOffset.y += (Math.random() - 0.5) * 2 * effect.intensity * decay;
+          }
+          break;
+        }
+        case "zoom": {
+          const p = effect.params;
+          if (p.easeBack) {
+            const curve = t < 0.5 ? t * 2 : (1 - t) * 2;
+            this.zoomMultiplier *= 1 + (p.targetZoom - 1) * curve;
+          } else {
+            this.zoomMultiplier *= 1 + (p.targetZoom - 1) * (1 - t);
+          }
+          break;
+        }
+        case "flash": {
+          const p = effect.params;
+          this.flashAlpha = Math.max(this.flashAlpha, effect.intensity * (1 - t));
+          this.flashColor = p.color;
+          break;
+        }
+        case "letterbox": {
+          const p = effect.params;
+          this.letterboxAmount = Math.max(this.letterboxAmount, p.ratio * Math.min(t * 4, 1));
+          break;
+        }
+        case "vignette":
+          this.vignetteIntensity = Math.max(
+            this.vignetteIntensity,
+            effect.intensity * Math.min(t * 3, 1)
+          );
+          break;
+        case "fade": {
+          const p = effect.params;
+          this.fadeAlpha = p.fadeIn ? 1 - t : t;
+          break;
+        }
+      }
+      if (t >= 1) effect.active = false;
+    }
+    this.effects = this.effects.filter((e) => e.active);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getShakeOffset() {
+    return { ...this.shakeOffset };
+  }
+  getZoomMultiplier() {
+    return this.zoomMultiplier;
+  }
+  getFlashAlpha() {
+    return this.flashAlpha;
+  }
+  getFlashColor() {
+    return { ...this.flashColor };
+  }
+  getLetterboxAmount() {
+    return this.letterboxAmount;
+  }
+  getVignetteIntensity() {
+    return this.vignetteIntensity;
+  }
+  getFadeAlpha() {
+    return this.fadeAlpha;
+  }
+  getActiveEffectCount() {
+    return this.effects.length;
+  }
+  cancelEffect(id) {
+    const idx = this.effects.findIndex((e) => e.id === id);
+    if (idx < 0) return false;
+    this.effects.splice(idx, 1);
+    return true;
+  }
+  cancelAll() {
+    this.effects = [];
+  }
+};
+
+// src/camera/CameraPath.ts
+var CameraPath = class {
+  points = [];
+  progress = 0;
+  // 0-1
+  speed = 1;
+  // Units per second
+  loop = false;
+  playing = false;
+  // ---------------------------------------------------------------------------
+  // Path Setup
+  // ---------------------------------------------------------------------------
+  setPoints(points) {
+    this.points = [...points];
+  }
+  addPoint(point) {
+    this.points.push(point);
+  }
+  clearPoints() {
+    this.points = [];
+    this.progress = 0;
+  }
+  setSpeed(speed) {
+    this.speed = speed;
+  }
+  setLoop(loop) {
+    this.loop = loop;
+  }
+  // ---------------------------------------------------------------------------
+  // Playback
+  // ---------------------------------------------------------------------------
+  play() {
+    this.playing = true;
+    this.progress = 0;
+  }
+  pause() {
+    this.playing = false;
+  }
+  resume() {
+    this.playing = true;
+  }
+  stop() {
+    this.playing = false;
+    this.progress = 0;
+  }
+  update(dt) {
+    if (!this.playing || this.points.length < 2) return null;
+    const segIndex = Math.min(
+      Math.floor(this.progress * (this.points.length - 1)),
+      this.points.length - 2
+    );
+    const speedMul = this.points[segIndex]?.speedMultiplier ?? 1;
+    const totalLength = this.points.length - 1;
+    this.progress += dt * this.speed * speedMul / totalLength;
+    if (this.progress >= 1) {
+      if (this.loop) {
+        this.progress %= 1;
+      } else {
+        this.progress = 1;
+        this.playing = false;
+      }
+    }
+    return this.evaluate(this.progress);
+  }
+  // ---------------------------------------------------------------------------
+  // Catmull-Rom Evaluation
+  // ---------------------------------------------------------------------------
+  evaluate(t) {
+    const n = this.points.length;
+    if (n === 0) return { position: [0, 0, 0], lookAt: null };
+    if (n === 1) return { position: { ...this.points[0] }, lookAt: null };
+    const f = t * (n - 1);
+    const i = Math.min(Math.floor(f), n - 2);
+    const frac = f - i;
+    const p0 = this.points[Math.max(0, i - 1)];
+    const p1 = this.points[i];
+    const p2 = this.points[Math.min(n - 1, i + 1)];
+    const p3 = this.points[Math.min(n - 1, i + 2)];
+    const position = {
+      x: this.catmullRom(p0.x, p1.x, p2.x, p3.x, frac),
+      y: this.catmullRom(p0.y, p1.y, p2.y, p3.y, frac),
+      z: this.catmullRom(p0.z, p1.z, p2.z, p3.z, frac)
+    };
+    let lookAt = null;
+    if (p1.lookAtX !== void 0 && p2.lookAtX !== void 0) {
+      lookAt = {
+        x: p1.lookAtX + (p2.lookAtX - p1.lookAtX) * frac,
+        y: (p1.lookAtY ?? 0) + ((p2.lookAtY ?? 0) - (p1.lookAtY ?? 0)) * frac,
+        z: (p1.lookAtZ ?? 0) + ((p2.lookAtZ ?? 0) - (p1.lookAtZ ?? 0)) * frac
+      };
+    }
+    return { position, lookAt };
+  }
+  catmullRom(p0, p1, p2, p3, t) {
+    const t2 = t * t, t3 = t2 * t;
+    return 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3 * p1 - 3 * p2 + p3) * t3);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getProgress() {
+    return this.progress;
+  }
+  isPlaying() {
+    return this.playing;
+  }
+  getPointCount() {
+    return this.points.length;
+  }
+};
+
+// src/camera/CameraShake.ts
+var CameraShake = class {
+  layers = /* @__PURE__ */ new Map();
+  time = 0;
+  // ---------------------------------------------------------------------------
+  // Layer Management
+  // ---------------------------------------------------------------------------
+  addLayer(id, config) {
+    this.layers.set(id, {
+      id,
+      trauma: 0,
+      decay: 1,
+      frequency: 15,
+      amplitude: 10,
+      rotationAmount: 0.05,
+      ...config
+    });
+  }
+  removeLayer(id) {
+    this.layers.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Trauma
+  // ---------------------------------------------------------------------------
+  addTrauma(layerId, amount) {
+    const layer = this.layers.get(layerId);
+    if (layer) layer.trauma = Math.min(1, layer.trauma + amount);
+  }
+  setTrauma(layerId, amount) {
+    const layer = this.layers.get(layerId);
+    if (layer) layer.trauma = Math.max(0, Math.min(1, amount));
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    this.time += dt;
+    let totalX = 0, totalY = 0, totalRot = 0;
+    for (const layer of this.layers.values()) {
+      if (layer.trauma <= 0) continue;
+      const shake = layer.trauma * layer.trauma;
+      const t = this.time * layer.frequency;
+      totalX += shake * layer.amplitude * this.noise(t, 0);
+      totalY += shake * layer.amplitude * this.noise(t, 100);
+      totalRot += shake * layer.rotationAmount * this.noise(t, 200);
+      layer.trauma = Math.max(0, layer.trauma - layer.decay * dt);
+    }
+    return { offsetX: totalX, offsetY: totalY, rotation: totalRot };
+  }
+  // ---------------------------------------------------------------------------
+  // Noise (simplified)
+  // ---------------------------------------------------------------------------
+  noise(x, seed) {
+    const n = Math.sin((x + seed) * 12.9898) * 43758.5453;
+    return (n - Math.floor(n)) * 2 - 1;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getTrauma(layerId) {
+    return this.layers.get(layerId)?.trauma ?? 0;
+  }
+  isShaking() {
+    return [...this.layers.values()].some((l) => l.trauma > 0);
+  }
+};
+
+// src/camera/CinematicTrack.ts
+var CinematicTrack = class {
+  keyframes = [];
+  cues = [];
+  currentTime = 0;
+  duration = 0;
+  playing = false;
+  looping = false;
+  speed = 1;
+  cueListeners = [];
+  // ---------------------------------------------------------------------------
+  // Keyframe Management
+  // ---------------------------------------------------------------------------
+  addKeyframe(keyframe) {
+    this.keyframes.push(keyframe);
+    this.keyframes.sort((a, b) => a.time - b.time);
+    this.duration = Math.max(this.duration, keyframe.time);
+  }
+  addCue(time, event, data = {}) {
+    this.cues.push({ time, event, data, fired: false });
+    this.cues.sort((a, b) => a.time - b.time);
+  }
+  removeKeyframesAt(time) {
+    const before = this.keyframes.length;
+    this.keyframes = this.keyframes.filter((k) => Math.abs(k.time - time) > 1e-3);
+    this.recalcDuration();
+    return before - this.keyframes.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Playback
+  // ---------------------------------------------------------------------------
+  play() {
+    this.playing = true;
+  }
+  pause() {
+    this.playing = false;
+  }
+  stop() {
+    this.playing = false;
+    this.currentTime = 0;
+    this.resetCues();
+  }
+  seek(time) {
+    this.currentTime = Math.max(0, Math.min(time, this.duration));
+  }
+  setSpeed(speed) {
+    this.speed = speed;
+  }
+  setLooping(loop) {
+    this.looping = loop;
+  }
+  isPlaying() {
+    return this.playing;
+  }
+  getCurrentTime() {
+    return this.currentTime;
+  }
+  getDuration() {
+    return this.duration;
+  }
+  getProgress() {
+    return this.duration > 0 ? this.currentTime / this.duration : 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    if (!this.playing || this.keyframes.length === 0) return null;
+    this.currentTime += dt * this.speed;
+    for (const cue of this.cues) {
+      if (!cue.fired && this.currentTime >= cue.time) {
+        cue.fired = true;
+        for (const listener of this.cueListeners) listener(cue.event, cue.data);
+      }
+    }
+    if (this.currentTime >= this.duration) {
+      if (this.looping) {
+        this.currentTime %= this.duration;
+        this.resetCues();
+      } else {
+        this.currentTime = this.duration;
+        this.playing = false;
+      }
+    }
+    return this.evaluate(this.currentTime);
+  }
+  // ---------------------------------------------------------------------------
+  // Evaluation
+  // ---------------------------------------------------------------------------
+  evaluate(time) {
+    const state = {
+      position: [0, 0, 0],
+      rotation: { pitch: 0, yaw: 0, roll: 0 },
+      fov: 60,
+      zoom: 1
+    };
+    if (this.keyframes.length === 0) return state;
+    if (this.keyframes.length === 1) {
+      const k = this.keyframes[0];
+      if (k.position) state.position = { ...k.position };
+      if (k.rotation) state.rotation = { ...k.rotation };
+      if (k.fov !== void 0) state.fov = k.fov;
+      if (k.zoom !== void 0) state.zoom = k.zoom;
+      return state;
+    }
+    let kA = this.keyframes[0];
+    let kB = this.keyframes[this.keyframes.length - 1];
+    for (let i = 0; i < this.keyframes.length - 1; i++) {
+      if (time >= this.keyframes[i].time && time <= this.keyframes[i + 1].time) {
+        kA = this.keyframes[i];
+        kB = this.keyframes[i + 1];
+        break;
+      }
+    }
+    const range = kB.time - kA.time;
+    const rawT = range > 0 ? (time - kA.time) / range : 1;
+    const t = this.applyEasing(rawT, kB.easing);
+    if (kA.position && kB.position) {
+      state.position.x = kA.position.x + (kB.position.x - kA.position.x) * t;
+      state.position.y = kA.position.y + (kB.position.y - kA.position.y) * t;
+      state.position.z = kA.position.z + (kB.position.z - kA.position.z) * t;
+    } else if (kB.position) {
+      state.position = { ...kB.position };
+    } else if (kA.position) {
+      state.position = { ...kA.position };
+    }
+    if (kA.rotation && kB.rotation) {
+      state.rotation.pitch = kA.rotation.pitch + (kB.rotation.pitch - kA.rotation.pitch) * t;
+      state.rotation.yaw = kA.rotation.yaw + (kB.rotation.yaw - kA.rotation.yaw) * t;
+      state.rotation.roll = kA.rotation.roll + (kB.rotation.roll - kA.rotation.roll) * t;
+    }
+    if (kA.fov !== void 0 && kB.fov !== void 0) {
+      state.fov = kA.fov + (kB.fov - kA.fov) * t;
+    }
+    if (kA.zoom !== void 0 && kB.zoom !== void 0) {
+      state.zoom = kA.zoom + (kB.zoom - kA.zoom) * t;
+    }
+    return state;
+  }
+  // ---------------------------------------------------------------------------
+  // Easing
+  // ---------------------------------------------------------------------------
+  applyEasing(t, easing) {
+    switch (easing) {
+      case "linear":
+        return t;
+      case "easeIn":
+        return t * t;
+      case "easeOut":
+        return 1 - (1 - t) * (1 - t);
+      case "easeInOut":
+        return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+      case "smoothStep":
+        return t * t * (3 - 2 * t);
+      default:
+        return t;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Listeners
+  // ---------------------------------------------------------------------------
+  onCue(listener) {
+    this.cueListeners.push(listener);
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  resetCues() {
+    for (const cue of this.cues) cue.fired = false;
+  }
+  recalcDuration() {
+    this.duration = this.keyframes.reduce((max, k) => Math.max(max, k.time), 0);
+  }
+  getKeyframeCount() {
+    return this.keyframes.length;
+  }
+  getCueCount() {
+    return this.cues.length;
+  }
+  clear() {
+    this.keyframes = [];
+    this.cues = [];
+    this.duration = 0;
+    this.currentTime = 0;
+  }
+};
+
+export {
+  CameraConstraints,
+  CameraController,
+  CameraEffects,
+  CameraPath,
+  CameraShake,
+  CinematicTrack,
+  camera_exports
+};