@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/chunk-CX4WTVGH.js

@@ -0,0 +1,4492 @@
+import { captureCamera } from './chunk-V3QINEEG.js';
+import { protocolVersionFor, SDK_VERSION, QUALITY } from './chunk-APBOWWSV.js';
+import { BAKERY_NODE_MARKER, builtinFor, tslRuntimeRegistered, toNodeObject } from './chunk-S4AJTLLN.js';
+import { findPresetRooms, sha256, environmentSourceFor, isPresetEnvironment, roomPresetSpecOf, roomPresetFactsOf, roomPresetAssetsOf } from './chunk-AF5BIELI.js';
+import { idOf, shouldExclude, captureFog, readUserData, scenePath, captureLights, captureRuntime, stampIds, captureEnvironmentSettings, excludedItself, bakeCandidates, resolveProbe, defaultIncludeIds, quantizeBakeView, bakeBounds, isBakeWrittenUv } from './chunk-HQTUFVMM.js';
+import { MAX_BAKE_OBJECTS, MAX_BAKE_TEXELS, roomIsPrebaked, roomPrebakeChanges, MAX_BAKE_SIMPLIFY, BAKE_TEXTURE_SIZES, MAX_BAKE_SIMPLIFY_TRIANGLES, BAKE_ATLAS_SIZES } from './chunk-W6WQ5UP7.js';
+import { Bakery3Error } from './chunk-3G5QL4F4.js';
+import { Vector3, Vector2, Matrix4, Quaternion } from 'three';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+
+// src/timeline/easing.ts
+var NAMED = {
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+function ease(easing, t) {
+  const clamped = t <= 0 ? 0 : t >= 1 ? 1 : t;
+  if (!easing || easing === "linear") return clamped;
+  const points = Array.isArray(easing) ? easing : NAMED[easing];
+  if (!points) return clamped;
+  return cubicBezier(points[0], points[1], points[2], points[3], clamped);
+}
+function cubicBezier(x1, y1, x2, y2, t) {
+  if (x1 === y1 && x2 === y2) return t;
+  const s = solveForX(x1, x2, t);
+  return bezier(y1, y2, s);
+}
+function bezier(a, b, s) {
+  const inv = 1 - s;
+  return 3 * inv * inv * s * a + 3 * inv * s * s * b + s * s * s;
+}
+function slope(a, b, s) {
+  const inv = 1 - s;
+  return 3 * inv * inv * a + 6 * inv * s * (b - a) + 3 * s * s * (1 - b);
+}
+function solveForX(x1, x2, target) {
+  let s = target;
+  for (let i = 0; i < 8; i++) {
+    const error = bezier(x1, x2, s) - target;
+    if (Math.abs(error) < 1e-6) return s;
+    const derivative = slope(x1, x2, s);
+    if (Math.abs(derivative) < 1e-6) break;
+    s -= error / derivative;
+  }
+  let low = 0;
+  let high = 1;
+  s = target;
+  for (let i = 0; i < 24; i++) {
+    const x = bezier(x1, x2, s);
+    if (Math.abs(x - target) < 1e-6) return s;
+    if (x > target) high = s;
+    else low = s;
+    s = (low + high) / 2;
+  }
+  return s;
+}
+
+// src/timeline/orbit.ts
+function toSpherical(position, center) {
+  const dx = position[0] - center[0];
+  const dy = position[1] - center[1];
+  const dz = position[2] - center[2];
+  const radius = Math.hypot(dx, dy, dz);
+  if (radius < 1e-9) return { radius: 0, yaw: 0, pitch: 0 };
+  return {
+    radius,
+    yaw: Math.atan2(dx, dz),
+    // Clamped before asin: a normalized component can land at 1.0000000002.
+    pitch: Math.asin(Math.max(-1, Math.min(1, dy / radius)))
+  };
+}
+function fromSpherical(spherical, center) {
+  const { radius, yaw, pitch } = spherical;
+  const horizontal = radius * Math.cos(pitch);
+  return [
+    center[0] + horizontal * Math.sin(yaw),
+    center[1] + radius * Math.sin(pitch),
+    center[2] + horizontal * Math.cos(yaw)
+  ];
+}
+function orbitAt(from, to, center, t) {
+  return fromSpherical(
+    {
+      radius: from.radius + (to.radius - from.radius) * t,
+      yaw: from.yaw + (to.yaw - from.yaw) * t,
+      pitch: from.pitch + (to.pitch - from.pitch) * t
+    },
+    center
+  );
+}
+function lookAtQuaternion(eye, target, up = [0, 1, 0]) {
+  let z = normalize([
+    eye[0] - target[0],
+    eye[1] - target[1],
+    eye[2] - target[2]
+  ]);
+  if (lengthOf(z) === 0) z = [0, 0, 1];
+  let x = cross(up, z);
+  if (lengthOf(x) === 0) {
+    if (Math.abs(up[2]) === 1) z[0] += 1e-4;
+    else z[2] += 1e-4;
+    z = normalize(z);
+    x = cross(up, z);
+  }
+  x = normalize(x);
+  const y = cross(z, x);
+  return matrixToQuaternion(x, y, z);
+}
+function matrixToQuaternion(x, y, z) {
+  const m00 = x[0];
+  const m10 = x[1];
+  const m20 = x[2];
+  const m01 = y[0];
+  const m11 = y[1];
+  const m21 = y[2];
+  const m02 = z[0];
+  const m12 = z[1];
+  const m22 = z[2];
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s2 = 0.5 / Math.sqrt(trace + 1);
+    return [(m21 - m12) * s2, (m02 - m20) * s2, (m10 - m01) * s2, 0.25 / s2];
+  }
+  if (m00 > m11 && m00 > m22) {
+    const s2 = 2 * Math.sqrt(1 + m00 - m11 - m22);
+    return [0.25 * s2, (m01 + m10) / s2, (m02 + m20) / s2, (m21 - m12) / s2];
+  }
+  if (m11 > m22) {
+    const s2 = 2 * Math.sqrt(1 + m11 - m00 - m22);
+    return [(m01 + m10) / s2, 0.25 * s2, (m12 + m21) / s2, (m02 - m20) / s2];
+  }
+  const s = 2 * Math.sqrt(1 + m22 - m00 - m11);
+  return [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s];
+}
+function eulerToQuaternion(euler) {
+  const [x, y, z] = euler;
+  const c1 = Math.cos(x / 2);
+  const c2 = Math.cos(y / 2);
+  const c3 = Math.cos(z / 2);
+  const s1 = Math.sin(x / 2);
+  const s2 = Math.sin(y / 2);
+  const s3 = Math.sin(z / 2);
+  return [
+    s1 * c2 * c3 + c1 * s2 * s3,
+    c1 * s2 * c3 - s1 * c2 * s3,
+    c1 * c2 * s3 + s1 * s2 * c3,
+    c1 * c2 * c3 - s1 * s2 * s3
+  ];
+}
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function lengthOf(v) {
+  return Math.hypot(v[0], v[1], v[2]);
+}
+function normalize(v) {
+  const length = lengthOf(v);
+  return length === 0 ? [0, 0, 0] : [v[0] / length, v[1] / length, v[2] / length];
+}
+
+// src/timeline/properties.ts
+function hemisphereOf(object) {
+  const light = object;
+  return light.isHemisphereLight ? light : void 0;
+}
+function sceneOf(object) {
+  const scene = object;
+  return scene.isScene ? scene : void 0;
+}
+function aimedLight(object) {
+  const light = object;
+  return (light.isDirectionalLight || light.isSpotLight) && light.target ? light : void 0;
+}
+function materialOf(object) {
+  const material = object.material;
+  if (!material) return void 0;
+  return Array.isArray(material) ? material[0] : material;
+}
+function readVector(v) {
+  return v ? [v.x, v.y, v.z] : void 0;
+}
+function scalar(get, set) {
+  return {
+    size: 1,
+    read(object) {
+      const material = materialOf(object);
+      const value = material ? get(material) : void 0;
+      return typeof value === "number" ? [value] : void 0;
+    },
+    write(object, value) {
+      const material = materialOf(object);
+      if (material) set(material, value[0]);
+    }
+  };
+}
+function colorProperty(pick) {
+  return {
+    size: 3,
+    color: true,
+    read(object) {
+      const target = pick(object);
+      return target ? [target.r, target.g, target.b] : void 0;
+    },
+    write(object, value) {
+      const target = pick(object);
+      if (!target) return;
+      if (target.setRGB) target.setRGB(value[0], value[1], value[2]);
+      else Object.assign(target, { r: value[0], g: value[1], b: value[2] });
+    }
+  };
+}
+var OBJECT_PROPERTIES = {
+  position: {
+    size: 3,
+    read: (object) => readVector(object.position),
+    write: (object, value) => object.position.set(value[0], value[1], value[2])
+  },
+  rotation: {
+    size: 3,
+    channel: "quaternion",
+    read: (object) => readVector(
+      object.rotation
+    ),
+    write: (object, value) => object.rotation.set(value[0], value[1], value[2])
+  },
+  scale: {
+    size: 3,
+    read: (object) => readVector(object.scale),
+    write: (object, value) => object.scale.set(value[0], value[1], value[2])
+  },
+  // A light's own color (the worker drives the lamp, or for an ambient or
+  // hemisphere light the dome), and a mesh's material's.
+  color: colorProperty(
+    (object) => object.isLight ? object.color : materialOf(object)?.color
+  ),
+  emissive: colorProperty((object) => materialOf(object)?.emissive),
+  emissiveIntensity: scalar(
+    (material) => material.emissiveIntensity,
+    (material, value) => {
+      material.emissiveIntensity = value;
+    }
+  ),
+  roughness: scalar(
+    (material) => material.roughness,
+    (material, value) => {
+      material.roughness = value;
+    }
+  ),
+  metalness: scalar(
+    (material) => material.metalness,
+    (material, value) => {
+      material.metalness = value;
+    }
+  ),
+  opacity: scalar(
+    (material) => material.opacity,
+    (material, value) => {
+      material.opacity = value;
+      if (value < 1 && !material.transparent) {
+        material.transparent = true;
+        material.needsUpdate = true;
+      }
+    }
+  ),
+  intensity: {
+    size: 1,
+    read(object) {
+      const light = object;
+      return light.isLight && typeof light.intensity === "number" ? [light.intensity] : void 0;
+    },
+    write(object, value) {
+      const light = object;
+      if (light.isLight) light.intensity = value[0];
+    }
+  },
+  /** A HemisphereLight's color from below. Its `color` is the sky. */
+  groundColor: {
+    ...colorProperty((object) => hemisphereOf(object)?.groundColor),
+    appliesTo: (object) => hemisphereOf(object) !== void 0
+  },
+  /**
+   * The scene's own `environmentIntensity`, on the Scene as a target: the
+   * environment's `intensity` channel. It scales the HDRI only, as in three.
+   */
+  environmentIntensity: {
+    size: 1,
+    appliesTo: (object) => sceneOf(object) !== void 0,
+    read(object) {
+      const value = sceneOf(object)?.environmentIntensity;
+      return typeof value === "number" ? [value] : void 0;
+    },
+    write(object, value) {
+      const scene = sceneOf(object);
+      if (scene) scene.environmentIntensity = value[0];
+    }
+  },
+  /**
+   * The scene's `environmentRotation`, radians, XYZ, as three holds it: the
+   * environment's `rotation` channel. Unlike an object's rotation it stays
+   * an euler on the wire, because that is what the environment carries.
+   */
+  environmentRotation: {
+    size: 3,
+    appliesTo: (object) => sceneOf(object) !== void 0,
+    read: (object) => readVector(sceneOf(object)?.environmentRotation),
+    write(object, value) {
+      sceneOf(object)?.environmentRotation?.set(
+        value[0],
+        value[1],
+        value[2]
+      );
+    }
+  },
+  /**
+   * Where a directional or spot light aims: its `target`'s WORLD position,
+   * which is what three aims it at and what the channel carries. Written
+   * back through the target's parent, if it has one, so the light points at
+   * the same place in the viewport as in the render.
+   */
+  target: {
+    size: 3,
+    appliesTo: (object) => aimedLight(object) !== void 0,
+    read(object) {
+      const target = aimedLight(object)?.target;
+      if (!target) return void 0;
+      target.updateMatrixWorld();
+      const e = target.matrixWorld.elements;
+      return [e[12], e[13], e[14]];
+    },
+    write(object, value) {
+      const target = aimedLight(object)?.target;
+      if (!target) return;
+      target.position.set(value[0], value[1], value[2]);
+      target.parent?.worldToLocal(target.position);
+      target.updateMatrixWorld();
+    }
+  }
+};
+var CAMERA_PROPERTIES = {
+  position: OBJECT_PROPERTIES.position,
+  lookAt: {
+    size: 3,
+    // There is no live "lookAt" to read; the timeline supplies its own center
+    // when a keyframe is captured. Returning undefined keeps the panel from
+    // offering a capture button that would silently record the wrong thing.
+    read: () => void 0,
+    // Applied together with position by the timeline, never alone: aiming at a
+    // point before moving to the position it was computed for produces one
+    // frame of visible swing.
+    write: () => void 0
+  },
+  fov: {
+    size: 1,
+    read(object) {
+      const camera = object;
+      return typeof camera.fov === "number" ? [camera.fov] : void 0;
+    },
+    write(object, value) {
+      const camera = object;
+      if (typeof camera.fov !== "number") return;
+      camera.fov = value[0];
+      camera.updateProjectionMatrix?.();
+    }
+  }
+};
+function propertyDefinition(target, property) {
+  return target === "camera" ? CAMERA_PROPERTIES[property] : OBJECT_PROPERTIES[property];
+}
+function readCameraLookAt(camera, center) {
+  camera.updateMatrixWorld();
+  const e = camera.matrixWorld.elements;
+  const position = [e[12], e[13], e[14]];
+  const forward = normalize2([-e[8], -e[9], -e[10]]);
+  const distance = Math.hypot(
+    position[0] - center[0],
+    position[1] - center[1],
+    position[2] - center[2]
+  ) || 1;
+  return [
+    position[0] + forward[0] * distance,
+    position[1] + forward[1] * distance,
+    position[2] + forward[2] * distance
+  ];
+}
+function normalize2(v) {
+  const length = Math.hypot(v[0], v[1], v[2]);
+  return length === 0 ? [0, 0, -1] : [v[0] / length, v[1] / length, v[2] / length];
+}
+function hexToLinear(hex) {
+  const value = hex.trim().replace(/^#/, "");
+  const full = value.length === 3 ? value.split("").map((c) => c + c).join("") : value;
+  const int = Number.parseInt(full, 16);
+  if (!Number.isFinite(int)) return [1, 1, 1];
+  return [
+    srgbToLinear((int >> 16 & 255) / 255),
+    srgbToLinear((int >> 8 & 255) / 255),
+    srgbToLinear((int & 255) / 255)
+  ];
+}
+function srgbToLinear(c) {
+  return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+}
+function linearToSrgbHex(value) {
+  const channel = (v) => {
+    const srgb = v < 31308e-7 ? v * 12.92 : 1.055 * Math.pow(Math.max(v, 0), 0.41666) - 0.055;
+    return Math.round(Math.max(0, Math.min(1, srgb)) * 255).toString(16).padStart(2, "0");
+  };
+  return `#${channel(value[0] ?? 0)}${channel(value[1] ?? 0)}${channel(value[2] ?? 0)}`;
+}
+
+// src/protocol/animation.ts
+var ENVIRONMENT_CHANNEL_SIZES = {
+  intensity: 1,
+  rotation: 3,
+  ambientIntensity: 1,
+  ambientColor: 3
+};
+var HEMISPHERE_CHANNEL_PROPERTIES = [
+  "intensity",
+  "color",
+  "groundColor"
+];
+var WORLD_CHECK_FRAMES = 5;
+var ANIMATION_CHANNEL_SIZES = {
+  position: 3,
+  quaternion: 4,
+  scale: 3,
+  color: 3,
+  emissive: 3,
+  fov: 1,
+  emissiveIntensity: 1,
+  roughness: 1,
+  metalness: 1,
+  opacity: 1,
+  intensity: 1,
+  target: 3,
+  groundColor: 3
+};
+var MAX_ANIMATION_FRAMES = 1800;
+
+// src/protocol/shader.ts
+var SHADER_GRAPH_VERSION = 1;
+var SHADER_OPS = {
+  // ---- values ------------------------------------------------------------
+  /** params: { value: number | number[], type } */
+  const: { tier: "exact" },
+  /**
+   * A uniform, baked to the value it held at capture. A still render is a
+   * snapshot; an animated uniform renders the moment the button was pressed.
+   * params: { value, type, name? }
+   */
+  uniform: { tier: "exact" },
+  // ---- geometry inputs ---------------------------------------------------
+  /** params: { index }. TEXCOORD_<index> of the mesh being shaded. */
+  uv: { tier: "exact" },
+  /** COLOR_0, as the mesh carries it. */
+  vertex_color: { tier: "exact" },
+  /** params: { space: 'local' | 'world' | 'view' } */
+  position: {
+    tier: "exact"
+  },
+  /**
+   * params: { space: 'world' | 'view' | 'local' }. View- and local-space
+   * normals are rebuilt from the renderer's world-space normal;
+   * rotation-invariant uses (dot products, fresnel) match exactly, raw
+   * components differ.
+   */
+  normal: { tier: "exact" },
+  /**
+   * Direction from the shaded point toward the camera, in view space. The
+   * worker rebuilds three's exact frame.
+   */
+  view_direction: { tier: "exact" },
+  /** The world-space camera location. */
+  camera_position: { tier: "exact" },
+  // ---- textures ----------------------------------------------------------
+  /**
+   * params: { image: 'sha256:…', colorSpace: 'srgb' | 'linear',
+   *           wrap: 'repeat' | 'clamp' | 'mirror', filter: 'linear' | 'nearest' }
+   * inputs: [uv?]. Sampled at TEXCOORD_0 when the input is omitted.
+   */
+  texture: { tier: "exact" },
+  /**
+   * Tangent-space normal mapping. inputs: [textureColor, scale?].
+   */
+  normal_map: { tier: "exact" },
+  /** Bump from a height value. inputs: [height, scale?]. */
+  bump_map: {
+    tier: "approximate",
+    note: "three.js bump-maps with screen-space derivatives, the renderer with surface derivatives. The relief reads the same; the exact pixels differ."
+  },
+  // ---- arithmetic --------------------------------------------------------
+  add: { tier: "exact" },
+  sub: { tier: "exact" },
+  mul: { tier: "exact" },
+  div: { tier: "exact" },
+  mod: { tier: "exact" },
+  pow: { tier: "exact" },
+  min: { tier: "exact" },
+  max: { tier: "exact" },
+  abs: { tier: "exact" },
+  sign: { tier: "exact" },
+  floor: { tier: "exact" },
+  ceil: { tier: "exact" },
+  round: { tier: "exact" },
+  trunc: { tier: "exact" },
+  fract: { tier: "exact" },
+  sqrt: { tier: "exact" },
+  inverse_sqrt: { tier: "exact" },
+  exp: { tier: "exact" },
+  exp2: { tier: "exact" },
+  log: { tier: "exact" },
+  log2: { tier: "exact" },
+  sin: { tier: "exact" },
+  cos: { tier: "exact" },
+  tan: { tier: "exact" },
+  asin: { tier: "exact" },
+  acos: { tier: "exact" },
+  atan: { tier: "exact" },
+  /** inputs: [y, x], like GLSL's two-argument atan. */
+  atan2: { tier: "exact" },
+  radians: { tier: "exact" },
+  degrees: { tier: "exact" },
+  negate: { tier: "exact" },
+  one_minus: { tier: "exact" },
+  reciprocal: { tier: "exact" },
+  saturate: { tier: "exact" },
+  clamp: { tier: "exact" },
+  /** inputs: [a, b, t]. three's `mix`, the same lerp on both sides. */
+  mix: { tier: "exact" },
+  step: { tier: "exact" },
+  smoothstep: { tier: "exact" },
+  /** inputs: [value, inLow, inHigh, outLow, outHigh]; params: { clamp } */
+  remap: { tier: "exact" },
+  // ---- vectors -----------------------------------------------------------
+  dot: { tier: "exact" },
+  cross: { tier: "exact" },
+  length: { tier: "exact" },
+  distance: { tier: "exact" },
+  normalize: { tier: "exact" },
+  reflect: { tier: "exact" },
+  refract: { tier: "exact" },
+  faceforward: { tier: "exact" },
+  /** params: { components: 'x' | 'xy' | 'zyx' | … } */
+  swizzle: { tier: "exact" },
+  /** inputs: the components, in order. Two to four of them. */
+  join: { tier: "exact" },
+  /** params: { to: 'float' | 'vec2' | 'vec3' | 'vec4' | 'color' | 'int' | 'uint' | 'bool' } */
+  convert: { tier: "exact" },
+  /** Rotate a vector about an axis. inputs: [vector, axis, angle]. */
+  rotate: { tier: "exact" },
+  // ---- comparison and choice --------------------------------------------
+  less_than: { tier: "exact" },
+  greater_than: { tier: "exact" },
+  less_equal: { tier: "exact" },
+  greater_equal: { tier: "exact" },
+  equal: {
+    tier: "approximate",
+    note: "Float equality is compared exactly on both sides, but GPU rounding differs between the browser and the renderer, so equality on computed values may flip near the boundary."
+  },
+  not_equal: {
+    tier: "approximate",
+    note: "Float equality is compared exactly on both sides, but GPU rounding differs between the browser and the renderer, so equality on computed values may flip near the boundary."
+  },
+  and: { tier: "exact" },
+  or: { tier: "exact" },
+  not: { tier: "exact" },
+  /** inputs: [condition, ifTrue, ifFalse]. */
+  select: { tier: "exact" },
+  // ---- color ------------------------------------------------------------
+  /**
+   * Luminance and color-space ops use Rec.709 weights on both sides.
+   */
+  luminance: { tier: "exact" },
+  srgb_to_linear: {
+    tier: "approximate",
+    note: "The renderer applies a gamma-2.2 curve rather than the piecewise sRGB transfer function; the toe below 0.04 differs slightly."
+  },
+  linear_to_srgb: {
+    tier: "approximate",
+    note: "The renderer applies a gamma-2.2 curve rather than the piecewise sRGB transfer function; the toe below 0.04 differs slightly."
+  },
+  // ---- procedural (three.js implementations, native equivalents) ---------
+  /**
+   * three's `checker()`: a 2×2 tile per UV unit.
+   */
+  checker: {
+    tier: "exact"
+  },
+  /**
+   * MaterialX Perlin noise, rendered through the renderer's own
+   * Perlin-derived noise. The lattices differ: the look matches, the exact
+   * pattern does not. params: { dimensions: 2 | 3 }
+   */
+  mx_noise: {
+    tier: "approximate",
+    note: "MaterialX Perlin noise renders through the renderer's own Perlin-based noise. The character matches; the exact pattern placement does not."
+  },
+  /** params: { octaves, lacunarity, diminish }. Fractal (fBm) noise. */
+  mx_fractal_noise: {
+    tier: "approximate",
+    note: "MaterialX fractal noise renders through the renderer's own noise with matching octaves. The character matches; the exact pattern placement does not."
+  },
+  /**
+   * Worley/cellular noise, as three calls it: SQUARED distances, to the
+   * nearest point, or with `vector` to the nearest `features` (2 or 3).
+   * inputs: [coordinate, jitter]; params: { vector?, features?, dimensions? },
+   * `dimensions: 2` when the coordinate is 2D, which three runs as 2D noise.
+   */
+  mx_worley_noise: {
+    tier: "approximate",
+    note: "MaterialX Worley noise renders through the renderer's cellular noise. Cell shapes match in character, not placement."
+  },
+  /** Constant pseudo-random value per integer cell. */
+  mx_cell_noise: {
+    tier: "approximate",
+    note: "MaterialX cell noise renders as a hash over the floored coordinate. Statistically identical, per-cell values differ."
+  },
+  // ---- Bakery-only (from @oeave/bakery3/tsl) -------------------------------
+  /**
+   * These exist because the renderer has procedural textures and shading
+   * inputs the browser cannot compute. The SDK exposes them as TSL nodes
+   * that preview approximately in WebGPU and serialize exactly here: the
+   * render is the real one, the viewport is the sketch.
+   */
+  /** params: { dimensions, scale, detail, roughness, lacunarity, distortion } */
+  bk_noise_texture: { tier: "bakery" },
+  /** params: { dimensions, feature, metric, scale, randomness, exponent } */
+  bk_voronoi_texture: { tier: "bakery" },
+  /** params: { type, bands_direction, rings_direction, profile, scale,
+   *            distortion, detail, detail_scale, detail_roughness, phase } */
+  bk_wave_texture: { tier: "bakery" },
+  /** params: { depth, scale, distortion } */
+  bk_magic_texture: { tier: "bakery" },
+  /** params: { gradient_type } */
+  bk_gradient_texture: { tier: "bakery" },
+  /** params: { offset, frequency, squash, …brick geometry } */
+  bk_brick_texture: { tier: "bakery" },
+  /** params: { dimensions }. A hash of the input coordinate. */
+  bk_white_noise: { tier: "bakery" },
+  /** Traced ambient occlusion. params: { distance, samples, only_local } */
+  bk_ambient_occlusion: { tier: "bakery" },
+  /** Rounds geometry edges at shading time. params: { radius, samples } */
+  bk_bevel: { tier: "bakery" },
+  /** Curvature of the surface: concave 0, flat 0.5, convex 1. */
+  bk_pointiness: { tier: "bakery" },
+  /** 1 on triangle edges, 0 elsewhere. params: { size, pixel_size } */
+  bk_wireframe: { tier: "bakery" },
+  /** Physically correct fresnel. inputs: [ior]. */
+  bk_fresnel: { tier: "bakery" },
+  /** Facing/fresnel layer weight. inputs: [blend]; params: { output } */
+  bk_layer_weight: { tier: "bakery" },
+  /**
+   * A color ramp. inputs: [fac];
+   * params: { interpolation, stops: [pos, r, g, b, a, …] flat }
+   */
+  bk_color_ramp: { tier: "bakery" },
+  /** Blackbody temperature to color. inputs: [kelvin]. */
+  bk_blackbody: { tier: "bakery" },
+  /** params: { hue, saturation, value, fac } as defaults; inputs override. */
+  bk_hsv: { tier: "bakery" },
+  /** Brightness/contrast. inputs: [color, bright, contrast]. */
+  bk_brightness_contrast: { tier: "bakery" },
+  /** A gamma curve. inputs: [color, gamma]. */
+  bk_gamma: { tier: "bakery" }
+};
+
+// src/protocol/complexity.ts
+var ENCLOSURE_RAYS = 128;
+var ENCLOSURE_REACH = 60;
+function skyDirections(count) {
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  const lowest = Math.sin(2 * Math.PI / 180);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const y = lowest + (1 - lowest) * ((i + 0.5) / count);
+    const r = Math.sqrt(1 - y * y);
+    const a = i * golden;
+    out.push([Math.cos(a) * r, y, Math.sin(a) * r]);
+  }
+  return out;
+}
+function vertex(mesh, v, out, at) {
+  const p = mesh.positions;
+  const m = mesh.matrix;
+  const x = p[v * 3], y = p[v * 3 + 1], z = p[v * 3 + 2];
+  if (!m) {
+    out[at] = x;
+    out[at + 1] = y;
+    out[at + 2] = z;
+    return;
+  }
+  out[at] = m[0] * x + m[4] * y + m[8] * z + m[12];
+  out[at + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+  out[at + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+}
+function prepare(mesh) {
+  const p = mesh.positions;
+  if (p.length < 9) return null;
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < p.length; i += 3) {
+    for (let k = 0; k < 3; k++) {
+      const value = p[i + k];
+      if (value < lo[k]) lo[k] = value;
+      if (value > hi[k]) hi[k] = value;
+    }
+  }
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  const corner = [0, 0, 0];
+  const probe = {
+    positions: [0, 0, 0],
+    matrix: mesh.matrix ?? null
+  };
+  for (let c = 0; c < 8; c++) {
+    probe.positions[0] = c & 1 ? hi[0] : lo[0];
+    probe.positions[1] = c & 2 ? hi[1] : lo[1];
+    probe.positions[2] = c & 4 ? hi[2] : lo[2];
+    vertex(probe, 0, corner, 0);
+    for (let k = 0; k < 3; k++) {
+      if (corner[k] < min[k]) min[k] = corner[k];
+      if (corner[k] > max[k]) max[k] = corner[k];
+    }
+  }
+  return { mesh, min, max };
+}
+function boxEntry(o, d, min, max) {
+  let near = 0;
+  let far = ENCLOSURE_REACH;
+  for (let k = 0; k < 3; k++) {
+    const lo = min[k] - 1e-4;
+    const hi = max[k] + 1e-4;
+    if (Math.abs(d[k]) < 1e-12) {
+      if (o[k] < lo || o[k] > hi) return Infinity;
+      continue;
+    }
+    let t1 = (lo - o[k]) / d[k];
+    let t2 = (hi - o[k]) / d[k];
+    if (t1 > t2) [t1, t2] = [t2, t1];
+    if (t1 > near) near = t1;
+    if (t2 < far) far = t2;
+    if (near > far) return Infinity;
+  }
+  return near;
+}
+function hitsMesh(o, d, mesh) {
+  const index = mesh.indices;
+  const count = index ? index.length : mesh.positions.length / 3;
+  const t = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  for (let i = 0; i + 2 < count; i += 3) {
+    vertex(mesh, index ? index[i] : i, t, 0);
+    vertex(mesh, index ? index[i + 1] : i + 1, t, 3);
+    vertex(mesh, index ? index[i + 2] : i + 2, t, 6);
+    const e1x = t[3] - t[0], e1y = t[4] - t[1], e1z = t[5] - t[2];
+    const e2x = t[6] - t[0], e2y = t[7] - t[1], e2z = t[8] - t[2];
+    const px = d[1] * e2z - d[2] * e2y, py = d[2] * e2x - d[0] * e2z, pz = d[0] * e2y - d[1] * e2x;
+    const det = e1x * px + e1y * py + e1z * pz;
+    if (Math.abs(det) < 1e-12) continue;
+    const inv = 1 / det;
+    const sx = o[0] - t[0], sy = o[1] - t[1], sz = o[2] - t[2];
+    const u = (sx * px + sy * py + sz * pz) * inv;
+    if (u < 0 || u > 1) continue;
+    const qx = sy * e1z - sz * e1y, qy = sz * e1x - sx * e1z, qz = sx * e1y - sy * e1x;
+    const v = (d[0] * qx + d[1] * qy + d[2] * qz) * inv;
+    if (v < 0 || u + v > 1) continue;
+    const distance = (e2x * qx + e2y * qy + e2z * qz) * inv;
+    if (distance > 1e-4 && distance < ENCLOSURE_REACH) return true;
+  }
+  return false;
+}
+function enclosureOf(meshes, eye, rays = ENCLOSURE_RAYS) {
+  const prepared = meshes.filter((mesh) => !mesh.emitter).map(prepare).filter((mesh) => mesh !== null);
+  if (!prepared.length) return 0;
+  let hidden = 0;
+  for (const d of skyDirections(rays)) {
+    const order = prepared.map((candidate) => ({
+      mesh: candidate.mesh,
+      entry: boxEntry(eye, d, candidate.min, candidate.max)
+    })).filter((candidate) => candidate.entry < ENCLOSURE_REACH).sort((a, b) => a.entry - b.entry);
+    if (order.some(({ mesh }) => hitsMesh(eye, d, mesh))) hidden++;
+  }
+  return hidden / rays;
+}
+function complexityOf(meshes, eye, objects = meshes.length) {
+  return { enclosure: round2(enclosureOf(meshes, eye)), objects };
+}
+function round2(value) {
+  return Math.round(value * 100) / 100;
+}
+
+// src/capture/ambient.ts
+function ambientLightsIn(root) {
+  const lights = [];
+  root.traverse((object) => {
+    const light = object;
+    if (!light.isAmbientLight || !light.visible && !readUserData(object).renderOnly)
+      return;
+    lights.push(light);
+  });
+  return lights;
+}
+function combineAmbient(terms) {
+  if (terms.length === 1) {
+    const [only] = terms;
+    return only.intensity > 0 ? { color: [...only.color], intensity: only.intensity } : void 0;
+  }
+  const sum = [0, 0, 0];
+  for (const term of terms) {
+    for (let c = 0; c < 3; c++) sum[c] += term.color[c] * term.intensity;
+  }
+  const intensity = Math.max(...sum);
+  if (!(intensity > 0)) return void 0;
+  return {
+    color: [sum[0] / intensity, sum[1] / intensity, sum[2] / intensity],
+    intensity
+  };
+}
+function ambientTermOf(light) {
+  const color = light.color;
+  return {
+    color: color ? [color.r, color.g, color.b] : [1, 1, 1],
+    intensity: light.intensity ?? 0
+  };
+}
+function capturedAmbient(root) {
+  const lights = ambientLightsIn(root);
+  const term = combineAmbient(lights.map(ambientTermOf));
+  if (!term) return void 0;
+  if (lights.length === 1) {
+    const color2 = lights[0].color;
+    return {
+      color: color2 ? `#${color2.getHexString()}` : "#ffffff",
+      intensity: term.intensity
+    };
+  }
+  const color = lights.find((light) => light.color)?.color;
+  const hex = color ? color.clone().setRGB(term.color[0], term.color[1], term.color[2]).getHexString() : "ffffff";
+  return { color: `#${hex}`, intensity: term.intensity };
+}
+
+// src/timeline/bake.ts
+function bakeTimeline(timeline, options = {}) {
+  const fps = Math.max(1, Math.round(options.fps ?? timeline.fps));
+  const duration = Math.max(1 / fps, options.duration ?? timeline.duration);
+  const frameCount = Math.max(1, Math.round(duration * fps));
+  if (frameCount > MAX_ANIMATION_FRAMES) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `${frameCount} frames is above the ${MAX_ANIMATION_FRAMES}-frame ceiling.`,
+      why: `${duration}s at ${fps} fps is more render time than any single request is allowed to buy. A video is where one wrong number turns minutes into hours.`,
+      fix: "Shorten the timeline, lower the fps, or render it in sections.",
+      docs: "https://bakery3.com/docs/animation"
+    });
+  }
+  const scene = options.scene ?? timeline.scene;
+  const channels = [];
+  channels.push(...cameraChannels(timeline, fps, frameCount));
+  channels.push(...objectChannels(timeline, fps, frameCount, scene));
+  channels.push(...environmentChannels(timeline, fps, frameCount, scene));
+  if (!channels.length) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: "The timeline has nothing to animate.",
+      why: "A video of an unchanging scene costs one render per frame and looks exactly like the still.",
+      fix: "Add a move, such as tl.push({ object: 'camera', orbitY: 90 }), or render a still with render().",
+      docs: "https://bakery3.com/docs/animation"
+    });
+  }
+  const checks = worldChecks(timeline, fps, frameCount, channels);
+  return { fps, frameCount, channels, ...checks.length ? { checks } : {} };
+}
+function checkFrames(frameCount) {
+  const last = Math.max(0, frameCount - 1);
+  const frames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < WORLD_CHECK_FRAMES; i++)
+    frames.add(Math.round(last * i / (WORLD_CHECK_FRAMES - 1)));
+  return [...frames].sort((a, b) => a - b);
+}
+function worldChecks(timeline, fps, frameCount, channels) {
+  const frames = checkFrames(frameCount);
+  const objects = /* @__PURE__ */ new Map();
+  for (const track of timeline.tracks) {
+    if (track.target !== "camera" && !isDome(track.target) && !isScene(track.target))
+      objects.set(idOf(track.target), track.target);
+  }
+  const cameraMoves = channels.some(
+    (c) => c.target.type === "camera" && c.property === "quaternion"
+  );
+  if (!objects.size && !cameraMoves) return [];
+  const perObject = new Map(
+    [...objects.keys()].map((id) => [id, []])
+  );
+  const cameraMatrices = [];
+  const matrix = new Matrix4();
+  const position = new Vector3();
+  const quaternion = new Quaternion();
+  const unit = new Vector3(1, 1, 1);
+  const was = timeline.time;
+  try {
+    for (const frame of frames) {
+      const time = frame / fps;
+      if (objects.size) {
+        timeline.seek(time);
+        for (const [id, object] of objects) {
+          object.updateWorldMatrix(true, false);
+          perObject.get(id).push(...object.matrixWorld.elements);
+        }
+      }
+      if (cameraMoves) {
+        const pose = timeline.cameraPoseAt(time);
+        if (pose) {
+          matrix.compose(
+            position.set(...pose.position),
+            quaternion.set(...pose.quaternion),
+            unit
+          );
+          cameraMatrices.push(...matrix.elements);
+        }
+      }
+    }
+  } finally {
+    if (objects.size) timeline.seek(was);
+  }
+  const checks = [];
+  for (const [objectId, matrices] of perObject)
+    checks.push({ target: { type: "object", objectId }, frames, matrices });
+  if (cameraMatrices.length === frames.length * 16)
+    checks.push({
+      target: { type: "camera" },
+      frames,
+      matrices: cameraMatrices
+    });
+  return checks;
+}
+function cameraChannels(timeline, fps, frameCount) {
+  const tracks = timeline.tracks.filter((track) => track.target === "camera");
+  const moves = tracks.some(
+    (track) => track.property === "position" || track.property === "lookAt"
+  );
+  const fovTrack = tracks.find((track) => track.property === "fov");
+  const channels = [];
+  if (!moves && !fovTrack) return channels;
+  if (moves) {
+    const positions = [];
+    const quaternions = [];
+    for (let frame = 0; frame < frameCount; frame++) {
+      const pose = timeline.cameraPoseAt(frame / fps);
+      if (!pose) break;
+      positions.push(...pose.position);
+      quaternions.push(...pose.quaternion);
+    }
+    const animatesPosition = tracks.some(
+      (track) => track.property === "position"
+    );
+    if (animatesPosition) {
+      channels.push({
+        target: { type: "camera" },
+        property: "position",
+        size: 3,
+        values: positions
+      });
+    }
+    channels.push({
+      target: { type: "camera" },
+      property: "quaternion",
+      size: 4,
+      values: quaternions
+    });
+  }
+  if (fovTrack) {
+    channels.push({
+      target: { type: "camera" },
+      property: "fov",
+      size: 1,
+      values: sample(timeline, fovTrack, fps, frameCount, 1)
+    });
+  }
+  return channels;
+}
+function objectChannels(timeline, fps, frameCount, scene) {
+  const channels = [];
+  for (const track of timeline.tracks) {
+    if (track.target === "camera") continue;
+    const object = track.target;
+    if (isAmbient(object) || isScene(object)) continue;
+    requireInScene(object, scene, track.property);
+    const definition = propertyDefinition(object, track.property);
+    const property = definition?.channel ?? track.property;
+    const size = ANIMATION_CHANNEL_SIZES[property];
+    if (size === void 0) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `"${property}" has no channel in this protocol version.`,
+        why: "The SDK can author it but the wire format cannot carry it, so the renderer would never see it.",
+        fix: "This is a bug in the SDK. Please report it to hello@bakery3.com with the property name."
+      });
+    }
+    const values = track.property === "rotation" ? sampleAsQuaternion(timeline, track, fps, frameCount) : sample(timeline, track, fps, frameCount, size);
+    channels.push({
+      target: { type: "object", objectId: idOf(object) },
+      property,
+      size,
+      values
+    });
+  }
+  return channels;
+}
+function environmentChannels(timeline, fps, frameCount, scene) {
+  const channels = [];
+  const environment = { type: "environment" };
+  for (const track of timeline.tracks) {
+    if (track.target === "camera" || !isScene(track.target)) continue;
+    requireInScene(track.target, scene, track.property);
+    const property = track.property === "environmentIntensity" ? "intensity" : "rotation";
+    const size = ENVIRONMENT_CHANNEL_SIZES[property];
+    channels.push({
+      target: environment,
+      property,
+      size,
+      values: sample(timeline, track, fps, frameCount, size)
+    });
+  }
+  const ambient = timeline.tracks.filter(
+    (track) => track.target !== "camera" && isAmbient(track.target)
+  );
+  if (!ambient.length) return channels;
+  for (const track of ambient)
+    requireInScene(track.target, scene, track.property);
+  const lights = ambientLightsIn(scene ?? rootOf(ambient[0].target));
+  const intensities = [];
+  const colors = [];
+  for (let frame = 0; frame < frameCount; frame++) {
+    const terms = lights.map((light) => {
+      const term = ambientTermOf(light);
+      for (const track of ambient) {
+        if (track.target !== light) continue;
+        const value = timeline.valueAt(track, frame / fps);
+        if (!value) continue;
+        if (track.property === "intensity") term.intensity = value[0];
+        else term.color = [value[0], value[1], value[2]];
+      }
+      return term;
+    });
+    const sum = combineAmbient(terms) ?? { color: [1, 1, 1], intensity: 0 };
+    intensities.push(sum.intensity);
+    colors.push(...sum.color);
+  }
+  channels.push(
+    {
+      target: environment,
+      property: "ambientIntensity",
+      size: ENVIRONMENT_CHANNEL_SIZES.ambientIntensity,
+      values: intensities
+    },
+    {
+      target: environment,
+      property: "ambientColor",
+      size: ENVIRONMENT_CHANNEL_SIZES.ambientColor,
+      values: colors
+    }
+  );
+  return channels;
+}
+function isAmbient(object) {
+  return Boolean(
+    object.isAmbientLight
+  );
+}
+function isHemisphere(object) {
+  return Boolean(
+    object.isHemisphereLight
+  );
+}
+function isDome(object) {
+  return isAmbient(object) || isHemisphere(object);
+}
+function isScene(object) {
+  return Boolean(object.isScene);
+}
+function rootOf(object) {
+  let root = object;
+  while (root.parent) root = root.parent;
+  return root;
+}
+function sample(timeline, track, fps, frameCount, size) {
+  const values = [];
+  for (let frame = 0; frame < frameCount; frame++) {
+    const value = timeline.valueAt(track, frame / fps);
+    for (let i = 0; i < size; i++) values.push(value?.[i] ?? 0);
+  }
+  return values;
+}
+function sampleAsQuaternion(timeline, track, fps, frameCount) {
+  const values = [];
+  for (let frame = 0; frame < frameCount; frame++) {
+    const euler = timeline.valueAt(track, frame / fps) ?? [0, 0, 0];
+    values.push(...eulerToQuaternion(euler));
+  }
+  return values;
+}
+function unexportableReason(object, property) {
+  const name = () => object.name || object.type;
+  for (let node = object; node; node = node.parent) {
+    if (!excludedItself(node)) continue;
+    const where = node === object ? `"${name()}"` : `"${name()}" (inside "${node.name || node.type}")`;
+    const because = readExclusionKind(node);
+    return {
+      code: "InvalidRequest",
+      message: `The timeline animates "${property}" on ${where}, which never reaches a render: ${because}.`,
+      why: "Excluded objects are detached from the GLB before export, so this channel would arrive at the renderer with an id that matches nothing.",
+      fix: because === EXCLUDED_BY_USERDATA ? "Remove userData.bakery3.exclude from it, or remove the track with timeline.removeTrack()." : "Animate the object you meant instead: helpers and gizmos never render.",
+      docs: "https://bakery3.com/docs/animation"
+    };
+  }
+  const domeProperties = isAmbient(object) ? AMBIENT_PROPERTIES : isHemisphere(object) ? HEMISPHERE_CHANNEL_PROPERTIES : void 0;
+  if (domeProperties && !domeProperties.includes(property)) {
+    const kind = isAmbient(object) ? "an AmbientLight" : "a HemisphereLight";
+    return {
+      code: "InvalidRequest",
+      message: `The timeline animates "${property}" on "${name()}", ${kind}, which has no "${property}" in a render.`,
+      why: isHemisphere(object) ? "A hemisphere light is a sky above and a ground below, split on its up axis. The renderer builds it into the world, where it has nothing to move, and turning its axis over a clip is not something it reproduces." : "An ambient light is the same light from every direction, so it has nothing to move or turn.",
+      fix: `Animate ${domeProperties.join(", ")} on it instead.`,
+      docs: "https://bakery3.com/docs/animation"
+    };
+  }
+  return null;
+}
+var AMBIENT_PROPERTIES = ["intensity", "color"];
+var EXCLUDED_BY_USERDATA = "it is excluded with userData.bakery3.exclude";
+function readExclusionKind(node) {
+  const data = node.userData?.bakery3;
+  if (data?.exclude) return EXCLUDED_BY_USERDATA;
+  if (node.type === "TransformControls")
+    return "it is part of a TransformControls gizmo";
+  if (node.userData?.bakery3Preset?.roomPreset) {
+    return "it is part of a room preset's stand-in, which the renderer rebuilds rather than imports";
+  }
+  return `${node.type} is debug furniture the exporter always skips`;
+}
+function requireInScene(object, scene, property) {
+  const reason = unexportableReason(object, property);
+  if (reason) throw new Bakery3Error(reason);
+  if (object.isLight && !object.visible) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `The timeline animates "${property}" on "${object.name || object.type}", a light that is currently invisible.`,
+      why: "Invisible lights are left out of the manifest, so this channel would arrive with an id that matches nothing.",
+      fix: "Make the light visible before rendering, or remove the track.",
+      docs: "https://bakery3.com/docs/animation"
+    });
+  }
+  if (!scene) return;
+  let found = false;
+  scene.traverse((candidate) => {
+    if (candidate === object) found = true;
+  });
+  if (found) return;
+  throw new Bakery3Error({
+    code: "InvalidRequest",
+    message: `The timeline animates "${property}" on "${object.name || object.type}", which is not in the scene being rendered.`,
+    why: "Only objects the exporter walks reach the renderer, so this channel would arrive with an id that matches nothing and be silently ignored.",
+    fix: "Add the object to the scene before rendering, or remove the track with timeline.removeTrack().",
+    docs: "https://bakery3.com/docs/animation"
+  });
+}
+
+// src/timeline/timeline.ts
+var PUSH_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "object",
+  "at",
+  "duration",
+  "easing",
+  "orbitY",
+  "orbitX",
+  "dolly",
+  "lookAt"
+]);
+var contexts = /* @__PURE__ */ new WeakMap();
+function bindTimelineContext(timeline, context) {
+  contexts.set(timeline, context);
+  return timeline;
+}
+var Timeline = class _Timeline {
+  _duration;
+  _fps;
+  _time = 0;
+  _tracks = [];
+  _playing = false;
+  _raf = null;
+  _lastTick = 0;
+  _listeners = /* @__PURE__ */ new Map();
+  _center;
+  _nextId = 0;
+  /** Playback only. A bake is always exactly one pass of the duration, so
+   *  looping in the panel never changes what a video contains. */
+  loop;
+  _camera;
+  _scene;
+  /** The host's orbit-controls target, when it has one. */
+  controlsTarget;
+  constructor(options = {}) {
+    this._duration = options.duration ?? 5;
+    this._fps = options.fps ?? 30;
+    this._center = options.lookAt ?? null;
+    this.loop = options.loop ?? true;
+    if (options.camera) this.camera = options.camera;
+    if (options.scene) this.scene = options.scene;
+    if (options.controlsTarget) this.controlsTarget = options.controlsTarget;
+  }
+  /**
+   * What `seek()` drives and `captureCameraKeyframe()` reads. Settable after
+   * construction because an R3F camera is frequently swapped out from under
+   * the application. A timeline from `bakery3.timeline()` that was given no
+   * camera reads the client's attached one each time it needs it.
+   */
+  get camera() {
+    return this._camera ?? contexts.get(this)?.()?.camera ?? void 0;
+  }
+  set camera(camera) {
+    this._camera = camera;
+  }
+  /** Used to find the orbit center, and to check at bake time that every
+   *  animated object is actually in what gets exported. Read from the
+   *  client's attachment, like `camera`, when it was not given. */
+  get scene() {
+    return this._scene ?? contexts.get(this)?.()?.scene ?? void 0;
+  }
+  set scene(scene) {
+    this._scene = scene;
+  }
+  // -------------------------------------------------------------------------
+  // Shape
+  // -------------------------------------------------------------------------
+  get duration() {
+    return this._duration;
+  }
+  /**
+   * Setting this moves the end, not the keyframes.
+   *
+   * Existing keyframes keep their absolute times, because the common reason to
+   * change the duration is "I need two more seconds at the end", and silently
+   * rescaling every ease you already tuned would be the opposite of that.
+   * `scaleToFit()` is the other intent, spelled out.
+   */
+  set duration(seconds) {
+    this._duration = Math.max(1 / this._fps, seconds);
+    if (this._time > this._duration) this.seek(this._duration);
+    this.emit("change");
+  }
+  get fps() {
+    return this._fps;
+  }
+  set fps(value) {
+    this._fps = Math.max(1, Math.round(value));
+    this.emit("change");
+  }
+  get time() {
+    return this._time;
+  }
+  get playing() {
+    return this._playing;
+  }
+  get tracks() {
+    return this._tracks;
+  }
+  /** Frames a bake at the current settings will produce. */
+  get frameCount() {
+    return Math.max(1, Math.round(this._duration * this._fps));
+  }
+  /** Proportionally rescale every keyframe into a new duration. */
+  scaleToFit(seconds) {
+    const factor = seconds / this._duration;
+    for (const track of this._tracks) {
+      for (const keyframe of track.keyframes) keyframe.time *= factor;
+    }
+    this._duration = seconds;
+    this.emit("change");
+    return this;
+  }
+  /**
+   * The point orbits turn around.
+   *
+   * Resolved lazily so a timeline created before the model finished loading
+   * still centers on it. `createTimeline()` at mount is the normal case, and
+   * an empty scene's bounding box is the origin, which would be wrong for
+   * every model that is not at the origin.
+   */
+  get center() {
+    if (this._center) return this._center;
+    if (this.scene) {
+      const box = boundingCenter(this.scene);
+      if (box) return box;
+    }
+    return [0, 0, 0];
+  }
+  set center(value) {
+    this._center = value;
+    this.emit("change");
+  }
+  // -------------------------------------------------------------------------
+  // Authoring
+  // -------------------------------------------------------------------------
+  /**
+   * Tween to a value from wherever the target is at `at`.
+   *
+   * "Wherever it is at `at`" means the timeline's own value if something else
+   * already animates that property, and the live object's value if not, so
+   * chaining two `.to()` calls on one property does what it looks like.
+   */
+  to(target, props, options = {}) {
+    const { at, end } = this.span(options);
+    for (const [property, raw] of Object.entries(props)) {
+      const track = this.track(target, property);
+      const value = normalize3(raw, track.size, property);
+      this.anchor(track, at);
+      this.insert(track, {
+        time: end,
+        value,
+        ...options.easing ? { easing: options.easing } : {}
+      });
+    }
+    this.emit("change");
+    return this;
+  }
+  /** Both ends stated. Nothing is read off the live object. */
+  fromTo(target, from, to, options = {}) {
+    const { at, end } = this.span(options);
+    for (const [property, raw] of Object.entries(to)) {
+      const track = this.track(target, property);
+      const start = from[property];
+      if (start !== void 0) {
+        this.insert(track, {
+          time: at,
+          value: normalize3(start, track.size, property)
+        });
+      } else {
+        this.anchor(track, at);
+      }
+      this.insert(track, {
+        time: end,
+        value: normalize3(raw, track.size, property),
+        ...options.easing ? { easing: options.easing } : {}
+      });
+    }
+    this.emit("change");
+    return this;
+  }
+  /**
+   * Swing the camera around what it is looking at.
+   *
+   * The lookAt point is pinned for the whole segment. That is the difference
+   * between an orbit and a camera drifting sideways past the product, and it
+   * is why this writes a `lookAt` track as well as a `position` one.
+   */
+  orbit(camera, options = {}) {
+    const target = camera === "camera" || camera === this.camera ? "camera" : camera;
+    if (target !== "camera") {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "orbit() only drives the camera.",
+        why: "An orbit is defined by a camera and the point it is aimed at; an ordinary object has no lookAt to hold.",
+        fix: "Pass 'camera' (or the timeline's camera), or animate the object's position with to()."
+      });
+    }
+    const { at, end } = this.span(options);
+    const center = resolveCenter(options.lookAt, this.center);
+    const positions = this.track("camera", "position");
+    const looks = this.track("camera", "lookAt");
+    const start = this.valueAt(positions, at) ?? this.live("camera", "position") ?? [
+      center[0],
+      center[1],
+      center[2] + 1
+    ];
+    const from = toSpherical(start, center);
+    const radius = options.radius !== void 0 ? options.radius : from.radius + (options.dolly ?? 0);
+    const to = {
+      radius,
+      yaw: from.yaw + degrees(options.yaw ?? 0),
+      pitch: from.pitch + degrees(options.pitch ?? 0)
+    };
+    if (!positions.keyframes.some((k) => Math.abs(k.time - at) < 1e-6))
+      this.insert(positions, { time: at, value: [...start] });
+    this.insert(positions, {
+      time: end,
+      value: [...fromSpherical(to, center)],
+      path: "orbit",
+      orbit: { center, ...to },
+      ...options.easing ? { easing: options.easing } : {}
+    });
+    this.insert(looks, { time: at, value: [...center] });
+    this.insert(looks, { time: end, value: [...center] });
+    this.emit("change");
+    return this;
+  }
+  /**
+   * One-call shorthand:
+   *
+   *     tl.push({ object: 'camera', orbitY: +15 });
+   *
+   * The camera starts where it is now and ends fifteen degrees round its
+   * current lookAt, holding that lookAt, over the whole timeline. Any other
+   * key is treated as if it had been passed to `.to()`.
+   */
+  push(spec) {
+    const { object, ...rest } = spec;
+    const options = {
+      ...rest.at !== void 0 ? { at: rest.at } : {},
+      ...rest.duration !== void 0 ? { duration: rest.duration } : {},
+      ...rest.easing !== void 0 ? { easing: rest.easing } : {}
+    };
+    const orbits = rest.orbitY !== void 0 || rest.orbitX !== void 0 || rest.dolly !== void 0;
+    if (orbits) {
+      this.orbit(object, {
+        ...options,
+        ...rest.orbitY !== void 0 ? { yaw: rest.orbitY } : {},
+        ...rest.orbitX !== void 0 ? { pitch: rest.orbitX } : {},
+        ...rest.dolly !== void 0 ? { dolly: rest.dolly } : {},
+        ...rest.lookAt !== void 0 ? { lookAt: rest.lookAt } : {}
+      });
+    }
+    const props = {};
+    for (const [key, value] of Object.entries(rest)) {
+      if (PUSH_OPTION_KEYS.has(key)) continue;
+      props[key] = value;
+    }
+    if (Object.keys(props).length) this.to(object, props, options);
+    else if (!orbits) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "push() was given nothing to animate.",
+        why: "Every key was an option (at, duration, easing, \u2026); no property and no orbit remained.",
+        fix: "Add a property: push({ object: 'camera', orbitY: 15 }) or push({ object: mesh, position: [0, 1, 0] })."
+      });
+    }
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Keyframe editing (what the panel drives)
+  // -------------------------------------------------------------------------
+  /**
+   * Save a property where it is right now.
+   *
+   * The After Effects flow: put the playhead somewhere, pose the scene, press
+   * the button. Both arguments default to exactly that: the playhead, and the
+   * live value.
+   */
+  keyframe(target, property, time = this._time, value) {
+    const track = this.track(target, property);
+    const resolved = value !== void 0 ? normalize3(value, track.size, property) : this.live(target, property) ?? this.valueAt(track, time);
+    if (!resolved) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `Nothing to read for "${property}" on ${track.label}.`,
+        why: "The property is not present on that object (a mesh has no intensity, a light has no roughness) and no value was passed.",
+        fix: `Pass a value explicitly, or animate a property the object has.`
+      });
+    }
+    const keyframe = this.insert(track, { time, value: resolved });
+    this.emit("change");
+    return keyframe;
+  }
+  /**
+   * The camera, as the developer framed it.
+   *
+   * Position and the point it is aimed at, because a camera keyframe that
+   * records only position leaves the render free to aim it somewhere else.
+   * The aim comes from the host's orbit controls when there are any (that is
+   * the point you were dragging around), and is otherwise projected along the
+   * camera's own forward axis, never assumed to be the origin.
+   */
+  captureCameraKeyframe(time = this._time, lookAt) {
+    const camera = this.requireCamera("captureCameraKeyframe");
+    camera.updateMatrixWorld();
+    const elements = camera.matrixWorld.elements;
+    const position = [elements[12], elements[13], elements[14]];
+    const target = lookAt ?? this.controlsTarget?.() ?? readCameraLookAt(camera, this.center);
+    this.insert(this.track("camera", "position"), {
+      time,
+      value: [...position]
+    });
+    this.insert(this.track("camera", "lookAt"), { time, value: [...target] });
+    this.emit("change");
+  }
+  removeKeyframe(trackId, index) {
+    const track = this._tracks.find((t) => t.id === trackId);
+    if (!track) return;
+    track.keyframes.splice(index, 1);
+    if (!track.keyframes.length) this.removeTrack(trackId);
+    this.emit("change");
+  }
+  /** Retime one keyframe, clamped into the timeline. A keyframe dragged past
+   *  the end would still be baked, at a frame nobody renders, so it is pinned
+   *  to the duration rather than allowed to leave the shot. */
+  moveKeyframe(trackId, index, time) {
+    const track = this._tracks.find((t) => t.id === trackId);
+    const keyframe = track?.keyframes[index];
+    if (!track || !keyframe) return;
+    keyframe.time = Math.max(0, Math.min(this._duration, time));
+    track.keyframes.sort((a, b) => a.time - b.time);
+    this.emit("change");
+  }
+  /** Re-curve the segment ending at this keyframe, the same convention `.to()`
+   *  writes, so the panel's dropdown and the authoring API mean the same thing
+   *  by "the ease on this diamond". */
+  setEasing(trackId, index, easing) {
+    const keyframe = this._tracks.find((t) => t.id === trackId)?.keyframes[index];
+    if (!keyframe) return;
+    keyframe.easing = easing;
+    this.emit("change");
+  }
+  /** Drop a lane and everything on it. The live object keeps whatever value it
+   *  last had: removing a track stops driving a property, it does not restore
+   *  what the property was before the timeline touched it. */
+  removeTrack(trackId) {
+    this._tracks = this._tracks.filter((track) => track.id !== trackId);
+    this.emit("change");
+  }
+  /**
+   * Re-attach tracks to the scene as it is now, and report what could not be.
+   *
+   * An application that rebuilds part of its graph (a configurator swapping a
+   * variant, R3F remounting a subtree) leaves tracks pointing at Object3Ds
+   * that are no longer in the scene, even though an object that is for every
+   * purpose "the same one" is standing right there. Rather than fail at
+   * export, look for that object: first by the identity you pinned
+   * (`userData.bakery3Id`, which is exactly what survives a rebuild), then by
+   * an unambiguous name match.
+   *
+   * Nothing is dropped silently. Every track that could not be healed is
+   * returned, so the caller can say what happened; that is the difference
+   * between repairing a timeline and quietly losing a motion you authored.
+   */
+  reconcile(scene) {
+    const healed = [];
+    const stale = [];
+    const live = /* @__PURE__ */ new Set();
+    const byId = /* @__PURE__ */ new Map();
+    const byName = /* @__PURE__ */ new Map();
+    scene.traverse((object) => {
+      live.add(object);
+      const declared = object.userData?.bakery3Id;
+      if (typeof declared === "string" && declared) byId.set(declared, object);
+      if (object.name) {
+        const bucket = byName.get(object.name);
+        if (bucket) bucket.push(object);
+        else byName.set(object.name, [object]);
+      }
+    });
+    for (const track of this._tracks) {
+      if (track.target === "camera" || live.has(track.target)) continue;
+      const previous = track.target;
+      const declared = previous.userData?.bakery3Id;
+      const replacement = (typeof declared === "string" ? byId.get(declared) : void 0) ?? // Only an unambiguous name match: two meshes called 'seat' and a
+      // coin flip between them is worse than saying the track is stale.
+      (previous.name && byName.get(previous.name)?.length === 1 ? byName.get(previous.name)[0] : void 0);
+      const entry = {
+        trackId: track.id,
+        property: track.property,
+        label: track.label
+      };
+      if (!replacement) {
+        stale.push({ ...entry, reason: "it is no longer in the scene" });
+        continue;
+      }
+      const blocked = unexportableReason(replacement, track.property);
+      if (blocked) {
+        stale.push({ ...entry, reason: blocked.message });
+        continue;
+      }
+      if (!propertyDefinition(replacement, track.property)) {
+        stale.push({
+          ...entry,
+          reason: `the object that replaced it has no "${track.property}"`
+        });
+        continue;
+      }
+      track.target = replacement;
+      track.label = labelFor(replacement);
+      healed.push(entry);
+    }
+    if (healed.length) this.emit("change");
+    return { healed, stale };
+  }
+  /** Find or create a lane. Public because the panel's "add track" picker
+   *  needs to create one without also writing a keyframe. */
+  track(target, property) {
+    const resolved = this.normalizeTarget(target);
+    const existing = this._tracks.find(
+      (track2) => track2.target === resolved && track2.property === property
+    );
+    if (existing) return existing;
+    if (resolved !== "camera") {
+      const reason = unexportableReason(resolved, property);
+      if (reason) throw new Bakery3Error(reason);
+    }
+    const definition = propertyDefinition(resolved, property);
+    if (!definition) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `"${property}" is not an animatable property${resolved === "camera" ? " of the camera" : ""}.`,
+        why: "Only properties the renderer can reproduce can be animated; animating one it cannot would produce a video that silently ignores it.",
+        fix: `Animate one of: ${Object.keys(
+          resolved === "camera" ? CAMERA_PROPERTIES : OBJECT_PROPERTIES
+        ).join(", ")}.`,
+        docs: "https://bakery3.com/docs/animation"
+      });
+    }
+    if (resolved !== "camera" && definition.appliesTo && !definition.appliesTo(resolved)) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `"${labelFor(resolved)}" has no "${property}" to animate.`,
+        why: property === "target" ? "Only a DirectionalLight or a SpotLight aims at a target." : `"${property}" exists on some kinds of object, and this is not one of them.`,
+        fix: property === "target" ? "Animate the light's position, or animate a DirectionalLight or SpotLight's target." : "Animate the property on an object that has it.",
+        docs: "https://bakery3.com/docs/animation"
+      });
+    }
+    const track = {
+      id: `t${this._nextId++}`,
+      target: resolved,
+      property,
+      size: definition.size,
+      label: labelFor(resolved),
+      keyframes: []
+    };
+    this._tracks.push(track);
+    return track;
+  }
+  // -------------------------------------------------------------------------
+  // Playback
+  // -------------------------------------------------------------------------
+  /**
+   * Evaluate every track and drive the live scene.
+   *
+   * The same evaluator `bake()` samples, which is the whole design: what you
+   * scrub to and what the renderer traces cannot drift apart, because there is
+   * only one of them.
+   */
+  seek(time) {
+    this._time = Math.max(0, Math.min(this._duration, time));
+    this.apply(this._time);
+    this.emit("time", this._time);
+    return this;
+  }
+  play() {
+    if (this._playing) return this;
+    this._playing = true;
+    this._lastTick = now();
+    this.emit("play");
+    this.tick();
+    return this;
+  }
+  pause() {
+    if (!this._playing) return this;
+    this._playing = false;
+    cancel(this._raf);
+    this._raf = null;
+    this.emit("pause");
+    return this;
+  }
+  /** Pause and rewind. */
+  stop() {
+    this.pause();
+    return this.seek(0);
+  }
+  /** Stop the clock and forget every listener. The scene is left exactly where
+   *  the playhead left it: a timeline being torn down should not also move
+   *  your camera back. */
+  dispose() {
+    this.pause();
+    this._listeners.clear();
+  }
+  tick() {
+    if (!this._playing) return;
+    const stamp = now();
+    const delta = (stamp - this._lastTick) / 1e3;
+    this._lastTick = stamp;
+    let next = this._time + delta;
+    if (next >= this._duration) {
+      if (this.loop) next = next % this._duration;
+      else {
+        this.seek(this._duration);
+        this.pause();
+        return;
+      }
+    }
+    this.seek(next);
+    this._raf = schedule(() => this.tick());
+  }
+  // -------------------------------------------------------------------------
+  // Evaluation
+  // -------------------------------------------------------------------------
+  /** The value of one track at a time, without touching the scene. Exposed
+   *  because the bake samples it. */
+  valueAt(track, time) {
+    const keys = track.keyframes;
+    if (!keys.length) return void 0;
+    if (keys.length === 1 || time <= keys[0].time) return [...keys[0].value];
+    const last = keys[keys.length - 1];
+    if (time >= last.time) return [...last.value];
+    let index = 0;
+    while (index < keys.length - 1 && keys[index + 1].time <= time) index++;
+    const a = keys[index];
+    const b = keys[index + 1];
+    const span = b.time - a.time;
+    const u = span <= 0 ? 1 : (time - a.time) / span;
+    const t = ease(b.easing, u);
+    if (b.path === "orbit" && b.orbit) {
+      const center = b.orbit.center;
+      const from = a.orbit ?? toSpherical(a.value, center);
+      return orbitAt(from, b.orbit, center, t);
+    }
+    if (track.size === 4 && track.property === "quaternion") {
+      return slerp(a.value, b.value, t);
+    }
+    return a.value.map(
+      (value, i) => value + ((b.value[i] ?? value) - value) * t
+    );
+  }
+  /** What the timeline says everything is at `time`, for a panel readout or a
+   *  test: the same numbers `seek()` applies. */
+  sample(time) {
+    const out = [];
+    for (const track of this._tracks) {
+      const value = this.valueAt(track, time);
+      if (value) out.push({ track, value });
+    }
+    return out;
+  }
+  /** The camera pose at a time: position and the rotation the wire format
+   *  carries. Shared by `seek()` and `bake()` so the preview cannot aim
+   *  somewhere the render does not. */
+  cameraPoseAt(time) {
+    const positions = this.find("camera", "position");
+    const looks = this.find("camera", "lookAt");
+    if (!positions && !looks) return void 0;
+    const position = (positions ? this.valueAt(positions, time) : void 0) ?? this.live("camera", "position") ?? [0, 0, 1];
+    const lookAt = (looks ? this.valueAt(looks, time) : void 0) ?? [
+      ...this.center
+    ];
+    return {
+      position,
+      lookAt,
+      quaternion: lookAtQuaternion(position, lookAt)
+    };
+  }
+  apply(time) {
+    const pose = this.cameraPoseAt(time);
+    const camera = pose ? this.cameraOrThrow("seek()") : void 0;
+    if (pose && camera) {
+      camera.position.set(pose.position[0], pose.position[1], pose.position[2]);
+      const lookable = camera;
+      lookable.lookAt?.(pose.lookAt[0], pose.lookAt[1], pose.lookAt[2]);
+      camera.updateMatrixWorld();
+    }
+    for (const track of this._tracks) {
+      if (track.target === "camera" && (track.property === "position" || track.property === "lookAt")) {
+        continue;
+      }
+      const value = this.valueAt(track, time);
+      if (!value) continue;
+      const definition = propertyDefinition(track.target, track.property);
+      const object = track.target === "camera" ? this.camera : track.target;
+      if (definition && object) definition.write(object, value);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Baking and serialization
+  // -------------------------------------------------------------------------
+  /**
+   * Every track, sampled at every output frame. The wire format is flat
+   * samples, so the renderer needs no evaluator of its own.
+   */
+  bake(options = {}) {
+    if (this._tracks.some((track) => track.target === "camera"))
+      this.cameraOrThrow("bake()");
+    return bakeTimeline(this, options);
+  }
+  /** The timeline as a storable document. See `TimelineJSON`, and `fromJSON`
+   *  for how stored ids find their live objects again. */
+  toJSON() {
+    return {
+      version: 1,
+      duration: this._duration,
+      fps: this._fps,
+      center: this.center,
+      tracks: this._tracks.map((track) => ({
+        target: track.target === "camera" ? { type: "camera" } : { type: "object", objectId: idOf(track.target) },
+        property: track.property,
+        label: track.label,
+        keyframes: track.keyframes.map((keyframe) => ({ ...keyframe }))
+      }))
+    };
+  }
+  /**
+   * Rebuild a timeline against a live scene.
+   *
+   * `resolve` maps a stored object id back to a live object. An id that does
+   * not resolve is refused rather than skipped: a track that silently
+   * disappears is a video missing a motion you authored, and you would find
+   * out by watching the finished render.
+   */
+  static fromJSON(json, context = {}) {
+    const timeline = new _Timeline({
+      duration: json.duration,
+      fps: json.fps,
+      ...json.center ? { lookAt: json.center } : {},
+      ...context.camera ? { camera: context.camera } : {},
+      ...context.scene ? { scene: context.scene } : {}
+    });
+    for (const stored of json.tracks) {
+      let target;
+      if (stored.target.type === "camera") {
+        target = "camera";
+      } else {
+        const object = context.resolve?.(stored.target.objectId) ?? findByUuid(context.scene, stored.target.objectId);
+        if (!object) {
+          throw new Bakery3Error({
+            code: "InvalidRequest",
+            message: `Timeline track "${stored.property}" refers to an object that is not in this scene.`,
+            why: `Object id ${stored.target.objectId} did not resolve. three assigns a new uuid on every reload, so a timeline saved against one session does not match the next one by default.`,
+            fix: "Pass { resolve } to Timeline.fromJSON to map stored ids onto your own stable names.",
+            docs: "https://bakery3.com/docs/animation"
+          });
+        }
+        target = object;
+      }
+      const track = timeline.track(target, stored.property);
+      if (stored.label) track.label = stored.label;
+      track.keyframes = stored.keyframes.map((keyframe) => ({ ...keyframe })).sort((a, b) => a.time - b.time);
+    }
+    return timeline;
+  }
+  // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  /** Subscribe. Returns the unsubscribe, so a panel's teardown is one call and
+   *  a forgotten listener cannot keep a disposed scene alive. */
+  on(event, listener) {
+    const set = this._listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this._listeners.set(event, set);
+    return () => set.delete(listener);
+  }
+  emit(event, payload) {
+    for (const listener of this._listeners.get(event) ?? []) listener(payload);
+    if (event === "change") {
+      for (const listener of this._listeners.get("time") ?? [])
+        listener(this._time);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  /** The live value of a property, read through the shared property table. */
+  live(target, property) {
+    const object = target === "camera" ? this.cameraOrThrow(`Reading the camera's ${property}`) : target;
+    if (!object) return void 0;
+    return propertyDefinition(target, property)?.read(object);
+  }
+  find(target, property) {
+    const resolved = this.normalizeTarget(target);
+    return this._tracks.find(
+      (t) => t.target === resolved && t.property === property
+    );
+  }
+  normalizeTarget(target) {
+    return target === "camera" || this.camera && target === this.camera ? "camera" : target;
+  }
+  span(options) {
+    const at = Math.max(0, options.at ?? 0);
+    const duration = options.duration ?? Math.max(0, this._duration - at);
+    return { at, end: at + duration };
+  }
+  /** Make sure a segment has something to start from at `at`. */
+  anchor(track, at) {
+    if (track.keyframes.some((keyframe) => Math.abs(keyframe.time - at) < 1e-6))
+      return;
+    const value = this.valueAt(track, at) ?? this.live(track.target, track.property);
+    if (value) this.insert(track, { time: at, value });
+  }
+  insert(track, keyframe) {
+    const index = track.keyframes.findIndex(
+      (existing) => Math.abs(existing.time - keyframe.time) < 1e-6
+    );
+    if (index >= 0) {
+      track.keyframes[index] = keyframe;
+    } else {
+      track.keyframes.push(keyframe);
+      track.keyframes.sort((a, b) => a.time - b.time);
+    }
+    return keyframe;
+  }
+  requireCamera(what) {
+    const camera = this.camera;
+    if (!camera) throw noCamera(`${what}()`, contexts.has(this));
+    return camera;
+  }
+  /**
+   * The camera, when one is needed. A client's timeline that has none by then
+   * refuses, because the move it was asked for would otherwise be authored
+   * from a made-up pose, or silently drive nothing. A standalone timeline
+   * with no camera is a document that can still be read and sampled.
+   */
+  cameraOrThrow(what) {
+    const camera = this.camera;
+    if (!camera && contexts.has(this)) throw noCamera(what, true);
+    return camera;
+  }
+};
+function noCamera(what, bound) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: bound ? "This timeline has no camera. Pass { scene, camera } to timeline(), or call bakery3.attach() first." : "This timeline has no camera. Pass { camera } to createTimeline(), or use bakery3.timeline() after bakery3.attach().",
+    why: `${what} needs the camera, and the timeline was given none${bound ? " and none is attached" : ""}.`,
+    fix: bound ? "Pass { scene, camera } to timeline(), or call bakery3.attach({ scene, camera, renderer }) before you author or play a camera move." : "Pass { camera } to createTimeline(), or set timeline.camera.",
+    docs: "https://bakery3.com/docs/animation#move-the-camera"
+  });
+}
+function createTimeline(options = {}) {
+  return new Timeline(options);
+}
+function normalize3(value, size, property) {
+  const flat = flatten(value, size, property);
+  if (flat && flat.length === size && flat.every((n) => Number.isFinite(n)))
+    return flat;
+  throw new Bakery3Error({
+    code: "InvalidRequest",
+    message: flat ? `"${property}" takes ${size === 1 ? "one number" : `${size} numbers`}, and got ${describe(value)}.` : `Could not read a value for "${property}".`,
+    why: "Expected a number, an array, a hex color, or a three Vector3/Color/Euler, of the size the property has.",
+    fix: size === 1 ? `Pass a single number for "${property}".` : `Pass [x, y, z] or a Vector3 for "${property}", or "#ff2d95" for a color. A bare number is read as a uniform value for scale only.`
+  });
+}
+function flatten(value, size, property) {
+  if (typeof value === "number") {
+    return property === "scale" ? new Array(size).fill(value) : [value];
+  }
+  if (typeof value === "string") return hexToLinear(value);
+  if (Array.isArray(value)) return [...value];
+  if ("x" in value) return [value.x, value.y, value.z];
+  if ("r" in value) return [value.r, value.g, value.b];
+  return null;
+}
+function describe(value) {
+  if (typeof value === "number") return `the number ${value}`;
+  if (typeof value === "string") return `"${value}"`;
+  if (Array.isArray(value)) return `an array of ${value.length}`;
+  return "x" in value ? "a vector" : "a color";
+}
+function resolveCenter(lookAt, fallback) {
+  if (!lookAt) return fallback;
+  if (Array.isArray(lookAt)) return [...lookAt];
+  lookAt.updateMatrixWorld();
+  const e = lookAt.matrixWorld.elements;
+  return [e[12], e[13], e[14]];
+}
+function degrees(value) {
+  return value * Math.PI / 180;
+}
+function slerp(a, b, t) {
+  let dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+  let end = [...b];
+  if (dot < 0) {
+    end = [-b[0], -b[1], -b[2], -b[3]];
+    dot = -dot;
+  }
+  if (dot > 0.9995) {
+    const out = a.map((value, i) => value + (end[i] - value) * t);
+    const length = Math.hypot(out[0], out[1], out[2], out[3]) || 1;
+    return out.map((value) => value / length);
+  }
+  const theta = Math.acos(dot);
+  const sin = Math.sin(theta);
+  const wa = Math.sin((1 - t) * theta) / sin;
+  const wb = Math.sin(t * theta) / sin;
+  return a.map((value, i) => value * wa + end[i] * wb);
+}
+function labelFor(target) {
+  if (target === "camera") return "camera";
+  return target.name || target.type || "object";
+}
+function findByUuid(scene, id) {
+  if (!scene) return void 0;
+  let found;
+  scene.traverse((object) => {
+    if (!found && (idOf(object) === id || object.uuid === id)) found = object;
+  });
+  return found;
+}
+function boundingCenter(scene) {
+  let min = null;
+  let max = null;
+  scene.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    object.updateMatrixWorld();
+    const e = object.matrixWorld.elements;
+    const point = [e[12], e[13], e[14]];
+    if (!min || !max) {
+      min = [...point];
+      max = [...point];
+      return;
+    }
+    for (let i = 0; i < 3; i++) {
+      min[i] = Math.min(min[i], point[i]);
+      max[i] = Math.max(max[i], point[i]);
+    }
+  });
+  if (!min || !max) return null;
+  const lo = min;
+  const hi = max;
+  return [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2];
+}
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function schedule(callback) {
+  if (typeof requestAnimationFrame === "function")
+    return requestAnimationFrame(callback);
+  return setTimeout(callback, 16);
+}
+function cancel(handle) {
+  if (handle === null) return;
+  if (typeof cancelAnimationFrame === "function" && typeof handle === "number") {
+    cancelAnimationFrame(handle);
+    return;
+  }
+  clearTimeout(handle);
+}
+
+// src/timeline/adapters.ts
+function timelineFromGsap(gsapTimeline, options) {
+  const source = gsapTimeline;
+  const duration = options.duration ?? numberFrom(source.duration);
+  if (!duration || !Number.isFinite(duration)) {
+    throw refusal(
+      "gsap",
+      "the timeline did not report a duration",
+      "Pass { duration }: an infinitely repeating gsap timeline has no length to bake."
+    );
+  }
+  const wasPaused = typeof source.paused === "function" ? source.paused() : true;
+  const before = typeof source.time === "function" ? source.time() : 0;
+  source.pause?.();
+  const seek = (time) => {
+    if (typeof source.seek === "function") source.seek(time, false);
+    else if (typeof source.time === "function") source.time(time, false);
+    else {
+      throw refusal(
+        "gsap",
+        "the object has neither seek() nor time()",
+        "Pass the gsap.timeline() itself rather than a wrapper around it."
+      );
+    }
+  };
+  try {
+    return record(seek, duration, options);
+  } finally {
+    seek(before);
+    if (!wasPaused) source.play?.();
+  }
+}
+function timelineFromTheatre(sequence, options) {
+  const source = sequence;
+  const duration = options.duration ?? (typeof source.length === "number" ? source.length : 0);
+  if (!duration || !Number.isFinite(duration)) {
+    throw refusal(
+      "Theatre.js",
+      "the sequence did not report a length",
+      "Pass { duration }, or set the sequence length in the Theatre studio."
+    );
+  }
+  const before = typeof source.position === "number" ? source.position : 0;
+  source.pause?.();
+  const seek = (time) => {
+    source.position = time;
+  };
+  try {
+    return record(seek, duration, options);
+  } finally {
+    seek(before);
+  }
+}
+function record(seek, duration, options) {
+  const fps = Math.max(1, Math.round(options.fps ?? 30));
+  const frames = Math.max(1, Math.round(duration * fps));
+  const timeline = new Timeline({
+    duration,
+    fps,
+    ...options.camera ? { camera: options.camera } : {},
+    ...options.scene ? { scene: options.scene } : {}
+  });
+  const tracks = options.tracks.map((spec) => {
+    const track = timeline.track(spec.object, spec.property);
+    if (spec.label) track.label = spec.label;
+    return { spec, track };
+  });
+  for (let frame = 0; frame < frames; frame++) {
+    const time = frame / fps;
+    seek(time);
+    for (const { spec, track } of tracks) {
+      const value = readLive(timeline, spec);
+      if (!value) continue;
+      track.keyframes.push({ time, value });
+    }
+  }
+  for (const { track } of tracks)
+    track.keyframes.sort((a, b) => a.time - b.time);
+  timeline.seek(0);
+  return timeline;
+}
+function readLive(timeline, spec) {
+  if (spec.object === "camera" && spec.property === "lookAt") {
+    return timeline.camera ? readCameraLookAt(timeline.camera, timeline.center) : void 0;
+  }
+  const value = timeline.live(spec.object, spec.property);
+  return value ? [...value] : void 0;
+}
+function numberFrom(value) {
+  if (typeof value === "function") return value();
+  return typeof value === "number" ? value : 0;
+}
+function refusal(library, why, fix) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `Could not sample the ${library} timeline.`,
+    why,
+    fix,
+    docs: "https://bakery3.com/docs/animation#adapters"
+  });
+}
+
+// src/shader/extract.ts
+var DOCS = "https://bakery3.com/docs";
+var OPERATORS = {
+  "+": "add",
+  "-": "sub",
+  "*": "mul",
+  "/": "div",
+  "%": "mod",
+  "<": "less_than",
+  ">": "greater_than",
+  "<=": "less_equal",
+  ">=": "greater_equal",
+  "==": "equal",
+  "!=": "not_equal",
+  "&&": "and",
+  "||": "or"
+};
+var MATH_METHODS = {
+  radians: "radians",
+  degrees: "degrees",
+  exp: "exp",
+  exp2: "exp2",
+  log: "log",
+  log2: "log2",
+  sqrt: "sqrt",
+  inversesqrt: "inverse_sqrt",
+  floor: "floor",
+  ceil: "ceil",
+  normalize: "normalize",
+  fract: "fract",
+  sin: "sin",
+  cos: "cos",
+  tan: "tan",
+  asin: "asin",
+  acos: "acos",
+  abs: "abs",
+  sign: "sign",
+  length: "length",
+  negate: "negate",
+  oneMinus: "one_minus",
+  round: "round",
+  reciprocal: "reciprocal",
+  trunc: "trunc",
+  min: "min",
+  max: "max",
+  step: "step",
+  reflect: "reflect",
+  distance: "distance",
+  dot: "dot",
+  cross: "cross",
+  pow: "pow",
+  mix: "mix",
+  clamp: "clamp",
+  refract: "refract",
+  smoothstep: "smoothstep",
+  faceforward: "faceforward",
+  saturate: "saturate"
+};
+var MATH_REFUSED = {
+  dFdx: "Screen-space derivatives do not exist in a path tracer: there is no screen-space neighbor to difference against.",
+  dFdy: "Screen-space derivatives do not exist in a path tracer: there is no screen-space neighbor to difference against.",
+  fwidth: "Screen-space derivatives do not exist in a path tracer: there is no screen-space neighbor to difference against."
+};
+var NAMED_BUILTINS = {
+  normalView: { op: "normal", params: { space: "view" } },
+  normalWorld: { op: "normal", params: { space: "world" } },
+  normalLocal: { op: "normal", params: { space: "local" } },
+  positionLocal: { op: "position", params: { space: "local" } },
+  positionWorld: { op: "position", params: { space: "world" } },
+  positionView: { op: "position", params: { space: "view" } },
+  positionViewDirection: { op: "view_direction" }
+};
+var NAMED_FUNCTIONS = {
+  mx_perlin_noise_float: { op: "mx_noise", inputCount: 1 },
+  mx_perlin_noise_vec3: {
+    op: "mx_noise",
+    params: { vector: 1 },
+    inputCount: 1
+  },
+  mx_fractal_noise_float: { op: "mx_fractal_noise", inputCount: 4 },
+  mx_fractal_noise_vec2: {
+    op: "mx_fractal_noise",
+    params: { vector: 1 },
+    inputCount: 4
+  },
+  mx_fractal_noise_vec3: {
+    op: "mx_fractal_noise",
+    params: { vector: 1 },
+    inputCount: 4
+  },
+  mx_fractal_noise_vec4: {
+    op: "mx_fractal_noise",
+    params: { vector: 1 },
+    inputCount: 4
+  },
+  mx_worley_noise_float: { op: "mx_worley_noise", inputCount: 2, planar: true },
+  // The squared distances to the nearest two, and three, points.
+  mx_worley_noise_vec2: {
+    op: "mx_worley_noise",
+    params: { vector: 1, features: 2 },
+    inputCount: 2,
+    planar: true
+  },
+  mx_worley_noise_vec3: {
+    op: "mx_worley_noise",
+    params: { vector: 1, features: 3 },
+    inputCount: 2,
+    planar: true
+  },
+  mx_cell_noise_float: { op: "mx_cell_noise", inputCount: 1 }
+};
+var TYPE_WIDTH = {
+  float: 1,
+  int: 1,
+  uint: 1,
+  bool: 1,
+  vec2: 2,
+  vec3: 3,
+  color: 3,
+  vec4: 4
+};
+var widest = (widths) => widths.length && widths.every((w) => w !== void 0) ? Math.max(...widths) : void 0;
+function outputWidth(op, inputs, params) {
+  switch (op) {
+    case "const":
+    case "uniform": {
+      const type = TYPE_WIDTH[String(params?.type)];
+      if (type) return type;
+      return Array.isArray(params?.value) ? params.value.length : 1;
+    }
+    case "uv":
+      return 2;
+    case "position":
+    case "normal":
+    case "view_direction":
+    case "camera_position":
+    case "normal_map":
+    case "bump_map":
+    case "cross":
+      return 3;
+    case "vertex_color":
+    case "texture":
+      return 4;
+    case "dot":
+    case "length":
+    case "distance":
+    case "luminance":
+    case "checker":
+      return 1;
+    case "swizzle":
+      return String(params?.components ?? "x").length;
+    case "convert":
+      return TYPE_WIDTH[String(params?.to)];
+    case "join":
+      return inputs.every((w) => w !== void 0) ? inputs.reduce((sum, w) => sum + w, 0) : void 0;
+    case "select":
+      return widest(inputs.slice(1));
+    case "reflect":
+    case "refract":
+    case "faceforward":
+    case "rotate":
+    case "remap":
+      return inputs[0];
+  }
+  if (op.startsWith("mx_") || op.startsWith("bk_")) return void 0;
+  return widest(inputs);
+}
+var Untranslatable = class extends Error {
+  constructor(issue) {
+    super(issue.message);
+    this.issue = issue;
+  }
+  issue;
+};
+var GraphWriter = class {
+  nodes = [];
+  issues = [];
+  textures = /* @__PURE__ */ new Map();
+  /** Ops seen, for the once-per-material approximate/bakery notes. */
+  opsUsed = /* @__PURE__ */ new Set();
+  memo = /* @__PURE__ */ new Map();
+  nextId = 0;
+  /** Fn-expansion results, cached so a shared call node stays shared. */
+  expanded = /* @__PURE__ */ new Map();
+  /** Components in each emitted value, where they can be known (`outputWidth`). */
+  widths = /* @__PURE__ */ new Map();
+  emit(op, inputs, params) {
+    const id = `n${this.nextId++}`;
+    this.opsUsed.add(op);
+    this.nodes.push({
+      id,
+      op,
+      ...inputs && inputs.length ? { inputs } : {},
+      ...params && Object.keys(params).length ? { params } : {}
+    });
+    const width = outputWidth(
+      op,
+      (inputs ?? []).map(
+        (input) => input ? this.widths.get(input) : void 0
+      ),
+      params
+    );
+    if (width) this.widths.set(id, width);
+    return id;
+  }
+  constant(value, type) {
+    return this.emit("const", void 0, { value, type });
+  }
+  refuse(code, message, docsAnchor = "shader-nodes") {
+    throw new Untranslatable({
+      code,
+      severity: "error",
+      message,
+      docs: `${DOCS}/${docsAnchor}`
+    });
+  }
+  /**
+   * The walk. Returns the IR id of the node's value.
+   *
+   * Dispatch order matters: the bakery-node marker and the uuid registry
+   * come before structure, because a marked node's TSL subtree is only its
+   * browser preview and must not be extracted.
+   */
+  visit(input) {
+    const node = unwrap(input);
+    if (node === null || node === void 0) {
+      this.refuse("shader_node_missing", "A node input was null.");
+    }
+    if (typeof node === "number") return this.constant(node, "float");
+    if (typeof node === "boolean") return this.constant(node ? 1 : 0, "float");
+    const tsl = node;
+    if (!tsl.isNode) {
+      const value = serializeValue(tsl);
+      if (value) return this.constant(value.value, value.type);
+      this.refuse(
+        "shader_node_unknown",
+        `A shader input was not a node (${describe2(tsl)}).`
+      );
+    }
+    const seen = this.memo.get(tsl.uuid);
+    if (seen) return seen;
+    const id = this.visitFresh(tsl);
+    this.memo.set(tsl.uuid, id);
+    return id;
+  }
+  visitFresh(node) {
+    const marker = node[BAKERY_NODE_MARKER];
+    if (marker) {
+      const inputs = (marker.inputs ?? []).map((input) => this.visit(input));
+      return this.emit(marker.op, inputs, marker.params);
+    }
+    const builtin = builtinFor(node.uuid);
+    if (builtin) {
+      return this.emit(builtin.op, void 0, builtin.params?.());
+    }
+    const type = node.type ?? "Node";
+    switch (type) {
+      case "ConstNode":
+        return this.emitValue(node, "const");
+      case "UniformNode": {
+        return this.emitValue(node, "uniform");
+      }
+      case "OperatorNode": {
+        const op = OPERATORS[node.op ?? ""];
+        if (!op) {
+          this.refuse(
+            "shader_node_unsupported",
+            `The "${node.op}" operator cannot be translated: bitwise operations do not exist as shader nodes.`
+          );
+        }
+        return this.emit(op, [this.visit(node.aNode), this.visit(node.bNode)]);
+      }
+      case "MathNode": {
+        const method = node.method ?? "";
+        const refused = MATH_REFUSED[method];
+        if (refused) {
+          this.refuse(
+            "shader_node_unsupported",
+            `\`${method}()\` cannot be translated. ${refused}`
+          );
+        }
+        if (method === "atan" && node.bNode) {
+          return this.emit("atan2", [
+            this.visit(node.aNode),
+            this.visit(node.bNode)
+          ]);
+        }
+        const op = MATH_METHODS[method];
+        if (!op) {
+          this.refuse(
+            "shader_node_unsupported",
+            `The \`${method}()\` math function has no render-engine equivalent.`
+          );
+        }
+        const inputs = [node.aNode, node.bNode, node.cNode].filter((n) => n !== null && n !== void 0).map((n) => this.visit(n));
+        return this.emit(op, inputs);
+      }
+      case "ConditionalNode":
+        return this.emit("select", [
+          this.visit(node.condNode),
+          this.visit(node.ifNode),
+          node.elseNode ? this.visit(node.elseNode) : this.constant(0, "float")
+        ]);
+      case "RemapNode":
+        return this.emit(
+          "remap",
+          [
+            this.visit(node.node),
+            this.visit(node.inLowNode),
+            this.visit(node.inHighNode),
+            this.visit(node.outLowNode),
+            this.visit(node.outHighNode)
+          ],
+          { clamp: node.doClamp ?? false }
+        );
+      case "SplitNode": {
+        const components = node.components ?? "x";
+        if (!/^[xyzwrgba]{1,4}$/.test(components)) {
+          this.refuse(
+            "shader_node_unsupported",
+            `Swizzle ".${components}" is not translatable.`
+          );
+        }
+        return this.emit("swizzle", [this.visit(node.node)], { components });
+      }
+      case "JoinNode": {
+        const parts = (node.nodes ?? []).map((n) => this.visit(n));
+        if (parts.length < 2 || parts.length > 4) {
+          this.refuse(
+            "shader_node_unsupported",
+            `join() of ${parts.length} components is not translatable.`
+          );
+        }
+        return this.emit("join", parts);
+      }
+      case "ConvertNode": {
+        const inner = this.visit(node.node);
+        const width = this.widths.get(inner);
+        const options = (node.convertTo ?? "").split("|");
+        let to = options[0];
+        for (const option of options)
+          if (width !== void 0 && TYPE_WIDTH[option] === width) to = option;
+        const id = this.emit("convert", [inner], { to });
+        if (options.length > 1 && width === void 0) this.widths.delete(id);
+        return id;
+      }
+      case "FlipNode":
+        return this.emit("one_minus", [this.visit(node.node)]);
+      case "RotateNode":
+        return this.emit("rotate", [
+          this.visit(node.positionNode),
+          this.constant([0, 0, 1], "vec3"),
+          this.visit(node.rotationNode)
+        ]);
+      case "NormalMapNode":
+        return this.emit("normal_map", [
+          this.visit(node.node),
+          node.scaleNode ? this.visit(node.scaleNode) : this.constant(1, "float")
+        ]);
+      case "BumpMapNode":
+        return this.emit("bump_map", [
+          this.visit(node.textureNode),
+          node.scaleNode ? this.visit(node.scaleNode) : this.constant(1, "float")
+        ]);
+      case "AttributeNode":
+        return this.emitAttribute(node);
+      case "VertexColorNode":
+        return this.emit("vertex_color");
+      case "TextureNode":
+        return this.emitTexture(node);
+      case "VarNode":
+      case "VaryingNode": {
+        const named = node.name ? NAMED_BUILTINS[node.name] : void 0;
+        if (named) return this.emit(named.op, void 0, named.params);
+        if (node.node) return this.visit(node.node);
+        this.refuse(
+          "shader_node_unsupported",
+          `Variable "${node.name ?? "unnamed"}" has no source node.`
+        );
+      }
+      // Purely organisational wrappers: the value is the wrapped node.
+      case "ContextNode":
+      case "CacheNode":
+      case "DebugNode":
+        if (node.node) return this.visit(node.node);
+        this.refuse("shader_node_unsupported", `${type} has no inner node.`);
+        break;
+      // overloadingFn([...]): how MaterialX's noise family is published.
+      // The variants share a base name ('mx_perlin_noise_float_0/_1'), which
+      // is what the catalog knows them by.
+      case "FunctionOverloadingNode": {
+        const first = (node.functionNodes ?? [])[0];
+        const layout = first?.shaderNode?.layout?.name;
+        const base = layout?.replace(/_\d+$/, "");
+        const named = base ? NAMED_FUNCTIONS[base] : void 0;
+        if (named) return this.emitNamed(named, base, node.parametersNodes);
+        this.refuse(
+          "shader_fn_opaque",
+          `The overloaded shader function ${layout ?? "(unnamed)"} has no render-engine equivalent.`
+        );
+        break;
+      }
+    }
+    if (node.isShaderCallNodeInternal || node.shaderNode) {
+      return this.emitFnCall(node);
+    }
+    this.refuse(
+      "shader_node_unsupported",
+      `${describeNodeType(type)} cannot be translated.`
+    );
+  }
+  emitValue(node, op) {
+    const serialized = serializeValue(node.value);
+    if (!serialized) {
+      this.refuse(
+        "shader_node_unsupported",
+        op === "uniform" ? `A uniform holds a ${describe2(node.value)}, which cannot travel as a shader value (matrices and textures cannot).` : `A constant holds a ${describe2(node.value)}, which cannot travel as a shader value.`
+      );
+    }
+    const params = {
+      value: serialized.value,
+      type: serialized.type
+    };
+    if (op === "uniform" && node.name) params.name = node.name;
+    return this.emit(op, void 0, params);
+  }
+  emitAttribute(node) {
+    const name = node._attributeName ?? "";
+    const uvIndex = /^uv(\d?)$/.exec(name);
+    if (uvIndex) {
+      return this.emit("uv", void 0, {
+        index: uvIndex[1] ? Number(uvIndex[1]) : 0
+      });
+    }
+    if (name === "position")
+      return this.emit("position", void 0, { space: "local" });
+    if (name === "normal")
+      return this.emit("normal", void 0, { space: "local" });
+    if (name === "color") return this.emit("vertex_color");
+    this.refuse(
+      "shader_attribute_unsupported",
+      `The custom geometry attribute "${name}" does not survive glTF export, so the renderer cannot read it. Rename it to a COLOR_0/TEXCOORD channel or bake it to a texture.`
+    );
+  }
+  emitTexture(node) {
+    const texture = node.value;
+    if (!texture || !texture.isTexture) {
+      this.refuse(
+        "shader_texture_missing",
+        "A texture node has no texture assigned."
+      );
+    }
+    const uvInput = node.uvNode ? this.visit(node.uvNode) : this.emit("uv", void 0, { index: 0 });
+    return this.sampleTexture(texture, uvInput);
+  }
+  /** A texture sample from a known texture; also used for the static maps. */
+  sampleTexture(texture, uvInput) {
+    const uv = uvInput ?? this.emit("uv", void 0, { index: 0 });
+    const params = {
+      image: "",
+      colorSpace: texture.colorSpace === "srgb" ? "srgb" : "linear",
+      wrap: wrapMode(texture),
+      filter: texture.magFilter === 1003 ? "nearest" : "linear",
+      // three's default. A GLTFLoader texture has flipY false, and the
+      // renderer compensates with a V flip so both sample the image the same
+      // way up.
+      flipY: texture.flipY !== false
+    };
+    const id = this.emit("texture", [uv], params);
+    const existing = this.textures.get(texture.uuid);
+    if (existing) {
+      const previous = existing.apply;
+      existing.apply = (image) => {
+        previous(image);
+        params.image = image;
+      };
+    } else {
+      this.textures.set(texture.uuid, {
+        texture,
+        apply: (image) => {
+          params.image = image;
+        }
+      });
+    }
+    return id;
+  }
+  emitFnCall(node) {
+    const layoutName = node.shaderNode?.layout?.name;
+    const named = layoutName ? NAMED_FUNCTIONS[layoutName] ?? NAMED_FUNCTIONS[layoutName.replace(/_\d+$/, "")] : void 0;
+    if (named) {
+      return this.emitNamed(
+        named,
+        layoutName.replace(/_\d+$/, ""),
+        Array.isArray(node.rawInputs) ? node.rawInputs : [],
+        // A variant called directly declares its coordinate's type.
+        TYPE_WIDTH[node.shaderNode?.layout?.inputs?.[0]?.type ?? ""]
+      );
+    }
+    const expandedNode = this.expand(node);
+    if (expandedNode) return this.visit(expandedNode);
+    const label = layoutName ?? "an anonymous Fn()";
+    this.refuse(
+      "shader_fn_opaque",
+      `The shader function ${label} could not be analyzed: it depends on renderer state the SDK cannot see.` + (tslRuntimeRegistered() ? "" : ` If it is a three.js builtin, importing '@oeave/bakery3/tsl' teaches the checker to recognize it.`)
+    );
+  }
+  /**
+   * A library function by its base name ('mx_worley_noise_vec2'). The name
+   * says how wide its value is; a `planar` one records a 2D coordinate.
+   */
+  emitNamed(named, base, raw = [], declared) {
+    const inputs = raw.slice(0, named.inputCount ?? raw.length).map((input) => this.visit(input));
+    const params = { ...named.params };
+    const coordinate = declared ?? (inputs[0] ? this.widths.get(inputs[0]) : void 0);
+    if (named.planar && coordinate === 2) params.dimensions = 2;
+    const id = this.emit(named.op, inputs, params);
+    const width = TYPE_WIDTH[base.slice(base.lastIndexOf("_") + 1)];
+    if (width) this.widths.set(id, width);
+    return id;
+  }
+  expand(node) {
+    const cached = this.expanded.get(node.uuid);
+    if (cached) return cached;
+    const jsFunc = node.shaderNode?.jsFunc;
+    if (typeof jsFunc !== "function") return null;
+    try {
+      const raw = node.rawInputs;
+      const inputs = Array.isArray(raw) ? raw.map(toNodeObject) : raw;
+      const result = unwrap(
+        jsFunc(Array.isArray(inputs) ? inputs : inputs ?? [])
+      );
+      if (result && result.isNode) {
+        this.expanded.set(node.uuid, result);
+        return result;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+function isNodeMaterial(material) {
+  return Boolean(material?.isNodeMaterial);
+}
+var SLOT_NODES = [
+  ["color", "colorNode"],
+  ["opacity", "opacityNode"],
+  ["alphaTest", "alphaTestNode"],
+  ["roughness", "roughnessNode"],
+  ["metalness", "metalnessNode"],
+  ["normal", "normalNode"],
+  ["emissive", "emissiveNode"],
+  ["ao", "aoNode"],
+  ["clearcoat", "clearcoatNode"],
+  ["clearcoatRoughness", "clearcoatRoughnessNode"],
+  ["sheen", "sheenNode"],
+  ["sheenRoughness", "sheenRoughnessNode"],
+  ["iridescence", "iridescenceNode"],
+  ["iridescenceIOR", "iridescenceIORNode"],
+  ["iridescenceThickness", "iridescenceThicknessNode"],
+  ["transmission", "transmissionNode"],
+  ["thickness", "thicknessNode"],
+  ["ior", "iorNode"],
+  ["specularIntensity", "specularIntensityNode"],
+  ["specularColor", "specularColorNode"],
+  ["anisotropy", "anisotropyNode"]
+];
+var REFUSED_SLOTS = [
+  [
+    "fragmentNode",
+    "fragmentNode replaces the whole fragment stage; there is no BSDF left to translate."
+  ],
+  [
+    "outputNode",
+    "outputNode replaces the material output; there is no BSDF left to translate."
+  ],
+  [
+    "positionNode",
+    "positionNode displaces vertices at shade time; true displacement is not wired up yet."
+  ],
+  [
+    "backdropNode",
+    "backdropNode is a screen-space effect with no path-traced equivalent."
+  ],
+  [
+    "depthNode",
+    "depthNode overrides rasterizer depth, which a path tracer does not have."
+  ],
+  [
+    "envNode",
+    "A per-material environment override is not translated; the scene environment is used."
+  ]
+];
+function extractMaterialShader(material) {
+  const writer = new GraphWriter();
+  const outputs = {};
+  const supportedSlots = [];
+  const failedSlots = [];
+  for (const [prop, reason] of REFUSED_SLOTS) {
+    if (material[prop]) {
+      writer.issues.push({
+        code: "shader_slot_unsupported",
+        severity: prop === "envNode" ? "warning" : "error",
+        message: `${material.type ?? "NodeMaterial"} sets \`${prop}\`. ${reason}`,
+        docs: `${DOCS}/shader-nodes#slots`
+      });
+    }
+  }
+  for (const [slot, prop] of SLOT_NODES) {
+    const driver = material[prop];
+    if (!driver) continue;
+    try {
+      outputs[slot] = writer.visit(driver);
+      supportedSlots.push(slot);
+    } catch (error) {
+      if (!(error instanceof Untranslatable)) throw error;
+      failedSlots.push(slot);
+      writer.issues.push({
+        ...error.issue,
+        message: `In \`${prop}\`: ${error.issue.message}`
+      });
+    }
+  }
+  synthesizeStaticMaps(material, writer, outputs, supportedSlots);
+  const hasGraph = Object.keys(outputs).length > 0;
+  const nodes = pruneUnreachable(writer.nodes, outputs);
+  reportTiers(writer);
+  return {
+    spec: hasGraph ? {
+      materialId: idOf(material),
+      ...material.name ? { name: material.name } : {},
+      base: material.isMeshPhysicalNodeMaterial ? "physical" : material.isMeshBasicNodeMaterial ? "basic" : "standard",
+      properties: staticProperties(material),
+      graph: {
+        version: SHADER_GRAPH_VERSION,
+        nodes,
+        outputs
+      }
+    } : null,
+    supportedSlots,
+    failedSlots,
+    issues: writer.issues,
+    textures: [...writer.textures.values()]
+  };
+}
+function synthesizeStaticMaps(material, writer, outputs, supportedSlots) {
+  const texture = (prop) => {
+    const value = material[prop];
+    return value && value.isTexture ? value : null;
+  };
+  const claim = (slot, id) => {
+    outputs[slot] = id;
+    supportedSlots.push(slot);
+  };
+  const sample2 = (map) => writer.sampleTexture(map);
+  try {
+    const map = texture("map");
+    if (map && !outputs.color) {
+      const color = serializeValue(material.color) ?? {
+        value: [1, 1, 1],
+        type: "color"
+      };
+      claim(
+        "color",
+        writer.emit("mul", [
+          sample2(map),
+          writer.constant(color.value, "color")
+        ])
+      );
+    }
+    const roughnessMap = texture("roughnessMap");
+    if (roughnessMap && !outputs.roughness) {
+      const channel = writer.emit("swizzle", [sample2(roughnessMap)], {
+        components: "g"
+      });
+      claim(
+        "roughness",
+        writer.emit("mul", [
+          channel,
+          writer.constant(num(material.roughness, 1), "float")
+        ])
+      );
+    }
+    const metalnessMap = texture("metalnessMap");
+    if (metalnessMap && !outputs.metalness) {
+      const channel = writer.emit("swizzle", [sample2(metalnessMap)], {
+        components: "b"
+      });
+      claim(
+        "metalness",
+        writer.emit("mul", [
+          channel,
+          writer.constant(num(material.metalness, 0), "float")
+        ])
+      );
+    }
+    const emissiveMap = texture("emissiveMap");
+    if (emissiveMap && !outputs.emissive) {
+      const emissive = serializeValue(material.emissive) ?? {
+        value: [0, 0, 0],
+        type: "color"
+      };
+      claim(
+        "emissive",
+        writer.emit("mul", [
+          sample2(emissiveMap),
+          writer.constant(emissive.value, "color")
+        ])
+      );
+    }
+    const alphaMap = texture("alphaMap");
+    if (alphaMap && !outputs.opacity) {
+      const channel = writer.emit("swizzle", [sample2(alphaMap)], {
+        components: "g"
+      });
+      claim(
+        "opacity",
+        writer.emit("mul", [
+          channel,
+          writer.constant(num(material.opacity, 1), "float")
+        ])
+      );
+    }
+    const normalMap = texture("normalMap");
+    if (normalMap && !outputs.normal) {
+      const scale = material.normalScale;
+      claim(
+        "normal",
+        writer.emit("normal_map", [
+          sample2(normalMap),
+          writer.constant(num(scale?.x, 1), "float")
+        ])
+      );
+    }
+    const aoMap = texture("aoMap");
+    if (aoMap && !outputs.ao) {
+      const channel = writer.emit("swizzle", [sample2(aoMap)], {
+        components: "r"
+      });
+      const intensity = writer.constant(
+        num(material.aoMapIntensity, 1),
+        "float"
+      );
+      const one = writer.constant(1, "float");
+      const delta = writer.emit("sub", [channel, one]);
+      claim(
+        "ao",
+        writer.emit("add", [one, writer.emit("mul", [intensity, delta])])
+      );
+    }
+  } catch (error) {
+    if (!(error instanceof Untranslatable)) throw error;
+    writer.issues.push(error.issue);
+  }
+}
+function pruneUnreachable(nodes, outputs) {
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = Object.values(outputs).filter(
+    (id) => Boolean(id)
+  );
+  while (queue.length) {
+    const id = queue.pop();
+    if (reachable.has(id)) continue;
+    reachable.add(id);
+    for (const input of byId.get(id)?.inputs ?? []) queue.push(input);
+  }
+  return nodes.filter((node) => reachable.has(node.id));
+}
+function reportTiers(writer) {
+  const bakeryOps = [];
+  for (const op of writer.opsUsed) {
+    const info = SHADER_OPS[op];
+    if (!info) continue;
+    if (info.tier === "approximate" && info.note) {
+      writer.issues.push({
+        code: "shader_op_approximated",
+        severity: "warning",
+        message: info.note,
+        docs: `${DOCS}/shader-nodes#${op}`
+      });
+    }
+    if (info.tier === "bakery") bakeryOps.push(op);
+  }
+  if (bakeryOps.length) {
+    writer.issues.push({
+      code: "shader_bakery_nodes",
+      severity: "info",
+      message: `Uses ${bakeryOps.length} bakery-only node(s) (${bakeryOps.join(", ")}). The viewport shows an approximation; the render is the real one.`,
+      docs: `${DOCS}/shader-nodes#bakery-only`
+    });
+  }
+}
+function staticProperties(material) {
+  const properties = {};
+  const color = (key, prop) => {
+    const value = material[prop];
+    if (value?.isColor && value.getHexString) {
+      properties[key] = `#${value.getHexString()}`;
+    }
+  };
+  const scalar2 = (key, prop) => {
+    const value = material[prop];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      properties[key] = value;
+    }
+  };
+  color("color", "color");
+  color("emissive", "emissive");
+  color("sheenColor", "sheenColor");
+  color("specularColor", "specularColor");
+  color("attenuationColor", "attenuationColor");
+  scalar2("roughness", "roughness");
+  scalar2("metalness", "metalness");
+  scalar2("emissiveIntensity", "emissiveIntensity");
+  scalar2("opacity", "opacity");
+  scalar2("alphaTest", "alphaTest");
+  scalar2("ior", "ior");
+  scalar2("transmission", "transmission");
+  scalar2("thickness", "thickness");
+  scalar2("attenuationDistance", "attenuationDistance");
+  scalar2("clearcoat", "clearcoat");
+  scalar2("clearcoatRoughness", "clearcoatRoughness");
+  scalar2("sheen", "sheen");
+  scalar2("sheenRoughness", "sheenRoughness");
+  scalar2("specularIntensity", "specularIntensity");
+  scalar2("iridescence", "iridescence");
+  scalar2("iridescenceIOR", "iridescenceIOR");
+  scalar2("anisotropy", "anisotropy");
+  if (material.transparent === true) properties.transparent = true;
+  if (material.side === 2) properties.doubleSided = true;
+  return properties;
+}
+function unwrap(value) {
+  const node = value;
+  if (node && typeof node === "object" && typeof node.getSelf === "function") {
+    try {
+      return node.getSelf();
+    } catch {
+      return node;
+    }
+  }
+  return value;
+}
+function serializeValue(value) {
+  if (typeof value === "number") return { value, type: "float" };
+  if (typeof value === "boolean")
+    return { value: value ? 1 : 0, type: "float" };
+  const v = value;
+  if (!v || typeof v !== "object") return null;
+  if (v.isColor) return { value: [v.r, v.g, v.b], type: "color" };
+  if (v.isVector2) return { value: [v.x, v.y], type: "vec2" };
+  if (v.isVector3) return { value: [v.x, v.y, v.z], type: "vec3" };
+  if (v.isVector4) return { value: [v.x, v.y, v.z, v.w], type: "vec4" };
+  return null;
+}
+function wrapMode(texture) {
+  const wrap = texture.wrapS ?? 1e3;
+  return wrap === 1001 ? "clamp" : wrap === 1002 ? "mirror" : "repeat";
+}
+function num(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function describe2(value) {
+  if (value === null) return "null";
+  if (typeof value !== "object") return typeof value;
+  const v = value;
+  if (v.isMatrix3) return "Matrix3";
+  if (v.isMatrix4) return "Matrix4";
+  if (v.isQuaternion) return "Quaternion";
+  if (v.isTexture) return "Texture";
+  return v.constructor?.name ?? "object";
+}
+function describeNodeType(type) {
+  const KNOWN = {
+    ViewportTextureNode: "Reading the viewport back",
+    ScreenNode: "Screen-space coordinates",
+    ViewportNode: "Screen-space coordinates",
+    MatcapUVNode: "Matcap UVs (they encode the rasterizer camera)",
+    ReflectorNode: "A planar reflector (it renders the scene twice)",
+    RTTNode: "Render-to-texture",
+    LoopNode: "A shader loop",
+    ArrayNode: "A shader array",
+    StorageBufferNode: "A storage buffer",
+    FunctionOverloadingNode: "An overloaded shader function",
+    ComputeNode: "A compute pass"
+  };
+  return KNOWN[type] ?? `A "${type}"`;
+}
+
+// src/compat/analyze.ts
+var DOCS2 = "https://bakery3.com/docs";
+var LARGE_TEXTURE_PX = 4096;
+var LARGE_TRIANGLE_COUNT = 1e7;
+var TRANSLATABLE = /* @__PURE__ */ new Set(["MeshStandardMaterial", "MeshPhysicalMaterial"]);
+var APPROXIMATED = {
+  MeshBasicMaterial: "Rendered as an emissive surface, since a path tracer has no unlit shading model.",
+  MeshLambertMaterial: "Rendered as a rough physically based material. Lambert has no specular term, so highlights will differ.",
+  MeshPhongMaterial: "Converted to roughness/metalness. Phong shininess is not a physical parameter, so the specular falloff is an approximation.",
+  MeshToonMaterial: "Rendered as flat diffuse. Cel shading is a screen-space stylization with no path-traced equivalent.",
+  MeshMatcapMaterial: "Rendered as diffuse using the matcap average. A matcap encodes lighting into a texture, which is exactly what path tracing replaces.",
+  MeshNormalMaterial: "Rendered as flat gray. Normal visualization is a debug view, not a surface.",
+  MeshDepthMaterial: "Rendered as flat gray. Depth output is a debug view.",
+  MeshDistanceMaterial: "Rendered as flat gray. Distance output is a debug view."
+};
+function emitsLight(material) {
+  const m = material;
+  if (m.isMeshBasicMaterial) return true;
+  if (m.emissiveNode) return true;
+  if ((m.emissiveIntensity ?? 1) <= 0) return false;
+  if (m.emissiveMap) return true;
+  const e = m.emissive;
+  return Boolean(e && e.r + e.g + e.b > 0);
+}
+function analyzeScene(root) {
+  const issues = [];
+  const seenMaterials = /* @__PURE__ */ new Set();
+  const seenTextures = /* @__PURE__ */ new Set();
+  let triangles = 0;
+  let faithfulTriangles = 0;
+  let maxTextureDimension = 0;
+  let emitters = 0;
+  root.traverse((object) => {
+    if (shouldExclude(object)) return;
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    const count = triangleCount(mesh);
+    triangles += count;
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    let objectIsFaithful = true;
+    for (const material of materials) {
+      if (!material) continue;
+      for (const texture of texturesOf(material)) {
+        if (seenTextures.has(texture.uuid)) continue;
+        seenTextures.add(texture.uuid);
+        const dimension = Math.max(
+          texture.image?.width ?? 0,
+          texture.image?.height ?? 0
+        );
+        maxTextureDimension = Math.max(maxTextureDimension, dimension);
+        if (dimension > LARGE_TEXTURE_PX) {
+          issues.push({
+            code: "texture_large",
+            severity: "warning",
+            message: `Texture "${texture.name || texture.uuid.slice(0, 8)}" is ${dimension}px. Above 4K a texture costs upload time and VRAM without visibly improving a product render.`,
+            path: pathOf(object),
+            docs: `${DOCS2}/scene-size#textures`
+          });
+        }
+      }
+      if (seenMaterials.has(material.uuid)) continue;
+      seenMaterials.add(material.uuid);
+      if (emitsLight(material)) emitters++;
+      for (const issue of classifyMaterial(material, object)) {
+        issues.push(issue);
+        if (issue.severity === "error") objectIsFaithful = false;
+      }
+    }
+    if (objectIsFaithful) faithfulTriangles += count;
+  });
+  if (triangles > LARGE_TRIANGLE_COUNT) {
+    issues.push({
+      code: "scene_large",
+      severity: "warning",
+      message: `Scene has ${(triangles / 1e6).toFixed(1)}M triangles.`,
+      docs: `${DOCS2}/scene-size`
+    });
+  }
+  const fog = captureFog(root).issue;
+  if (fog) issues.push(fog);
+  const counts = { info: 0, warning: 0, error: 0 };
+  for (const issue of issues) counts[issue.severity]++;
+  return {
+    // An empty scene is not 0% compatible, it is a different problem, and
+    // reporting 0 there would put a red 0% in the devtools panel of a
+    // developer whose scene simply had not loaded yet.
+    score: triangles === 0 ? 1 : faithfulTriangles / triangles,
+    issues,
+    counts,
+    triangles,
+    textures: { count: seenTextures.size, maxDimension: maxTextureDimension },
+    emitters
+  };
+}
+function collectFallbacks(root) {
+  const fallbacks = [];
+  const seen = /* @__PURE__ */ new Set();
+  root.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    for (const material of materials) {
+      if (!material || seen.has(material.uuid)) continue;
+      const declared = material.userData?.bakery3?.fallback ?? readUserData(object).fallback;
+      if (!declared) continue;
+      seen.add(material.uuid);
+      fallbacks.push({
+        ...declared,
+        materialId: idOf(material),
+        type: "physical"
+      });
+    }
+  });
+  return fallbacks;
+}
+function classifyMaterial(material, object) {
+  const hasFallback = Boolean(
+    material.userData?.bakery3?.fallback ?? readUserData(object).fallback
+  );
+  if (isNodeMaterial(material) && !hasFallback) {
+    const extracted = extractMaterialShader(material);
+    return extracted.issues.map((issue) => ({
+      ...issue,
+      path: pathOf(object),
+      materialId: idOf(material),
+      materialName: material.name,
+      materialType: material.type
+    }));
+  }
+  const verdict = classify(material, object, hasFallback);
+  return verdict ? [verdict.issue] : [];
+}
+function classify(material, object, hasFallback) {
+  if (TRANSLATABLE.has(material.type)) return null;
+  if (hasFallback) {
+    return {
+      issue: {
+        code: "material_fallback_used",
+        severity: "info",
+        message: `${material.type} "${material.name || "unnamed"}" renders with your declared fallback.`,
+        path: pathOf(object),
+        materialId: idOf(material),
+        materialName: material.name,
+        materialType: material.type,
+        docs: `${DOCS2}/material-fallbacks`
+      }
+    };
+  }
+  if (material.type === "ShaderMaterial" || material.type === "RawShaderMaterial") {
+    return {
+      issue: {
+        code: "material_custom_shader",
+        severity: "error",
+        message: `Unsupported material: ${material.name || material.type}`,
+        path: pathOf(object),
+        materialId: idOf(material),
+        materialName: material.name,
+        materialType: material.type,
+        docs: `${DOCS2}/material-fallbacks`
+      }
+    };
+  }
+  const approximation = APPROXIMATED[material.type];
+  if (approximation) {
+    return {
+      issue: {
+        code: "material_approximated",
+        severity: "warning",
+        message: `${material.type} "${material.name || "unnamed"}" is approximated. ${approximation}`,
+        path: pathOf(object),
+        materialId: idOf(material),
+        materialName: material.name,
+        materialType: material.type,
+        docs: `${DOCS2}/materials`
+      }
+    };
+  }
+  return {
+    issue: {
+      code: "material_unknown",
+      severity: "error",
+      message: `Unsupported material: ${material.name || material.type}`,
+      path: pathOf(object),
+      materialId: idOf(material),
+      materialName: material.name,
+      materialType: material.type,
+      docs: `${DOCS2}/materials`
+    }
+  };
+}
+var TEXTURE_SLOTS = [
+  "map",
+  "normalMap",
+  "bumpMap",
+  "displacementMap",
+  "roughnessMap",
+  "metalnessMap",
+  "aoMap",
+  "emissiveMap",
+  "alphaMap",
+  "clearcoatMap",
+  "clearcoatNormalMap",
+  "clearcoatRoughnessMap",
+  "transmissionMap",
+  "thicknessMap",
+  "sheenColorMap",
+  "sheenRoughnessMap",
+  "iridescenceMap",
+  "iridescenceThicknessMap",
+  "anisotropyMap",
+  "specularMap",
+  "specularColorMap",
+  "specularIntensityMap"
+];
+function texturesOf(material) {
+  const out = [];
+  const record2 = material;
+  for (const slot of TEXTURE_SLOTS) {
+    const texture = record2[slot];
+    if (texture?.isTexture) out.push(texture);
+  }
+  return out;
+}
+function triangleCount(mesh) {
+  const geometry = mesh.geometry;
+  if (!geometry) return 0;
+  const indexed = geometry.index?.count;
+  const positions = geometry.attributes.position?.count ?? 0;
+  const vertices = indexed ?? positions;
+  const instances = mesh.count;
+  const perInstance = Math.floor(vertices / 3);
+  return mesh.isInstancedMesh ? perInstance * (instances ?? 1) : perInstance;
+}
+var pathOf = scenePath;
+var PROBED_INSTANCES = 64;
+function sceneComplexity(scene, camera) {
+  scene.updateMatrixWorld();
+  camera.updateMatrixWorld();
+  const rooms = new Set(findPresetRooms(scene));
+  const meshes = [];
+  let objects = 0;
+  const visit = (object) => {
+    if (!object.visible) return;
+    if (excludedItself(object) && !rooms.has(object)) return;
+    const mesh = object;
+    if (mesh.isMesh && mesh.geometry?.attributes?.position) {
+      const position = mesh.geometry.attributes.position;
+      const index = mesh.geometry.index;
+      const plain = !position.normalized && !position.isInterleavedBufferAttribute && position.itemSize === 3;
+      const positions = plain ? position.array : Float32Array.from(
+        { length: position.count * 3 },
+        (_, i) => i % 3 === 0 ? position.getX(i / 3 | 0) : i % 3 === 1 ? position.getY(i / 3 | 0) : position.getZ(i / 3 | 0)
+      );
+      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+      const emitter = materials.length > 0 && materials.every((material) => material && emitsLight(material));
+      const base = {
+        positions,
+        indices: index?.array ?? null,
+        emitter
+      };
+      if (mesh.isInstancedMesh && mesh.instanceMatrix) {
+        const count = mesh.count ?? 0;
+        objects += count;
+        const local = new Matrix4();
+        for (let i = 0; i < Math.min(count, PROBED_INSTANCES); i++) {
+          local.fromArray(mesh.instanceMatrix.array, i * 16);
+          meshes.push({
+            ...base,
+            matrix: new Matrix4().multiplyMatrices(mesh.matrixWorld, local).elements
+          });
+        }
+      } else {
+        objects += 1;
+        meshes.push({ ...base, matrix: mesh.matrixWorld.elements });
+      }
+    }
+    for (const child of object.children) visit(child);
+  };
+  visit(scene);
+  const eye = camera.getWorldPosition(new Vector3());
+  return complexityOf(meshes, [eye.x, eye.y, eye.z], objects);
+}
+
+// src/capture/color.ts
+var TONE_MAPPING = {
+  0: "none",
+  1: "linear",
+  2: "reinhard",
+  3: "cineon",
+  4: "aces-filmic",
+  // AgX (r162+) and Neutral (r165+) took the next two slots, in that order.
+  6: "agx",
+  7: "neutral"
+};
+var COLOR_SPACES = {
+  srgb: "srgb",
+  "srgb-linear": "srgb-linear",
+  "display-p3": "display-p3"
+};
+function captureColor(renderer) {
+  if (!renderer) {
+    return {
+      outputColorSpace: "srgb",
+      toneMapping: "none",
+      toneMappingExposure: 1
+    };
+  }
+  return {
+    outputColorSpace: COLOR_SPACES[renderer.outputColorSpace ?? "srgb"] ?? "srgb",
+    toneMapping: TONE_MAPPING[renderer.toneMapping ?? 0] ?? "none",
+    toneMappingExposure: renderer.toneMappingExposure ?? 1
+  };
+}
+
+// src/capture/shaders.ts
+async function captureShaders(root) {
+  const shaders = [];
+  const assets = [];
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  const hashed = /* @__PURE__ */ new Map();
+  const materials = [];
+  root.traverse((object) => {
+    if (shouldExclude(object)) return;
+    const mesh = object;
+    if (!mesh.isMesh || !mesh.material) return;
+    const list = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    for (const material of list) {
+      if (!material || seen.has(material.uuid)) continue;
+      seen.add(material.uuid);
+      const hasFallback = Boolean(
+        material.userData?.bakery3?.fallback ?? readUserData(object).fallback
+      );
+      if (isNodeMaterial(material) && !hasFallback) {
+        materials.push({ material, path: pathOf2(object) });
+      }
+    }
+  });
+  for (const { material, path } of materials) {
+    const extracted = extractMaterialShader(material);
+    if (!extracted.spec) continue;
+    let texturesOk = true;
+    for (const ref of extracted.textures) {
+      const hash = await resolveTexture(
+        ref,
+        hashed,
+        assets,
+        issues,
+        material,
+        path
+      );
+      if (!hash) texturesOk = false;
+    }
+    if (texturesOk) {
+      shaders.push(extracted.spec);
+    }
+  }
+  return { shaders, assets, issues };
+}
+async function resolveTexture(ref, hashed, assets, issues, material, path) {
+  const known = hashed.get(ref.texture.uuid);
+  if (known !== void 0) {
+    if (known) ref.apply(known);
+    return known;
+  }
+  const bytes = await textureBytes(ref.texture);
+  if (!bytes) {
+    hashed.set(ref.texture.uuid, null);
+    issues.push({
+      code: "shader_texture_unreadable",
+      severity: "error",
+      message: `The texture "${ref.texture.name || ref.texture.uuid.slice(0, 8)}" used by "${material.name || material.type}" has no reachable pixels, so the shader graph was not sent. `,
+      path,
+      materialId: idOf(material),
+      materialName: material.name,
+      materialType: material.type,
+      docs: "https://bakery3.com/docs/shader-nodes#textures"
+    });
+    return null;
+  }
+  const hash = await sha256(bytes.data);
+  hashed.set(ref.texture.uuid, hash);
+  if (!assets.some((asset) => asset.hash === hash)) {
+    assets.push({
+      hash,
+      kind: "texture",
+      bytes: bytes.data.byteLength,
+      contentType: bytes.contentType,
+      name: ref.texture.name || "shader-texture",
+      data: bytes.data
+    });
+  }
+  ref.apply(hash);
+  return hash;
+}
+async function textureBytes(texture) {
+  const declared = texture.userData?.bakery3?.src;
+  if (typeof declared === "string") {
+    const fetched = await fetchBytes(declared);
+    if (fetched) return fetched;
+  }
+  const image = texture.image;
+  if (!image) return null;
+  if (typeof image.src === "string" && image.src && !image.src.startsWith("blob:")) {
+    const fetched = await fetchBytes(image.src);
+    if (fetched) return fetched;
+  }
+  const raw = image.data;
+  if (raw && ArrayBuffer.isView(raw)) {
+    if (!(raw instanceof Uint8Array) && !(raw instanceof Uint8ClampedArray)) {
+      return null;
+    }
+    return encodeRGBA(raw, image.width ?? 0, image.height ?? 0);
+  }
+  return drawToPng(
+    image,
+    image.width ?? 0,
+    image.height ?? 0
+  );
+}
+async function fetchBytes(url) {
+  if (typeof fetch !== "function") return null;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) return null;
+    return {
+      data: await response.arrayBuffer(),
+      contentType: response.headers.get("content-type") ?? "application/octet-stream"
+    };
+  } catch {
+    return null;
+  }
+}
+async function drawToPng(source, width, height) {
+  if (!width || !height) return null;
+  const canvas = makeCanvas(width, height);
+  if (!canvas) return null;
+  const context = canvas.getContext("2d");
+  if (!context) return null;
+  try {
+    context.drawImage(source, 0, 0);
+  } catch {
+    return null;
+  }
+  return canvasToPng(canvas);
+}
+async function encodeRGBA(data, width, height) {
+  if (!width || !height || data.length < width * height * 4) return null;
+  const canvas = makeCanvas(width, height);
+  if (!canvas) return null;
+  const context = canvas.getContext("2d");
+  if (!context) return null;
+  const pixels = new Uint8ClampedArray(width * height * 4);
+  pixels.set(data.subarray(0, pixels.length));
+  context.putImageData(new ImageData(pixels, width, height), 0, 0);
+  return canvasToPng(canvas);
+}
+function makeCanvas(width, height) {
+  if (typeof OffscreenCanvas !== "undefined")
+    return new OffscreenCanvas(width, height);
+  if (typeof document !== "undefined") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  }
+  return null;
+}
+async function canvasToPng(canvas) {
+  if ("convertToBlob" in canvas) {
+    const blob2 = await canvas.convertToBlob({ type: "image/png" });
+    return { data: await blob2.arrayBuffer(), contentType: "image/png" };
+  }
+  const blob = await new Promise(
+    (resolve) => canvas.toBlob(resolve, "image/png")
+  );
+  return blob ? { data: await blob.arrayBuffer(), contentType: "image/png" } : null;
+}
+function pathOf2(object) {
+  const parts = [];
+  let current = object;
+  while (current && current.parent) {
+    parts.unshift(`<${current.name || current.type}>`);
+    current = current.parent;
+  }
+  return parts.join("/");
+}
+
+// src/capture/room.ts
+var DOCS3 = "https://bakery3.com/docs/presets#room-presets";
+function captureRoomPreset(scene, report, context) {
+  const rooms = findPresetRooms(scene);
+  if (!rooms.length) return null;
+  if (rooms.length > 1) {
+    throw new Bakery3Error({
+      code: "CaptureFailed",
+      message: `The scene holds ${rooms.length} room presets (${rooms.map(scenePath).join(", ")}); a render can be inside one room.`,
+      why: "The renderer rebuilds a room around the product from its published definition, and two rooms would be two skies and two suns for one camera.",
+      fix: "Keep one createPresetRoom() group in the scene at render time: hide the others with userData.bakery3.exclude, or remove them.",
+      docs: DOCS3
+    });
+  }
+  const group = rooms[0];
+  const spec = roomPresetSpecOf(group);
+  const info = roomPresetFactsOf(group);
+  const note = (issue) => {
+    report.issues.push({
+      ...issue,
+      severity: "info",
+      path: scenePath(group),
+      docs: DOCS3
+    });
+    report.counts.info++;
+  };
+  note({
+    code: "RoomPresetReconstructed",
+    message: `Room preset "${info?.label ?? spec.name}" is rebuilt by the renderer from its full-quality definition; the furniture, lights and materials in the viewport are stand-ins, and the foliage outside its windows exists only in the render.`
+  });
+  if (context.environment) {
+    note({
+      code: "RoomPresetOwnsSky",
+      message: "The room preset provides the sky and the daylight; scene.environment is not used for this render."
+    });
+  }
+  if (spec.pictures?.some(Boolean)) {
+    note({
+      code: "RoomPresetPicturesReplaced",
+      message: `${spec.pictures.filter(Boolean).length} of the room's pictures are yours; each is cropped to fill the frame it hangs in, which does not move.`
+    });
+  }
+  return {
+    spec,
+    triangles: info?.triangles ?? 0,
+    assets: roomPresetAssetsOf(group)
+  };
+}
+function roomTriangles(room) {
+  return room && room.spec.standIn !== true ? room.triangles : 0;
+}
+function presetRoomTriangles(scene) {
+  const rooms = findPresetRooms(scene);
+  if (rooms.length !== 1) return 0;
+  const spec = roomPresetSpecOf(rooms[0]);
+  if (!spec) return 0;
+  return roomTriangles({
+    spec,
+    triangles: roomPresetFactsOf(rooms[0])?.triangles ?? 0
+  });
+}
+
+// src/capture/capture.ts
+async function captureScene(options) {
+  const { scene, camera } = options;
+  assertCaptureRuntime();
+  const color = captureColor(options.renderer);
+  const compatibility = analyzeScene(scene);
+  const fallbacks = collectFallbacks(scene);
+  const lights = captureLights(scene);
+  const runtime = captureRuntime(scene, options.productState);
+  const shaded = await captureShaders(scene);
+  for (const issue of shaded.issues) {
+    compatibility.issues.push(issue);
+    compatibility.counts[issue.severity]++;
+  }
+  const room = captureRoomPreset(scene, compatibility, {
+    environment: Boolean(scene.environment || options.environment)
+  });
+  const unstamp = stampIds(scene);
+  let glb;
+  try {
+    glb = await exportGLB(scene);
+  } finally {
+    unstamp();
+  }
+  const sceneAsset = await sha256(glb);
+  const assets = [
+    {
+      hash: sceneAsset,
+      kind: "scene",
+      bytes: glb.byteLength,
+      contentType: "model/gltf-binary",
+      name: "scene.glb",
+      data: glb
+    },
+    ...shaded.assets,
+    // A picture the developer hung in a preset room's frame: the one case
+    // where the room record names an asset the scene GLB does not carry.
+    ...(room?.assets ?? []).map((asset) => ({
+      hash: asset.hash,
+      kind: "texture",
+      bytes: asset.data.byteLength,
+      contentType: asset.contentType,
+      name: asset.name,
+      data: asset.data
+    }))
+  ];
+  const lit = await captureEnvironment(options, scene, assets, compatibility);
+  const { fog } = captureFog(scene);
+  const environment = fog ? { ...lit, fog } : lit;
+  const manifest = {
+    // A manifest is stamped with the lowest protocol version that can read
+    // it, so an older render worker is not refused a still it understands.
+    // `renderVideo()` re-stamps once it has added the animation; a preset
+    // room raises the version here, because a worker that ignored the room
+    // would render the product in a void. See `protocolVersionFor`.
+    // Fog raises it too: an older worker would leave the fog out.
+    protocolVersion: protocolVersionFor({
+      ...room ? { room: room.spec } : {},
+      ...environment ? { environment } : {}
+    }),
+    sdkVersion: SDK_VERSION,
+    sceneAsset,
+    ...assets.length > 1 ? { assets: assets.slice(1).map((asset) => asset.hash) } : {},
+    camera: captureCamera(camera),
+    ...Object.keys(runtime).length ? { runtime } : {},
+    ...environment ? { environment } : {},
+    ...lights.length ? { lights } : {},
+    color,
+    ...fallbacks.length ? { fallbacks } : {},
+    ...shaded.shaders.length ? { shaders: shaded.shaders } : {},
+    ...room ? { room: room.spec } : {},
+    compatibility: {
+      score: compatibility.score,
+      issues: compatibility.issues,
+      counts: compatibility.counts
+    },
+    // The control plane prices what it accepts with the same numbers
+    // estimate() was given (see SceneManifest.stats).
+    stats: {
+      // A preset room's geometry is built by the renderer, not uploaded, but
+      // it is traced all the same, so its published count is added. Unless
+      // the room shipped its stand-in: then the upload carries it and
+      // `compatibility` has already counted it.
+      triangles: compatibility.triangles + roomTriangles(room),
+      emitters: compatibility.emitters,
+      // How enclosed and how full the scene is, from the camera: what the
+      // quote reads to price an interior as one (capture/complexity.ts).
+      ...sceneComplexity(scene, camera)
+    },
+    source: {
+      three: threeVersion(),
+      renderer: options.renderer ? "WebGLRenderer" : void 0,
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+    }
+  };
+  return { manifest, assets };
+}
+function exportGLB(scene) {
+  const exporter = new GLTFExporter();
+  const reattach = detachExcluded(scene);
+  const unmute = muteLightWarnings();
+  return new Promise((resolve, reject) => {
+    exporter.parse(
+      scene,
+      (result) => {
+        if (!(result instanceof ArrayBuffer)) {
+          reject(
+            new Bakery3Error({
+              code: "CaptureFailed",
+              message: "The glTF exporter returned JSON instead of a binary GLB.",
+              why: "binary: true was set, so this should not happen. It usually means a patched or very old GLTFExporter.",
+              fix: "Update three, or file an issue at github.com/oeave/bakery3 with your three version."
+            })
+          );
+          return;
+        }
+        resolve(result);
+      },
+      (error) => reject(
+        new Bakery3Error({
+          code: "CaptureFailed",
+          message: `Could not export the scene: ${error instanceof Error ? error.message : String(error)}`,
+          why: "The glTF exporter walks the scene graph; a geometry with a malformed attribute or a texture from a tainted canvas will stop it.",
+          fix: "Run bakery3.check() to find the object it stopped on.",
+          docs: "https://bakery3.com/docs/troubleshooting#export"
+        })
+      ),
+      {
+        binary: true,
+        onlyVisible: false,
+        includeCustomExtensions: true
+      }
+    );
+  }).finally(() => {
+    unmute();
+    reattach();
+  });
+}
+var MUTED_EXPORTER_WARNINGS = [
+  "THREE.GLTFExporter: Only directional, point, and spot lights are supported.",
+  "THREE.GLTFExporter: Light direction may be lost.",
+  "THREE.GLTFExporter: Light decay may be lost."
+];
+var muted = 0;
+var mute = null;
+function muteLightWarnings() {
+  if (muted++ === 0) {
+    const original = console.warn;
+    const filter = function(...args) {
+      const first = args[0];
+      if (typeof first === "string" && MUTED_EXPORTER_WARNINGS.some((prefix) => first.startsWith(prefix)))
+        return;
+      original.apply(this, args);
+    };
+    mute = { original, filter };
+    console.warn = filter;
+  }
+  let done = false;
+  return () => {
+    if (done) return;
+    done = true;
+    if (--muted > 0 || !mute) return;
+    if (console.warn === mute.filter) console.warn = mute.original;
+    mute = null;
+  };
+}
+function assertCaptureRuntime() {
+  if (typeof globalThis.FileReader === "function")
+    return;
+  throw new Bakery3Error({
+    code: "CaptureFailed",
+    message: "render() captures a three.js scene in a browser. In Node, use @oeave/bakery3/node: renderBatch() renders models by URL.",
+    why: "The capture exports your live scene with three.js, which needs the browser's FileReader, and this runtime has none.",
+    fix: "Call render() from the page that shows the scene. From a server or a script, render .glb files by URL with `new Bakery3Server(key).renderBatch()` from '@oeave/bakery3/node'.",
+    docs: "https://bakery3.com/docs/catalog"
+  });
+}
+function detachExcluded(scene) {
+  const detached = [];
+  scene.traverse((object) => {
+    if (!object.parent || !shouldExclude(object)) return;
+    detached.push({
+      object,
+      parent: object.parent,
+      index: object.parent.children.indexOf(object)
+    });
+  });
+  for (const entry of detached) entry.parent.remove(entry.object);
+  return () => {
+    for (const entry of [...detached].reverse()) {
+      entry.object.parent = entry.parent;
+      entry.parent.children.splice(entry.index, 0, entry.object);
+    }
+  };
+}
+async function captureEnvironment(options, scene, assets, compatibility) {
+  const settings = captureEnvironmentSettings(scene);
+  const background = options.background ?? {
+    type: "transparent"
+  };
+  const explicit = options.environment;
+  const remembered = scene.environment ? environmentSourceFor(scene.environment) : void 0;
+  const source = explicit ?? remembered;
+  if (!source) {
+    if (scene.environment) {
+      compatibility.issues.push({
+        code: "environment_unavailable",
+        severity: "warning",
+        message: "The scene has an environment map, but its source pixels are not reachable from the SDK.",
+        docs: "https://bakery3.com/docs/environment"
+      });
+      compatibility.counts.warning++;
+    }
+    const ambient2 = capturedAmbient(scene);
+    return {
+      ...settings,
+      ...ambient2 ? { ambient: ambient2 } : {},
+      background
+    };
+  }
+  const preset = typeof source === "string" && (source.startsWith(PRESET_LIBRARY) || !explicit && scene.environment !== null && isPresetEnvironment(scene.environment));
+  const ambient = capturedAmbient(scene);
+  const fill = ambient ? { ambient } : {};
+  if (typeof source === "string" && preset) {
+    return { ...settings, ...fill, hdri: source, background };
+  }
+  const pixels = typeof source === "string" ? await fetchEnvironment(source) : source;
+  const hash = await sha256(pixels);
+  assets.push({
+    hash,
+    kind: "hdri",
+    bytes: pixels.byteLength,
+    contentType: "image/vnd.radiance",
+    name: "environment.hdr",
+    data: pixels
+  });
+  return { ...settings, ...fill, hdri: hash, background };
+}
+var PRESET_LIBRARY = "https://cdn.bakery3.com/presets/";
+async function fetchEnvironment(url) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (cause) {
+    throw environmentUnreachable(
+      url,
+      cause instanceof Error ? cause.message : String(cause)
+    );
+  }
+  if (!response.ok)
+    throw environmentUnreachable(
+      url,
+      `${response.status} ${response.statusText}`.trim()
+    );
+  return response.arrayBuffer();
+}
+function environmentUnreachable(url, detail) {
+  return new Bakery3Error({
+    code: "CaptureFailed",
+    message: `The environment at ${url} could not be fetched: ${detail}.`,
+    why: "An environment given by URL is downloaded in the page and uploaded with the scene, so the page has to be able to read it.",
+    fix: "Check the URL and its CORS headers, or pass the HDRI bytes as `environment` instead.",
+    docs: "https://bakery3.com/docs/environment"
+  });
+}
+function threeVersion() {
+  const three = globalThis.__THREE__;
+  return typeof three === "string" ? three : void 0;
+}
+function aspectOf(camera, renderer) {
+  return cameraAspect(camera) ?? rendererAspect(renderer) ?? 1;
+}
+function outputSize(given, longEdge, aspect, options = {}) {
+  const ratio = Number.isFinite(aspect) && aspect > 0 ? aspect : 1;
+  const round = options.even ? (value) => Math.max(2, Math.round(value / 2) * 2) : (value) => Math.max(1, Math.round(value));
+  const { width, height } = given;
+  if (width !== void 0 && height !== void 0) return { width, height };
+  if (width !== void 0) return { width, height: round(width / ratio) };
+  if (height !== void 0) return { width: round(height * ratio), height };
+  return ratio >= 1 ? { width: round(longEdge), height: round(longEdge / ratio) } : { width: round(longEdge * ratio), height: round(longEdge) };
+}
+function resolveOutput(call, defaults, context) {
+  const own = call.width !== void 0 || call.height !== void 0;
+  const given = own ? { width: call.width, height: call.height } : { width: defaults?.width, height: defaults?.height };
+  const size = outputSize(
+    {
+      ...given.width !== void 0 ? { width: given.width } : {},
+      ...given.height !== void 0 ? { height: given.height } : {}
+    },
+    QUALITY[context.quality].defaultLongEdge,
+    aspectOf(context.camera, context.renderer),
+    { even: context.even ?? false }
+  );
+  const quality = call.imageQuality ?? defaults?.quality;
+  return {
+    ...size,
+    format: call.format ?? defaults?.format ?? "png",
+    ...quality !== void 0 ? { quality } : {},
+    ...defaults?.opaque !== void 0 ? { opaque: defaults.opaque } : {}
+  };
+}
+function cameraAspect(camera) {
+  const view = camera;
+  if (!view) return void 0;
+  if (view.isPerspectiveCamera) return positive(view.aspect);
+  if (view.isOrthographicCamera)
+    return positive(
+      ((view.right ?? 0) - (view.left ?? 0)) / ((view.top ?? 0) - (view.bottom ?? 0))
+    );
+  return void 0;
+}
+function rendererAspect(renderer) {
+  const drawing = renderer;
+  if (!drawing || typeof drawing !== "object") return void 0;
+  if (typeof drawing.getDrawingBufferSize === "function") {
+    try {
+      const size = drawing.getDrawingBufferSize(new Vector2());
+      const aspect = positive(size.x / size.y);
+      if (aspect) return aspect;
+    } catch {
+    }
+  }
+  const canvas = drawing.domElement;
+  return canvas ? positive((canvas.width ?? 0) / (canvas.height ?? 0)) : void 0;
+}
+function positive(value) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+
+// src/capture/stats.ts
+function tracedTriangles(scene, uploaded = analyzeScene(scene).triangles) {
+  return uploaded + presetRoomTriangles(scene);
+}
+
+// src/bake/room.ts
+var ON_THE_STAND_METRES = 0.05;
+function presetRoomBake(scene, candidates, include) {
+  const rooms = findPresetRooms(scene);
+  if (rooms.length === 0) return null;
+  if (rooms.length > 1) {
+    return {
+      refused: {
+        code: "BakeManyRooms",
+        message: `The scene has ${rooms.length} preset rooms in it, and a prebaked room has to be the only one.`
+      }
+    };
+  }
+  const group = rooms[0];
+  const room = roomPresetSpecOf(group);
+  if (!room) return null;
+  if (!roomIsPrebaked(room.name, room.lighting)) {
+    return {
+      refused: {
+        code: "BakeRoomNotPrebaked",
+        message: `There are no prebaked lightmaps for ${room.name} under ${room.lighting} light, so this bake covers the room itself.`
+      }
+    };
+  }
+  const changed = roomPrebakeChanges(room);
+  if (changed.length) {
+    return {
+      refused: {
+        code: "BakeRoomModified",
+        message: `This room has ${changed.join(" and ")} changed, so its light is not the light we baked.`
+      }
+    };
+  }
+  const mine = candidates.filter(
+    (candidate) => include.includes(candidate.objectId) && !isUnder(candidate.object, group)
+  );
+  if (!mine.length) {
+    return {
+      refused: {
+        code: "BakeRoomOnly",
+        message: "Everything this bake covers belongs to the room, so there is nothing a prebaked one would not already have."
+      }
+    };
+  }
+  const stand = group.getObjectByName("stand");
+  const standIds = stand ? standsUnder(candidates, stand, mine) : [];
+  const mineIds = mine.map((candidate) => candidate.objectId);
+  return {
+    ok: {
+      room,
+      group,
+      standIds,
+      castIds: mineIds,
+      spanIds: [...mineIds, ...standIds]
+    }
+  };
+}
+function standsUnder(candidates, stand, mine) {
+  const top = boundsOf(stand)?.high;
+  if (top === void 0) return [];
+  const lowest = Math.min(
+    ...mine.map((candidate) => boundsOf(candidate.object)?.low ?? Infinity)
+  );
+  if (!Number.isFinite(lowest) || Math.abs(lowest - top) > ON_THE_STAND_METRES)
+    return [];
+  const ids = [];
+  for (const candidate of candidates) {
+    if (candidate.bakeable && isUnder(candidate.object, stand))
+      ids.push(candidate.objectId);
+  }
+  return ids;
+}
+function boundsOf(object) {
+  object.updateWorldMatrix(true, true);
+  let low = Infinity;
+  let high = -Infinity;
+  object.traverse((node) => {
+    const mesh = node;
+    if (!mesh.isMesh || !mesh.geometry) return;
+    if (!mesh.geometry.boundingBox) mesh.geometry.computeBoundingBox();
+    const box = mesh.geometry.boundingBox;
+    if (!box) return;
+    const matrix = node.matrixWorld.elements;
+    const scale = matrix[5] ?? 1;
+    const offset = matrix[13] ?? 0;
+    low = Math.min(low, box.min.y * scale + offset);
+    high = Math.max(high, box.max.y * scale + offset);
+  });
+  return Number.isFinite(low) ? { low, high } : void 0;
+}
+function isUnder(object, root) {
+  for (let node = object; node; node = node.parent)
+    if (node === root) return true;
+  return false;
+}
+
+// src/bake/prepare.ts
+function planBake(scene, camera, settings = {}) {
+  const quality = settings.quality ?? "standard";
+  const textureSize = settings.textureSize ?? 1024;
+  const candidates = bakeCandidates({ scene });
+  let include = resolveInclude(candidates, settings);
+  let preset;
+  if (settings.room !== "full") {
+    const verdict = presetRoomBake(scene, candidates, include);
+    if (verdict && "ok" in verdict) {
+      preset = verdict.ok;
+      const keep = /* @__PURE__ */ new Set([...preset.spanIds]);
+      include = include.filter((id) => keep.has(id));
+    }
+  }
+  const standIns = resolveSimplify(scene, candidates, settings);
+  const covered = new Set(include);
+  standIns.entries = standIns.entries.filter(
+    (entry) => entry.objects.some((id) => covered.has(id))
+  );
+  const replaced = new Set(standIns.entries.flatMap((entry) => entry.objects));
+  include = include.filter((id) => !replaced.has(id));
+  if (!include.length && !standIns.entries.length) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: "There is nothing to bake.",
+      why: candidates.length ? "Every mesh in the scene is either unbakeable or excluded. Instanced and skinned meshes cannot take a lightmap, and glass is off by default." : "The scene has no meshes.",
+      fix: "Tick at least one object in the bake panel, or pass { settings: { include: [objectId] } }.",
+      docs: "https://bakery3.com/docs/bake"
+    });
+  }
+  if (include.length > MAX_BAKE_OBJECTS) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `A bake can cover ${MAX_BAKE_OBJECTS} objects; this one asks for ${include.length}.`,
+      why: "Past that the scene wants a shared atlas, which this version does not build. Sampling the list down for you would quietly leave objects unlit.",
+      fix: "Bake the hero objects, or merge small props into fewer meshes.",
+      docs: "https://bakery3.com/docs/bake"
+    });
+  }
+  const atlas = resolveAtlas(settings.atlas);
+  const texels = standIns.entries.reduce(
+    (total, entry) => total + (entry.textureSize ?? textureSize) ** 2,
+    0
+  ) + (atlas ? atlas.size * atlas.size : include.reduce((total, id) => {
+    const size = settings.sizes?.[id] ?? textureSize;
+    return total + size * size;
+  }, 0));
+  if (texels > MAX_BAKE_TEXELS) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `This bake asks for ${(texels / 1e6).toFixed(1)}M texels; the ceiling is ${(MAX_BAKE_TEXELS / 1e6).toFixed(0)}M.`,
+      why: `${include.length} objects \xD7 ${textureSize}\xB2 = ${(texels / 1e6).toFixed(1)}M texels, and texels are what a bake costs the way frames are what a video costs.`,
+      fix: "Lower the texture size, or bake fewer objects at a time.",
+      docs: "https://bakery3.com/docs/bake"
+    });
+  }
+  const view = camera ? resolveView(settings.view ?? "camera", camera, candidates, include) : void 0;
+  const probe = resolveProbe(candidates, include);
+  const bake = {
+    quality,
+    textureSize,
+    include,
+    ...settings.sizes ? { sizes: settings.sizes } : {},
+    ...atlas ? { atlas } : {},
+    ...settings.margin !== void 0 ? { margin: settings.margin } : {},
+    ...settings.deliverGlb ? { deliverGlb: true } : {},
+    ...view ? { view } : {},
+    probe,
+    ...standIns.entries.length ? { simplify: standIns.entries } : {},
+    // This SDK can apply a lightmap to a uv set the mesh already has, so the
+    // render worker may keep an object's own layout rather than unwrap it;
+    // these are the objects whose `uv1` is your own (a lightmap uv you
+    // exported) rather than one a bake applied here wrote.
+    existingUv: { uv1: developerUv1(candidates, include) },
+    ...preset ? {
+      room: "preset",
+      // The plane is placed and sized by the render worker, which sees what
+      // the objects stand on; all it is told is whose shadow it is and
+      // what it has to clear. The stand is in the second list and not
+      // the first: the prebaked floor already has its shadow.
+      shadow: { cast: preset.castIds, spans: preset.spanIds }
+    } : {}
+  };
+  return {
+    bake,
+    // For the quote, not for the cache: see `bakedTriangles` in the protocol.
+    bakedTriangles: countTriangles(candidates, include),
+    candidates,
+    ...preset ? { preset } : {},
+    shapes: standIns.shapes
+  };
+}
+function stageBake(plan, scene) {
+  const restore = plan.shapes.map((shape) => {
+    const parent = shape.parent;
+    const visible = shape.visible;
+    if (!isUnder2(shape, scene)) scene.add(shape);
+    shape.visible = false;
+    return () => {
+      shape.visible = visible;
+      if (parent !== shape.parent) {
+        if (parent) parent.add(shape);
+        else shape.removeFromParent();
+      }
+    };
+  });
+  if (plan.preset)
+    restore.push(...holdRoomBack(plan.preset, plan.bake.include));
+  return () => {
+    for (const undo of restore) undo();
+  };
+}
+function bakeQuoteRequest(bake, facts) {
+  return {
+    bake: {
+      quality: bake.quality,
+      textureSize: bake.textureSize,
+      include: bake.include,
+      ...bake.sizes ? { sizes: bake.sizes } : {},
+      ...bake.atlas ? { atlas: bake.atlas } : {},
+      ...bake.deliverGlb ? { deliverGlb: true } : {},
+      ...bake.simplify ? { simplify: bake.simplify } : {},
+      // The shadow plane: two traces of its own.
+      ...bake.shadow ? { shadow: bake.shadow } : {},
+      // Inside a room a ray that misses keeps going, which is most of
+      // what one of these bakes costs.
+      ...facts.enclosed ? { enclosed: true } : {}
+    },
+    scene: { triangles: facts.triangles },
+    bakedTriangles: facts.bakedTriangles
+  };
+}
+function bakeQuoteOf(spec) {
+  return bakeQuoteRequest(spec.bake, {
+    triangles: spec.manifest.stats?.triangles ?? 0,
+    bakedTriangles: spec.bakedTriangles ?? 0,
+    enclosed: Boolean(spec.manifest.room)
+  });
+}
+function quoteBake(scene, camera, settings = {}) {
+  const plan = planBake(scene, camera, settings);
+  const undo = stageBake(plan, scene);
+  let triangles;
+  try {
+    triangles = tracedTriangles(scene);
+  } finally {
+    undo();
+  }
+  return bakeQuoteRequest(plan.bake, {
+    triangles,
+    bakedTriangles: plan.bakedTriangles,
+    enclosed: findPresetRooms(scene).length > 0
+  });
+}
+async function prepareBake(options) {
+  const plan = planBake(options.scene, options.camera, options.settings ?? {});
+  const undo = stageBake(plan, options.scene);
+  let captured;
+  try {
+    captured = await captureScene({
+      scene: options.scene,
+      camera: options.camera,
+      ...options.renderer !== void 0 ? { renderer: options.renderer } : {},
+      ...options.environment !== void 0 ? { environment: options.environment } : {},
+      ...options.productState !== void 0 ? { productState: options.productState } : {},
+      ...options.background !== void 0 ? { background: options.background } : {}
+    });
+  } finally {
+    undo();
+  }
+  const { manifest, assets } = captured;
+  const spec = {
+    manifest,
+    bake: plan.bake,
+    bakedTriangles: plan.bakedTriangles,
+    ...options.maxCost !== void 0 ? { maxCost: options.maxCost } : {},
+    ...options.metadata ? { metadata: options.metadata } : {},
+    ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
+  };
+  const preset = plan.preset;
+  return {
+    spec,
+    assets,
+    candidates: plan.candidates,
+    ...preset ? {
+      presetRoom: {
+        name: preset.room.name,
+        lighting: preset.room.lighting,
+        build: preset.room.build
+      }
+    } : {}
+  };
+}
+function holdRoomBack(preset, include) {
+  const undo = [];
+  const state = preset.group.userData?.bakery3Preset?.roomPreset;
+  if (!state?.standIn) return undo;
+  const shipping = new Set(
+    include.filter((id) => preset.standIds.includes(id))
+  );
+  const stand = preset.group.getObjectByName("stand");
+  preset.group.traverse((object) => {
+    if (!object.isMesh) return;
+    if (stand && isUnder2(object, stand) && shipping.has(idOf(object))) return;
+    const before = object.userData.bakery3;
+    object.userData.bakery3 = { ...before ?? {}, exclude: true };
+    undo.push(() => {
+      if (before === void 0) delete object.userData.bakery3;
+      else object.userData.bakery3 = before;
+    });
+  });
+  const was = state.standIn;
+  state.standIn = shipping.size ? "stand" : void 0;
+  undo.push(() => {
+    state.standIn = was;
+  });
+  return undo;
+}
+function developerUv1(candidates, include) {
+  const wanted = new Set(include);
+  return candidates.filter((candidate) => {
+    if (!wanted.has(candidate.objectId)) return false;
+    const uv1 = candidate.object.geometry?.getAttribute("uv1");
+    return Boolean(uv1) && !isBakeWrittenUv(uv1);
+  }).map((candidate) => candidate.objectId);
+}
+function countTriangles(candidates, include) {
+  const wanted = new Set(include);
+  let total = 0;
+  for (const candidate of candidates) {
+    if (!wanted.has(candidate.objectId)) continue;
+    const geometry = candidate.object.geometry;
+    const count = geometry?.index?.count ?? geometry?.attributes?.position?.count ?? 0;
+    total += Math.floor(count / 3);
+  }
+  return total;
+}
+function isUnder2(object, root) {
+  for (let node = object; node; node = node.parent)
+    if (node === root) return true;
+  return false;
+}
+function mergeGroups(inputs, docs) {
+  const out = [];
+  const at = /* @__PURE__ */ new Map();
+  for (const input of inputs) {
+    if (!input.group) {
+      out.push(input);
+      continue;
+    }
+    const index = at.get(input.group);
+    if (index === void 0) {
+      at.set(input.group, out.length);
+      out.push({
+        ...input,
+        objects: [
+          ...Array.isArray(input.objects) ? input.objects : [input.objects]
+        ]
+      });
+      continue;
+    }
+    const first = out[index];
+    const differs = (input.to ?? "lowpoly") !== (first.to ?? "lowpoly") || input.triangles !== first.triangles || input.textureSize !== first.textureSize;
+    if (differs) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `The stand-ins grouped as "${input.group}" do not ask for the same thing.`,
+        why: "A group is one stand-in, so it can only be built one way.",
+        fix: "Give them the same `to`, `triangles` and `textureSize`, or take them out of the group.",
+        docs
+      });
+    }
+    first.objects.push(
+      ...Array.isArray(input.objects) ? input.objects : [input.objects]
+    );
+  }
+  return out;
+}
+function resolveSimplify(scene, candidates, settings) {
+  const docs = "https://bakery3.com/docs/bake#simplify";
+  const inputs = [...settings.simplify ?? []];
+  scene.traverse((object) => {
+    const declared = object.userData?.bakery3?.simplify;
+    if (declared === void 0 || declared === null) return;
+    const options = typeof declared === "object" && !declared.isMesh ? declared : { to: declared };
+    inputs.push({ ...options, objects: object });
+  });
+  if (!inputs.length) return { entries: [], shapes: [] };
+  const merged = mergeGroups(inputs, docs);
+  if (merged.length > MAX_BAKE_SIMPLIFY) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `A bake can build ${MAX_BAKE_SIMPLIFY} stand-ins; this one asks for ${merged.length}.`,
+      why: "Each stand-in is three traced passes of its own.",
+      fix: "Group more objects under each entry: one stand-in can replace a whole shelf of them.",
+      docs
+    });
+  }
+  const byId = new Map(
+    candidates.map((candidate) => [candidate.objectId, candidate])
+  );
+  const claimed = /* @__PURE__ */ new Map();
+  const shapes = [];
+  const entries = merged.map((input, n) => {
+    const shape = typeof input.to === "object" && input.to !== null ? input.to : void 0;
+    const shapeId = shape ? idOf(shape) : void 0;
+    const ids = [];
+    for (const target of Array.isArray(input.objects) ? input.objects : [input.objects]) {
+      if (typeof target === "string") {
+        if (!byId.has(target)) {
+          throw new Bakery3Error({
+            code: "InvalidRequest",
+            message: `simplify[${n}] names "${target}", which is not a mesh in this scene.`,
+            why: "Ids are matched against userData.bakery3Id, falling back to the object uuid, which three mints anew on every reload.",
+            fix: "Pass the object itself, or take the id from candidates().",
+            docs
+          });
+        }
+        ids.push(target);
+        continue;
+      }
+      for (const candidate of candidates) {
+        if (candidate.objectId !== shapeId && isUnder2(candidate.object, target))
+          ids.push(candidate.objectId);
+      }
+    }
+    const objects = [...new Set(ids)];
+    if (!objects.length) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `simplify[${n}] replaces nothing: there is no mesh under what it names.`,
+        why: "A stand-in is made from the meshes it replaces.",
+        fix: "Pass a mesh, or a group with meshes under it.",
+        docs
+      });
+    }
+    for (const id of objects) {
+      const other = claimed.get(id);
+      if (other !== void 0) {
+        throw new Bakery3Error({
+          code: "InvalidRequest",
+          message: `"${byId.get(id)?.name ?? id}" is claimed by simplify[${other}] and simplify[${n}].`,
+          why: "An object is replaced by one stand-in. A group and something inside it were probably both named.",
+          fix: "Name the group or its parts, not both.",
+          docs
+        });
+      }
+      claimed.set(id, n);
+    }
+    if (input.textureSize !== void 0 && !BAKE_TEXTURE_SIZES.includes(input.textureSize)) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `simplify[${n}].textureSize must be one of ${BAKE_TEXTURE_SIZES.join(", ")}; got ${String(input.textureSize)}.`,
+        fix: "Leave it out to use the bake's textureSize.",
+        docs
+      });
+    }
+    if (input.triangles !== void 0 && !(Number.isInteger(input.triangles) && input.triangles >= 12 && input.triangles <= MAX_BAKE_SIMPLIFY_TRIANGLES)) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `simplify[${n}].triangles must be a whole number from 12 to ${MAX_BAKE_SIMPLIFY_TRIANGLES}; got ${String(input.triangles)}.`,
+        fix: "A few hundred is a piece of furniture across a room; a few thousand holds up close.",
+        docs
+      });
+    }
+    if (shape) {
+      if (!shape.isMesh || !shape.geometry) {
+        throw new Bakery3Error({
+          code: "InvalidRequest",
+          message: `simplify[${n}].to must be 'lowpoly', 'box', 'billboard', 'decimate' or a Mesh.`,
+          fix: "Pass a THREE.Mesh whose geometry is the low-poly shape, placed where the objects are.",
+          docs
+        });
+      }
+      shapes.push(shape);
+    }
+    return {
+      objects,
+      to: shape ? { objectId: shapeId } : input.to ?? "lowpoly",
+      ...input.triangles !== void 0 ? { triangles: input.triangles } : {},
+      ...input.textureSize !== void 0 ? { textureSize: input.textureSize } : {}
+    };
+  });
+  const expanded = entries.flatMap(
+    (entry) => entry.to === "decimate" && entry.objects.length > 1 ? entry.objects.map((id) => ({ ...entry, objects: [id] })) : [entry]
+  );
+  if (expanded.length > MAX_BAKE_SIMPLIFY) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `A bake can build ${MAX_BAKE_SIMPLIFY} stand-ins; decimating every object named here asks for ${expanded.length}.`,
+      why: "Each decimated object is a stand-in of its own.",
+      fix: "Decimate the objects that are heavy and leave the rest as they are.",
+      docs
+    });
+  }
+  return { entries: expanded, shapes };
+}
+function resolveView(setting, camera, candidates, include) {
+  if (setting === "none") return void 0;
+  if (setting !== "camera") {
+    const position = setting.position;
+    if (!Array.isArray(position) || position.length !== 3 || position.some(
+      (value) => typeof value !== "number" || !Number.isFinite(value)
+    )) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: "settings.view.position must be three finite numbers.",
+        why: "The render worker places UV seams on the side of each object that faces away from this point, so it has to be a point.",
+        fix: "Pass { view: { position: [x, y, z] } } in scene units, 'camera' to derive it from the camera, or 'none'.",
+        docs: "https://bakery3.com/docs/bake#seams"
+      });
+    }
+    return { position: [position[0], position[1], position[2]] };
+  }
+  if (typeof camera.getWorldPosition !== "function")
+    return void 0;
+  const wanted = new Set(include);
+  const objects = candidates.filter((candidate) => wanted.has(candidate.objectId)).map((candidate) => candidate.object);
+  return quantizeBakeView(camera, bakeBounds(objects));
+}
+function resolveAtlas(setting) {
+  if (!setting) return void 0;
+  const atlas = setting === true ? { size: 2048 } : { ...setting };
+  if (!BAKE_ATLAS_SIZES.includes(atlas.size)) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `settings.atlas.size must be one of ${BAKE_ATLAS_SIZES.join(", ")}; got ${String(atlas.size)}.`,
+      why: "The atlas is one texture shared by every baked object, and its side is what the whole bake costs in texels.",
+      fix: "Pass atlas: true for 2048\xB2, or { size: 4096 } for a large room.",
+      docs: "https://bakery3.com/docs/bake#one-map-for-the-room"
+    });
+  }
+  for (const [id, weight] of Object.entries(atlas.weights ?? {})) {
+    if (typeof weight !== "number" || !Number.isFinite(weight) || weight <= 0) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `settings.atlas.weights["${id}"] must be a positive number; got ${String(weight)}.`,
+        why: "A weight multiplies the texel density an object gets in the shared map; zero or less would leave it with no texels at all.",
+        fix: "Use 1 for an ordinary object and 4 for the hero product (weights round to a power of two in side).",
+        docs: "https://bakery3.com/docs/bake#one-map-for-the-room"
+      });
+    }
+  }
+  return atlas;
+}
+function resolveInclude(candidates, settings) {
+  const byId = new Map(
+    candidates.map((candidate) => [candidate.objectId, candidate])
+  );
+  const excluded = new Set(settings.exclude ?? []);
+  if (!settings.include) {
+    return defaultIncludeIds(candidates).filter((id) => !excluded.has(id));
+  }
+  const resolved = [];
+  for (const id of settings.include) {
+    if (excluded.has(id)) continue;
+    const candidate = byId.get(id);
+    if (!candidate) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `Asked to bake "${id}", which is not a mesh in this scene.`,
+        why: "The include list is matched against userData.bakery3Id, falling back to the object uuid. three mints a new uuid on every reload, so an id saved from a previous session will not match.",
+        fix: "Set userData.bakery3Id on the objects you bake so their ids survive a reload, or take the ids from candidates().",
+        docs: "https://bakery3.com/docs/bake"
+      });
+    }
+    if (!candidate.bakeable) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: candidate.reason?.message ?? `"${candidate.name}" cannot take a lightmap.`,
+        ...candidate.reason?.why ? { why: candidate.reason.why } : {},
+        ...candidate.reason?.fix ? { fix: candidate.reason.fix } : {},
+        path: candidate.path,
+        docs: "https://bakery3.com/docs/bake"
+      });
+    }
+    if (!resolved.includes(id)) resolved.push(id);
+  }
+  return resolved;
+}
+
+export { OBJECT_PROPERTIES, Timeline, analyzeScene, aspectOf, bakeQuoteOf, bindTimelineContext, captureScene, createTimeline, extractMaterialShader, isNodeMaterial, linearToSrgbHex, outputSize, prepareBake, quoteBake, resolveOutput, sceneComplexity, timelineFromGsap, timelineFromTheatre, tracedTriangles };
+//# sourceMappingURL=chunk-CX4WTVGH.js.map
+//# sourceMappingURL=chunk-CX4WTVGH.js.map