@cueframe/kernel 0.2.2 → 0.2.4

package/dist/chunk-MH3UPKWR.js

@@ -0,0 +1,3415 @@
+import {
+  SCENE_CONTEXT_GL_BUDGET_BYTES,
+  SCENE_MAX_TRIANGLES,
+  SCENE_SURFACE_TEXTURE_BUDGET_BYTES
+} from "./chunk-2L7PYYJK.js";
+
+// ../composition/src/scene/schema.ts
+import { z } from "zod";
+var SCENE_SHOT_SPEC_VERSION = 2;
+var SCENE_MAX_LAYERS = 32;
+var SCENE_MAX_GROUP_DEPTH = 4;
+var SCENE_MAX_KEYFRAMES_PER_CHANNEL = 256;
+var SCENE_MAX_KEYFRAMES_PER_SHOT = 2048;
+var SCENE_MAX_SURFACES = 32;
+var SCENE_FOV_MIN = Math.PI / 10;
+var SCENE_FOV_MAX = 4 * Math.PI / 9;
+var SCENE_LAYER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var SCENE_ASSET_SLOT_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+var SCENE_BRAND_COLOR_TOKENS = [
+  "background",
+  "surface",
+  "text",
+  "textMuted",
+  "accent",
+  "accentStrong",
+  "accentSoft",
+  "success",
+  "warning",
+  "danger"
+];
+var SCENE_BRAND_FONT_TOKENS = ["heading", "body", "caption"];
+var COLOR_REFERENCE_VALUES = SCENE_BRAND_COLOR_TOKENS.map(
+  (token) => `$brand:colors.${token}`
+);
+var FONT_REFERENCE_VALUES = SCENE_BRAND_FONT_TOKENS.map(
+  (token) => `$brand:fonts.${token}`
+);
+var SceneHexColor = z.string().regex(/^#(?:[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, "Expected #rrggbb or #rrggbbaa.");
+var SceneBrandColorRef = z.enum(COLOR_REFERENCE_VALUES);
+var SceneColor = z.union([SceneHexColor, SceneBrandColorRef]);
+var SceneBrandFontRef = z.enum(FONT_REFERENCE_VALUES);
+var SCENE_FONT_FAMILY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 _.\-]*$/;
+var SceneAdmittedFontFamily = z.string().min(1).max(128).regex(SCENE_FONT_FAMILY_PATTERN);
+var SceneFontFamily = z.union([SceneAdmittedFontFamily, SceneBrandFontRef]);
+var SceneLayerId = z.string().min(1).max(64).regex(SCENE_LAYER_ID_PATTERN);
+var SceneAssetSlot = z.string().min(1).max(64).regex(
+  SCENE_ASSET_SLOT_PATTERN,
+  'Expected a slot name: a letter or underscore followed by letters, digits, "_" or "-".'
+).describe("Image asset slot name bound by the clip assets map; never a URL.");
+var SceneUnit = z.number().min(0).max(1);
+var SceneVec3Schema = z.tuple([z.number(), z.number(), z.number()]);
+var JsonValueSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema)
+  ])
+);
+var SceneReferenceSizeV2 = z.object({
+  width: z.number().int().min(16).max(8192),
+  height: z.number().int().min(16).max(8192)
+}).strict();
+var SceneCameraInputV2 = z.object({
+  position: SceneVec3Schema.optional(),
+  rotation: SceneVec3Schema.optional(),
+  fov: z.number().min(SCENE_FOV_MIN).max(SCENE_FOV_MAX).optional()
+}).strict();
+var SceneCameraV2 = z.object({
+  position: SceneVec3Schema,
+  rotation: SceneVec3Schema,
+  fov: z.number().min(SCENE_FOV_MIN).max(SCENE_FOV_MAX)
+}).strict();
+var SceneTransformV2 = z.object({
+  position: SceneVec3Schema.default([0, 0, 0]),
+  rotation: SceneVec3Schema.default([0, 0, 0]),
+  scale: z.number().positive().default(1)
+}).strict().default({ position: [0, 0, 0], rotation: [0, 0, 0], scale: 1 });
+var SceneGradientStopV2 = z.object({ at: SceneUnit, color: SceneColor }).strict();
+var SceneGradientStopsV2 = z.array(SceneGradientStopV2).min(2).max(8).superRefine((stops, ctx) => {
+  for (let index = 1; index < stops.length; index += 1) {
+    if (stops[index].at <= stops[index - 1].at) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "at"],
+        message: "Gradient stops must be strictly increasing."
+      });
+    }
+  }
+});
+var SceneBackdropV2 = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("transparent") }).strict(),
+  z.object({ kind: z.literal("solid"), color: SceneColor }).strict(),
+  z.object({
+    kind: z.literal("linear"),
+    angle: z.number().default(0),
+    stops: SceneGradientStopsV2
+  }).strict(),
+  z.object({
+    kind: z.literal("radial"),
+    at: z.tuple([SceneUnit, SceneUnit]).default([0.5, 0.5]),
+    stops: SceneGradientStopsV2
+  }).strict()
+]);
+var SceneImageSurfaceV2 = z.object({ source: z.literal("image"), assetSlot: SceneAssetSlot }).strict();
+var SceneColorSurfaceV2 = z.object({ source: z.literal("color"), color: SceneColor }).strict();
+var SceneComponentSurfaceV2 = z.object({
+  source: z.literal("component"),
+  component: z.object({
+    version: z.literal(1),
+    componentId: z.string().min(1).max(256),
+    sourceVersionId: z.string().regex(/^[a-f0-9]{64}$/)
+  }).strict(),
+  captureFrame: z.number().int().min(0),
+  layout: z.object({
+    width: z.number().int().positive(),
+    height: z.number().int().positive()
+  }).strict(),
+  bakeScale: z.union([z.literal(2), z.literal(3)]).optional().describe("Optional authored scale. Preparation defaults omission to 2 and may auto-raise it to 3."),
+  params: z.record(z.string(), JsonValueSchema).optional()
+}).strict();
+var SceneVideoSurfaceV2 = z.object({
+  source: z.literal("video"),
+  mediaId: z.string().min(1).max(256),
+  startFrame: z.number().int().min(0).default(0),
+  endFrame: z.number().int().positive().optional()
+}).strict().superRefine((surface, ctx) => {
+  if (surface.endFrame !== void 0 && surface.endFrame <= surface.startFrame) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["endFrame"],
+      message: "endFrame must be greater than startFrame (the exclusive source-frame trim)."
+    });
+  }
+});
+var SceneSurfaceBindingV2 = z.discriminatedUnion("source", [
+  SceneImageSurfaceV2,
+  SceneColorSurfaceV2,
+  SceneComponentSurfaceV2,
+  SceneVideoSurfaceV2
+]);
+var PHYSICAL_ONLY_FIELDS = [
+  "roughness",
+  "metalness",
+  "clearcoat",
+  "clearcoatRoughness",
+  "anisotropy",
+  "anisotropyRotation",
+  "ior",
+  "reflectivity"
+];
+var SceneMaterialOverrideV2 = z.object({
+  role: z.string().min(1).max(64),
+  type: z.enum(["physical", "unlit"]),
+  color: SceneColor.optional(),
+  roughness: SceneUnit.optional(),
+  metalness: SceneUnit.optional(),
+  clearcoat: SceneUnit.optional(),
+  clearcoatRoughness: SceneUnit.optional(),
+  anisotropy: SceneUnit.optional(),
+  anisotropyRotation: z.number().optional(),
+  ior: z.number().min(1).max(2.333).optional(),
+  reflectivity: SceneUnit.optional()
+}).strict().superRefine((material, ctx) => {
+  if (material.type !== "unlit") return;
+  for (const field of PHYSICAL_ONLY_FIELDS) {
+    if (material[field] !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [field],
+        message: `${field} is physical-only and cannot be set on an unlit material.`
+      });
+    }
+  }
+});
+var OptionalMaterials = z.array(SceneMaterialOverrideV2).max(16).optional();
+var OptionalSurfaces = z.record(z.string(), SceneSurfaceBindingV2).optional();
+var SceneTextRunV2 = z.object({
+  text: z.string().min(1).max(512).regex(/^[^\r\n]+$/, "A run may not contain a line break."),
+  color: SceneColor.optional(),
+  emphasis: z.boolean().optional()
+}).strict();
+var SceneTextLineV2 = z.object({ runs: z.array(SceneTextRunV2).min(1).max(16) }).strict();
+var textFields = {
+  id: SceneLayerId,
+  kind: z.literal("text"),
+  opacity: SceneUnit.default(1),
+  lines: z.array(SceneTextLineV2).min(1).max(24),
+  fontFamily: SceneFontFamily,
+  fontWeight: z.number().int().min(100).max(900),
+  fontStyle: z.enum(["normal", "italic"]),
+  fontSize: z.number().min(8).max(800),
+  lineHeight: z.number().min(0.6).max(3).default(1.2),
+  letterSpacing: z.number().min(-20).max(40).default(0),
+  align: z.enum(["left", "center", "right"]).default("center"),
+  maxWidth: z.number().positive().optional(),
+  color: SceneColor
+};
+var SceneGroupV2 = z.lazy(
+  () => z.object({
+    kind: z.literal("group"),
+    id: SceneLayerId,
+    transform: SceneTransformV2,
+    opacity: SceneUnit.default(1),
+    children: z.array(SceneObjectV2).min(1).max(16)
+  }).strict()
+);
+var SceneLaptopV2 = z.object({
+  kind: z.literal("laptop"),
+  id: SceneLayerId,
+  transform: SceneTransformV2,
+  opacity: SceneUnit.default(1),
+  width: z.number().min(200).max(4e3),
+  openAngle: z.number().min(0).max(Math.PI),
+  materials: OptionalMaterials,
+  surfaces: OptionalSurfaces
+}).strict();
+var ScenePhoneV2 = z.object({
+  kind: z.literal("phone"),
+  id: SceneLayerId,
+  transform: SceneTransformV2,
+  opacity: SceneUnit.default(1),
+  width: z.number().min(80).max(2e3),
+  materials: OptionalMaterials,
+  surfaces: OptionalSurfaces
+}).strict();
+var SceneSlabV2 = z.object({
+  kind: z.literal("slab"),
+  id: SceneLayerId,
+  transform: SceneTransformV2,
+  opacity: SceneUnit.default(1),
+  width: z.number().min(40).max(8e3),
+  height: z.number().min(40).max(8e3),
+  thickness: z.number().min(4).max(200).default(32),
+  cornerRadius: z.number().min(0).default(32),
+  edgeRadius: z.number().min(0).default(15),
+  finish: z.enum(["satin", "brushed"]).default("satin"),
+  materials: OptionalMaterials,
+  surfaces: OptionalSurfaces
+}).strict().superRefine((slab, ctx) => {
+  if (slab.cornerRadius > Math.min(slab.width, slab.height) / 2) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["cornerRadius"],
+      message: "cornerRadius cannot exceed half the shorter face side."
+    });
+  }
+  if (slab.edgeRadius > slab.thickness / 2) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["edgeRadius"],
+      message: "edgeRadius cannot exceed thickness/2."
+    });
+  }
+});
+var ScenePageV2 = z.object({
+  kind: z.literal("page"),
+  id: SceneLayerId,
+  transform: SceneTransformV2,
+  opacity: SceneUnit.default(1),
+  width: z.number().min(40).max(8e3),
+  height: z.number().min(40).max(8e3),
+  fit: z.enum(["contain", "cover"]).default("contain"),
+  transparency: z.enum(["straight", "premultiplied", "opaque"]).default("straight"),
+  depthWrite: z.boolean().default(true),
+  backface: z.enum(["hidden", "visible"]).default("hidden"),
+  materials: OptionalMaterials,
+  surfaces: z.record(z.string(), SceneSurfaceBindingV2)
+}).strict();
+var SceneWorldTextV2 = z.object({ ...textFields, space: z.literal("world"), transform: SceneTransformV2 }).strict();
+var SceneScreenTextV2 = z.object({
+  ...textFields,
+  space: z.literal("screen"),
+  x: z.number(),
+  y: z.number(),
+  rotation: z.number().default(0),
+  scale: z.number().positive().default(1)
+}).strict();
+var SceneObjectV2 = z.lazy(
+  () => z.union([
+    SceneGroupV2,
+    SceneLaptopV2,
+    ScenePhoneV2,
+    SceneSlabV2,
+    ScenePageV2,
+    SceneWorldTextV2,
+    SceneScreenTextV2
+  ])
+);
+var SceneEasingV2 = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("linear") }).strict(),
+  z.object({ kind: z.literal("hold") }).strict(),
+  z.object({
+    kind: z.literal("bezier"),
+    x1: SceneUnit,
+    y1: z.number().min(-4).max(5),
+    x2: SceneUnit,
+    y2: z.number().min(-4).max(5)
+  }).strict()
+]);
+var SceneKeyframeV2 = z.object({ at: SceneUnit, value: z.number(), easing: SceneEasingV2.optional() }).strict();
+var SceneKeyframesV2 = z.array(SceneKeyframeV2).min(1).max(SCENE_MAX_KEYFRAMES_PER_CHANNEL).superRefine((keyframes, ctx) => {
+  if (keyframes[0]?.easing !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: [0, "easing"],
+      message: "The first keyframe has no arriving segment; easing is not authorable here."
+    });
+  }
+  for (let index = 1; index < keyframes.length; index += 1) {
+    if (keyframes[index].at <= keyframes[index - 1].at) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "at"],
+        message: "Keyframe times must be strictly increasing."
+      });
+    }
+  }
+});
+var SceneChannelTargetV2 = z.discriminatedUnion(
+  "kind",
+  [
+    z.object({ kind: z.literal("camera") }).strict(),
+    z.object({ kind: z.literal("layer"), layerId: SceneLayerId }).strict(),
+    z.object({ kind: z.literal("environment") }).strict(),
+    z.object({ kind: z.literal("focus") }).strict()
+  ]
+);
+var SceneChannelV2 = z.object({
+  target: SceneChannelTargetV2,
+  property: z.string().min(1).max(64),
+  keyframes: SceneKeyframesV2
+}).strict();
+var SCENE_CAMERA_PROPERTIES = [
+  "positionX",
+  "positionY",
+  "positionZ",
+  "rotationX",
+  "rotationY",
+  "rotationZ",
+  "fov"
+];
+var SCENE_WORLD_OBJECT_PROPERTIES = [
+  "positionX",
+  "positionY",
+  "positionZ",
+  "rotationX",
+  "rotationY",
+  "rotationZ",
+  "scale",
+  "opacity"
+];
+var SCENE_LAPTOP_PROPERTIES = [
+  ...SCENE_WORLD_OBJECT_PROPERTIES,
+  "openAngle"
+];
+var SCENE_SCREEN_TEXT_PROPERTIES = ["x", "y", "rotation", "scale", "opacity"];
+var SCENE_ENVIRONMENT_PROPERTIES = ["intensity"];
+var SCENE_FOCUS_PROPERTIES = ["distance", "range", "maxBlur"];
+var SCENE_CHANNEL_PROPERTIES = [
+  .../* @__PURE__ */ new Set([
+    ...SCENE_CAMERA_PROPERTIES,
+    ...SCENE_WORLD_OBJECT_PROPERTIES,
+    ...SCENE_LAPTOP_PROPERTIES,
+    ...SCENE_SCREEN_TEXT_PROPERTIES,
+    ...SCENE_ENVIRONMENT_PROPERTIES,
+    ...SCENE_FOCUS_PROPERTIES
+  ])
+];
+var SceneFocusV2 = z.object({
+  distance: z.number().positive(),
+  range: z.number().positive(),
+  maxBlur: z.number().min(0).max(64)
+}).strict();
+var ScenePostV2 = z.object({
+  grain: z.number().min(0).max(0.5).default(0),
+  vignette: SceneUnit.default(0),
+  focus: SceneFocusV2.nullable().default(null)
+}).strict().default({ grain: 0, vignette: 0, focus: null });
+var SceneGeneratedStudioRigV2 = z.object({
+  kind: z.literal("studio").optional(),
+  lightingProfile: z.enum(["studio", "studio-edge"]).default("studio"),
+  preset: z.enum(["soft", "key", "rim"]).default("soft"),
+  intensity: z.number().min(0).default(1),
+  floorY: z.number().default(-420),
+  shadowOpacity: SceneUnit.default(0.5)
+}).strict();
+var ScenePhotographicStudioRigV1 = z.object({ kind: z.literal("photographic-studio-v1") }).strict();
+var SceneRigV2 = z.union([
+  SceneGeneratedStudioRigV2,
+  ScenePhotographicStudioRigV1
+]);
+var SceneConstraintV2 = z.object({
+  kind: z.literal("minSeparation"),
+  objects: z.array(SceneLayerId).min(2),
+  gap: z.number().positive()
+}).strict();
+function flattenSceneObjects(nodes, path = ["layers"], groupDepth = 0, output = []) {
+  nodes.forEach((node, index) => {
+    const nodePath = [...path, index];
+    const nodeGroupDepth = node.kind === "group" ? groupDepth + 1 : groupDepth;
+    output.push({ node, path: nodePath, groupDepth: nodeGroupDepth });
+    if (node.kind === "group") {
+      flattenSceneObjects(node.children, [...nodePath, "children"], nodeGroupDepth, output);
+    }
+  });
+  return output;
+}
+var SCENE_PRESET_SLOTS = Object.freeze({
+  laptop: ["screen"],
+  phone: ["screen"],
+  slab: ["front"],
+  page: ["content"]
+});
+var SCENE_PRESET_MATERIAL_ROLES = Object.freeze({
+  laptop: ["base", "lid", "keyboard", "trackpad", "bezel", "screen", "glass"],
+  phone: ["shell", "screen", "glass"],
+  slab: ["body", "face"],
+  page: ["base"]
+});
+function allowedLayerProperties(node) {
+  if (node.kind === "text" && node.space === "screen") return SCENE_SCREEN_TEXT_PROPERTIES;
+  if (node.kind === "laptop") return SCENE_LAPTOP_PROPERTIES;
+  return SCENE_WORLD_OBJECT_PROPERTIES;
+}
+function channelBound(target, property) {
+  if (target === "camera" && property === "fov") return { min: SCENE_FOV_MIN, max: SCENE_FOV_MAX };
+  if (target === "layer" && property === "scale") return { exclusiveMin: 0 };
+  if (target === "layer" && property === "opacity") return { min: 0, max: 1 };
+  if (target === "layer" && property === "openAngle") return { min: 0, max: Math.PI };
+  if (target === "environment" && property === "intensity") return { min: 0 };
+  if (target === "focus" && property === "maxBlur") return { min: 0, max: 64 };
+  if (target === "focus") return { exclusiveMin: 0 };
+  return {};
+}
+function violatesBound(bound, value) {
+  return bound.min !== void 0 && value < bound.min || bound.exclusiveMin !== void 0 && value <= bound.exclusiveMin || bound.max !== void 0 && value > bound.max;
+}
+var SceneShotSpecV2Base = z.object({
+  version: z.literal(SCENE_SHOT_SPEC_VERSION),
+  referenceSize: SceneReferenceSizeV2,
+  camera: SceneCameraInputV2.optional(),
+  environment: SceneRigV2.default({
+    lightingProfile: "studio",
+    preset: "soft",
+    intensity: 1,
+    floorY: -420,
+    shadowOpacity: 0.5
+  }),
+  backdrop: SceneBackdropV2.default({ kind: "transparent" }),
+  layers: z.array(SceneObjectV2).min(1),
+  animation: z.array(SceneChannelV2).default([]),
+  post: ScenePostV2,
+  constraints: z.array(SceneConstraintV2).default([])
+}).strict().transform((spec2) => {
+  const fov = spec2.camera?.fov ?? 40 * Math.PI / 180;
+  return {
+    ...spec2,
+    camera: {
+      position: spec2.camera?.position ?? [0, 0, spec2.referenceSize.height / (2 * Math.tan(fov / 2))],
+      rotation: spec2.camera?.rotation ?? [0, 0, 0],
+      fov
+    }
+  };
+});
+var SceneShotSpecV2Schema = SceneShotSpecV2Base.superRefine(
+  (spec2, ctx) => {
+    const flat = flattenSceneObjects(spec2.layers);
+    if (flat.length > SCENE_MAX_LAYERS) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["layers"],
+        message: `The flattened scene has ${flat.length} layers; the limit is ${SCENE_MAX_LAYERS}.`
+      });
+    }
+    const nodesById = /* @__PURE__ */ new Map();
+    let surfaceCount = 0;
+    for (const entry of flat) {
+      const { node, path, groupDepth } = entry;
+      if (groupDepth > SCENE_MAX_GROUP_DEPTH) {
+        ctx.addIssue({
+          code: "custom",
+          path,
+          message: `Group depth ${groupDepth} exceeds the limit ${SCENE_MAX_GROUP_DEPTH}.`
+        });
+      }
+      if (nodesById.has(node.id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [...path, "id"],
+          message: `Duplicate layer id "${node.id}".`
+        });
+      } else {
+        nodesById.set(node.id, node);
+      }
+      if ("surfaces" in node && node.surfaces !== void 0) {
+        const preset = node.kind;
+        const legalSlots = SCENE_PRESET_SLOTS[preset] ?? [];
+        for (const slot of Object.keys(node.surfaces)) {
+          surfaceCount += 1;
+          if (!legalSlots.includes(slot)) {
+            ctx.addIssue({
+              code: "custom",
+              path: [...path, "surfaces", slot],
+              message: `Unknown ${node.kind} surface slot "${slot}"; legal slots: ${legalSlots.join(", ") || "(none)"}.`
+            });
+          }
+        }
+        if (node.kind === "page" && node.surfaces.content === void 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: [...path, "surfaces", "content"],
+            message: "A page requires its content surface."
+          });
+        }
+      }
+      if ("materials" in node && node.materials !== void 0) {
+        const preset = node.kind;
+        const legalRoles = SCENE_PRESET_MATERIAL_ROLES[preset] ?? [];
+        const seenRoles = /* @__PURE__ */ new Set();
+        node.materials.forEach((material, index) => {
+          if (!legalRoles.includes(material.role)) {
+            ctx.addIssue({
+              code: "custom",
+              path: [...path, "materials", index, "role"],
+              message: `Unknown ${node.kind} material role "${material.role}"; legal roles: ${legalRoles.join(", ")}.`
+            });
+          }
+          if (seenRoles.has(material.role)) {
+            ctx.addIssue({
+              code: "custom",
+              path: [...path, "materials", index, "role"],
+              message: `Duplicate material override for role "${material.role}".`
+            });
+          }
+          seenRoles.add(material.role);
+        });
+      }
+    }
+    if (surfaceCount > SCENE_MAX_SURFACES) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["layers"],
+        message: `The flattened scene binds ${surfaceCount} surfaces; the limit is ${SCENE_MAX_SURFACES}.`
+      });
+    }
+    const channelKeys = /* @__PURE__ */ new Set();
+    let keyframeCount = 0;
+    spec2.animation.forEach((channel, index) => {
+      keyframeCount += channel.keyframes.length;
+      let allowed;
+      let targetNode;
+      if (channel.target.kind === "camera") {
+        allowed = SCENE_CAMERA_PROPERTIES;
+      } else if (channel.target.kind === "environment") {
+        allowed = spec2.environment.kind === "photographic-studio-v1" ? [] : SCENE_ENVIRONMENT_PROPERTIES;
+      } else if (channel.target.kind === "focus") {
+        allowed = SCENE_FOCUS_PROPERTIES;
+        if (spec2.post.focus === null) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["animation", index, "target"],
+            message: "A focus channel requires post.focus."
+          });
+        }
+      } else {
+        targetNode = nodesById.get(channel.target.layerId);
+        allowed = targetNode === void 0 ? [] : allowedLayerProperties(targetNode);
+        if (targetNode === void 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["animation", index, "target", "layerId"],
+            message: `Unknown layer "${channel.target.layerId}".`
+          });
+        }
+      }
+      if (!allowed.includes(channel.property)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["animation", index, "property"],
+          message: `"${channel.property}" cannot be animated on this target; legal properties: ${allowed.join(", ") || "(none)"}.`
+        });
+      }
+      const targetKey = channel.target.kind === "layer" ? `layer:${channel.target.layerId}` : channel.target.kind;
+      const channelKey2 = `${targetKey}|${channel.property}`;
+      if (channelKeys.has(channelKey2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["animation", index],
+          message: `Duplicate channel for ${targetKey}.${channel.property}.`
+        });
+      }
+      channelKeys.add(channelKey2);
+      const bound = channelBound(channel.target.kind, channel.property);
+      channel.keyframes.forEach((keyframe, keyframeIndex) => {
+        if (violatesBound(bound, keyframe.value)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["animation", index, "keyframes", keyframeIndex, "value"],
+            message: `${channel.property} is outside its authored bounds.`
+          });
+        }
+      });
+    });
+    if (keyframeCount > SCENE_MAX_KEYFRAMES_PER_SHOT) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["animation"],
+        message: `The shot has ${keyframeCount} keyframes; the limit is ${SCENE_MAX_KEYFRAMES_PER_SHOT}.`
+      });
+    }
+    spec2.constraints.forEach((constraint, constraintIndex) => {
+      const seenObjects = /* @__PURE__ */ new Set();
+      constraint.objects.forEach((objectId, objectIndex) => {
+        if (!nodesById.has(objectId)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["constraints", constraintIndex, "objects", objectIndex],
+            message: `Unknown constrained object "${objectId}".`
+          });
+        }
+        if (seenObjects.has(objectId)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["constraints", constraintIndex, "objects", objectIndex],
+            message: `Duplicate constrained object "${objectId}".`
+          });
+        }
+        seenObjects.add(objectId);
+      });
+    });
+  }
+);
+var SCENE_OBJECT_LIGHT_FIELDS = [
+  "light",
+  "lights",
+  "lighting",
+  "lightingProfile",
+  "intensity",
+  "lightIntensity",
+  "lightPosition",
+  "lightColor",
+  "lightColour",
+  "slabEdgeLighting",
+  "slabEdgeBoost",
+  "slabSideLighting",
+  "slabSideIntensity",
+  "edgeLight",
+  "edgeLighting",
+  "rimLight",
+  "castShadow",
+  "shadowOpacity"
+];
+function throwRefusal(code, path, message, input) {
+  throw new z.ZodError([{ code: "custom", path, message: `${code}: ${message}`, input }]);
+}
+function preflightObjectLightFields(value, path = ["layers"]) {
+  if (!Array.isArray(value)) return;
+  value.forEach((candidate, index) => {
+    if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) return;
+    const node = candidate;
+    for (const field of SCENE_OBJECT_LIGHT_FIELDS) {
+      if (Object.prototype.hasOwnProperty.call(node, field)) {
+        throwRefusal(
+          "scene_object_light_field_unsupported",
+          [...path, index, field],
+          `No object carries "${field}". Choose a shot-level environment lighting profile.`,
+          node[field]
+        );
+      }
+    }
+    if (node.kind === "group") {
+      preflightObjectLightFields(node.children, [...path, index, "children"]);
+    }
+  });
+}
+function recordAt(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function rejectNonFiniteNumbers(value, path = []) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new z.ZodError([
+        {
+          code: "custom",
+          path,
+          message: "Expected a finite number.",
+          input: value
+        }
+      ]);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => rejectNonFiniteNumbers(entry, [...path, index]));
+    return;
+  }
+  const record2 = recordAt(value);
+  if (record2 === null) return;
+  for (const [key, entry] of Object.entries(record2)) {
+    rejectNonFiniteNumbers(entry, [...path, key]);
+  }
+}
+function rejectUnknownFields(value, allowed, path) {
+  const record2 = recordAt(value);
+  if (record2 === null) return;
+  const unknown = Object.keys(record2).find((key) => !allowed.includes(key));
+  if (unknown !== void 0) {
+    throw new z.ZodError([
+      {
+        code: "custom",
+        path: [...path, unknown],
+        message: `Unrecognized field "${unknown}".`,
+        input: record2[unknown]
+      }
+    ]);
+  }
+}
+function requireFields(value, required, path) {
+  const record2 = recordAt(value);
+  if (record2 === null) return;
+  const missing = required.find((key) => record2[key] === void 0);
+  if (missing !== void 0) {
+    throw new z.ZodError([
+      {
+        code: "custom",
+        path: [...path, missing],
+        message: `Required field "${missing}" is missing.`,
+        input: void 0
+      }
+    ]);
+  }
+}
+function preflightColor(value, path) {
+  if (typeof value === "string" && value.startsWith("$brand:") && !COLOR_REFERENCE_VALUES.includes(value)) {
+    throw new z.ZodError([
+      {
+        code: "custom",
+        path,
+        message: `scene_brand_token_unresolved: "${value}" is not a scene colour token; supported roles: ${SCENE_BRAND_COLOR_TOKENS.join(", ")}.`,
+        input: value
+      }
+    ]);
+  }
+}
+function preflightTransform(value, path) {
+  rejectUnknownFields(value, ["position", "rotation", "scale"], path);
+}
+function preflightMaterial(value, path) {
+  rejectUnknownFields(
+    value,
+    [
+      "role",
+      "type",
+      "color",
+      "roughness",
+      "metalness",
+      "clearcoat",
+      "clearcoatRoughness",
+      "anisotropy",
+      "anisotropyRotation",
+      "ior",
+      "reflectivity"
+    ],
+    path
+  );
+  preflightColor(recordAt(value)?.color, [...path, "color"]);
+}
+function preflightSurface(value, path) {
+  const surface = recordAt(value);
+  if (surface === null) return;
+  requireFields(surface, ["source"], path);
+  switch (surface.source) {
+    case "image":
+      rejectUnknownFields(surface, ["source", "assetSlot"], path);
+      requireFields(surface, ["assetSlot"], path);
+      break;
+    case "color":
+      rejectUnknownFields(surface, ["source", "color"], path);
+      requireFields(surface, ["color"], path);
+      preflightColor(surface.color, [...path, "color"]);
+      break;
+    case "component":
+      rejectUnknownFields(
+        surface,
+        ["source", "component", "captureFrame", "layout", "bakeScale", "params"],
+        path
+      );
+      requireFields(surface, ["component", "captureFrame", "layout"], path);
+      requireFields(
+        surface.component,
+        ["version", "componentId", "sourceVersionId"],
+        [...path, "component"]
+      );
+      requireFields(surface.layout, ["width", "height"], [...path, "layout"]);
+      rejectUnknownFields(
+        surface.component,
+        ["version", "componentId", "sourceVersionId"],
+        [...path, "component"]
+      );
+      rejectUnknownFields(surface.layout, ["width", "height"], [...path, "layout"]);
+      break;
+    case "video":
+      rejectUnknownFields(surface, ["source", "mediaId", "startFrame", "endFrame"], path);
+      requireFields(surface, ["mediaId"], path);
+      break;
+    default:
+      break;
+  }
+}
+function preflightText(value, path) {
+  const common = [
+    "kind",
+    "space",
+    "id",
+    "opacity",
+    "lines",
+    "fontFamily",
+    "fontWeight",
+    "fontStyle",
+    "fontSize",
+    "lineHeight",
+    "letterSpacing",
+    "align",
+    "maxWidth",
+    "color"
+  ];
+  rejectUnknownFields(
+    value,
+    value.space === "screen" ? [...common, "x", "y", "rotation", "scale"] : [...common, "transform"],
+    path
+  );
+  requireFields(
+    value,
+    [
+      "kind",
+      "space",
+      "id",
+      "lines",
+      "fontFamily",
+      "fontWeight",
+      "fontStyle",
+      "fontSize",
+      "color",
+      ...value.space === "screen" ? ["x", "y"] : []
+    ],
+    path
+  );
+  preflightColor(value.color, [...path, "color"]);
+  if (typeof value.fontFamily === "string" && value.fontFamily.startsWith("$brand:") && !FONT_REFERENCE_VALUES.includes(value.fontFamily)) {
+    throw new z.ZodError([
+      {
+        code: "custom",
+        path: [...path, "fontFamily"],
+        message: `scene_brand_token_unresolved: "${value.fontFamily}" is not a scene font token; supported roles: ${SCENE_BRAND_FONT_TOKENS.join(", ")}.`,
+        input: value.fontFamily
+      }
+    ]);
+  }
+  if (value.space === "world") preflightTransform(value.transform, [...path, "transform"]);
+  if (!Array.isArray(value.lines)) return;
+  value.lines.forEach((line, lineIndex) => {
+    const linePath = [...path, "lines", lineIndex];
+    rejectUnknownFields(line, ["runs"], linePath);
+    const runs = recordAt(line)?.runs;
+    if (!Array.isArray(runs)) return;
+    runs.forEach((run, runIndex) => {
+      const runPath = [...linePath, "runs", runIndex];
+      rejectUnknownFields(run, ["text", "color", "emphasis"], runPath);
+      preflightColor(recordAt(run)?.color, [...runPath, "color"]);
+    });
+  });
+}
+function preflightObjects(value, path = ["layers"]) {
+  if (!Array.isArray(value)) return;
+  value.forEach((candidate, index) => {
+    const node = recordAt(candidate);
+    if (node === null) return;
+    const nodePath = [...path, index];
+    if (typeof node.kind !== "string" || !["group", "laptop", "phone", "slab", "page", "text"].includes(node.kind)) {
+      throw new z.ZodError([
+        {
+          code: "custom",
+          path: [...nodePath, "kind"],
+          message: "Expected a supported scene object kind.",
+          input: node.kind
+        }
+      ]);
+    }
+    if (node.kind === "text" && node.space !== "world" && node.space !== "screen") {
+      throw new z.ZodError([
+        {
+          code: "custom",
+          path: [...nodePath, "space"],
+          message: 'Text space must be "world" or "screen".',
+          input: node.space
+        }
+      ]);
+    }
+    switch (node.kind) {
+      case "group":
+        rejectUnknownFields(node, ["kind", "id", "transform", "opacity", "children"], nodePath);
+        preflightTransform(node.transform, [...nodePath, "transform"]);
+        requireFields(node, ["id", "children"], nodePath);
+        preflightObjects(node.children, [...nodePath, "children"]);
+        return;
+      case "laptop":
+        rejectUnknownFields(
+          node,
+          ["kind", "id", "transform", "opacity", "width", "openAngle", "materials", "surfaces"],
+          nodePath
+        );
+        requireFields(node, ["id", "width", "openAngle"], nodePath);
+        break;
+      case "phone":
+        rejectUnknownFields(
+          node,
+          ["kind", "id", "transform", "opacity", "width", "materials", "surfaces"],
+          nodePath
+        );
+        requireFields(node, ["id", "width"], nodePath);
+        break;
+      case "slab":
+        rejectUnknownFields(
+          node,
+          [
+            "kind",
+            "id",
+            "transform",
+            "opacity",
+            "width",
+            "height",
+            "thickness",
+            "cornerRadius",
+            "edgeRadius",
+            "finish",
+            "materials",
+            "surfaces"
+          ],
+          nodePath
+        );
+        requireFields(node, ["id", "width", "height"], nodePath);
+        break;
+      case "page":
+        rejectUnknownFields(
+          node,
+          [
+            "kind",
+            "id",
+            "transform",
+            "opacity",
+            "width",
+            "height",
+            "fit",
+            "transparency",
+            "depthWrite",
+            "backface",
+            "materials",
+            "surfaces"
+          ],
+          nodePath
+        );
+        requireFields(node, ["id", "width", "height", "surfaces"], nodePath);
+        break;
+      case "text":
+        preflightText(node, nodePath);
+        return;
+      default:
+        return;
+    }
+    preflightTransform(node.transform, [...nodePath, "transform"]);
+    if (Array.isArray(node.materials)) {
+      node.materials.forEach(
+        (material, materialIndex) => preflightMaterial(material, [...nodePath, "materials", materialIndex])
+      );
+    }
+    const surfaces = recordAt(node.surfaces);
+    if (surfaces !== null) {
+      for (const [slot, surface] of Object.entries(surfaces)) {
+        preflightSurface(surface, [...nodePath, "surfaces", slot]);
+      }
+    }
+  });
+}
+function preflightDocument(document) {
+  rejectNonFiniteNumbers(document);
+  rejectUnknownFields(
+    document,
+    [
+      "version",
+      "referenceSize",
+      "camera",
+      "environment",
+      "backdrop",
+      "layers",
+      "animation",
+      "post",
+      "constraints"
+    ],
+    []
+  );
+  rejectUnknownFields(document.referenceSize, ["width", "height"], ["referenceSize"]);
+  rejectUnknownFields(document.camera, ["position", "rotation", "fov"], ["camera"]);
+  const environment = recordAt(document.environment);
+  if (environment !== null) {
+    rejectUnknownFields(
+      environment,
+      environment.kind === "photographic-studio-v1" ? ["kind"] : ["kind", "lightingProfile", "preset", "intensity", "floorY", "shadowOpacity"],
+      ["environment"]
+    );
+  }
+  const backdrop = recordAt(document.backdrop);
+  if (backdrop !== null) {
+    if (backdrop.kind === "transparent") rejectUnknownFields(backdrop, ["kind"], ["backdrop"]);
+    if (backdrop.kind === "solid") {
+      rejectUnknownFields(backdrop, ["kind", "color"], ["backdrop"]);
+      preflightColor(backdrop.color, ["backdrop", "color"]);
+    }
+    if (backdrop.kind === "linear") {
+      rejectUnknownFields(backdrop, ["kind", "angle", "stops"], ["backdrop"]);
+    }
+    if (backdrop.kind === "radial") {
+      rejectUnknownFields(backdrop, ["kind", "at", "stops"], ["backdrop"]);
+    }
+    if (Array.isArray(backdrop.stops)) {
+      backdrop.stops.forEach((stop, index) => {
+        rejectUnknownFields(stop, ["at", "color"], ["backdrop", "stops", index]);
+        preflightColor(recordAt(stop)?.color, ["backdrop", "stops", index, "color"]);
+      });
+    }
+  }
+  preflightObjects(document.layers);
+  if (Array.isArray(document.animation)) {
+    document.animation.forEach((candidate, index) => {
+      const channel = recordAt(candidate);
+      if (channel === null) return;
+      const channelPath = ["animation", index];
+      rejectUnknownFields(channel, ["target", "property", "keyframes"], channelPath);
+      const target = recordAt(channel.target);
+      rejectUnknownFields(
+        target,
+        target?.kind === "layer" ? ["kind", "layerId"] : ["kind"],
+        [...channelPath, "target"]
+      );
+      if (!Array.isArray(channel.keyframes)) return;
+      channel.keyframes.forEach((candidateKeyframe, keyframeIndex) => {
+        const keyframePath = [...channelPath, "keyframes", keyframeIndex];
+        const keyframe = recordAt(candidateKeyframe);
+        rejectUnknownFields(keyframe, ["at", "value", "easing"], keyframePath);
+        const easing = recordAt(keyframe?.easing);
+        if (easing !== null) {
+          rejectUnknownFields(
+            easing,
+            easing.kind === "bezier" ? ["kind", "x1", "y1", "x2", "y2"] : ["kind"],
+            [...keyframePath, "easing"]
+          );
+        }
+      });
+    });
+  }
+  const post = recordAt(document.post);
+  rejectUnknownFields(post, ["grain", "vignette", "focus"], ["post"]);
+  rejectUnknownFields(recordAt(post?.focus), ["distance", "range", "maxBlur"], ["post", "focus"]);
+  if (Array.isArray(document.constraints)) {
+    document.constraints.forEach(
+      (constraint, index) => rejectUnknownFields(constraint, ["kind", "objects", "gap"], ["constraints", index])
+    );
+  }
+}
+function runSceneShotPreflight(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const document = value;
+  if (document.version !== SCENE_SHOT_SPEC_VERSION) {
+    throwRefusal(
+      "scene_spec_version_unsupported",
+      ["version"],
+      `Scene version ${String(document.version)} is unsupported; this runtime accepts version 2.`,
+      document.version
+    );
+  }
+  const environment = document.environment;
+  if (environment !== void 0 && environment !== null && typeof environment === "object") {
+    const rig = environment;
+    const kind = rig.kind;
+    if (kind !== void 0 && kind !== "studio" && kind !== "photographic-studio-v1") {
+      throwRefusal(
+        "scene_rig_unsupported",
+        ["environment", "kind"],
+        `Unsupported rig ${JSON.stringify(kind)}; use "studio" or "photographic-studio-v1".`,
+        kind
+      );
+    }
+    if (kind === "photographic-studio-v1") {
+      const unsupported = Object.keys(rig).find((key) => key !== "kind");
+      if (unsupported !== void 0) {
+        throwRefusal(
+          "scene_photographic_rig_field_unsupported",
+          ["environment", unsupported],
+          "photographic-studio-v1 is fixed and accepts only its kind.",
+          rig[unsupported]
+        );
+      }
+    } else if (rig.lightingProfile !== void 0 && rig.lightingProfile !== "studio" && rig.lightingProfile !== "studio-edge") {
+      throwRefusal(
+        "scene_lighting_profile_unsupported",
+        ["environment", "lightingProfile"],
+        'Supported profiles are "studio" and "studio-edge".',
+        rig.lightingProfile
+      );
+    }
+  }
+  preflightObjectLightFields(document.layers);
+  preflightDocument(document);
+}
+var SceneShotSpecV2Preflight = z.unknown().superRefine((value, ctx) => {
+  try {
+    runSceneShotPreflight(value);
+  } catch (error) {
+    if (!(error instanceof z.ZodError)) throw error;
+    for (const issue of error.issues) ctx.addIssue(issue);
+  }
+});
+var SceneShotSpecV2 = SceneShotSpecV2Preflight.pipe(
+  SceneShotSpecV2Schema
+);
+function parseSceneShotSpecV2(value) {
+  return SceneShotSpecV2.parse(value);
+}
+function visitSceneObjects(nodes, visitor) {
+  for (const node of nodes) {
+    visitor(node);
+    if (node.kind === "group") visitSceneObjects(node.children, visitor);
+  }
+}
+function sceneShotImageSlots(spec2) {
+  const slots = [];
+  visitSceneObjects(spec2.layers, (node) => {
+    if (!("surfaces" in node) || node.surfaces === void 0) return;
+    for (const binding of Object.values(node.surfaces)) {
+      if (binding.source === "image" && !slots.includes(binding.assetSlot)) {
+        slots.push(binding.assetSlot);
+      }
+    }
+  });
+  return slots;
+}
+function sceneShotVideoSlots(spec2) {
+  const slots = [];
+  visitSceneObjects(spec2.layers, (node) => {
+    if (!("surfaces" in node) || node.surfaces === void 0) return;
+    for (const binding of Object.values(node.surfaces)) if (binding.source === "video" && !slots.includes(binding.mediaId)) slots.push(binding.mediaId);
+  });
+  return slots;
+}
+function sceneShotSurfaceCount(spec2) {
+  let count = 0;
+  visitSceneObjects(spec2.layers, (node) => {
+    if ("surfaces" in node && node.surfaces !== void 0) {
+      count += Object.keys(node.surfaces).length;
+    }
+  });
+  return count;
+}
+var sceneShotJsonSchema = z.toJSONSchema(SceneShotSpecV2Schema, {
+  target: "draft-2020-12",
+  io: "input"
+});
+function sceneShotJsonSchemaText() {
+  return `${JSON.stringify(sceneShotJsonSchema, null, 2)}
+`;
+}
+
+// ../composition/src/scene/animation.ts
+function contentFrame(frame, durationInFrames) {
+  if (!Number.isFinite(frame) || !Number.isInteger(durationInFrames) || durationInFrames <= 1) return 0;
+  return Math.max(0, Math.min(durationInFrames - 1, Math.floor(frame)));
+}
+function normalizedTime(frame, durationInFrames) {
+  return durationInFrames <= 1 ? 0 : contentFrame(frame, durationInFrames) / (durationInFrames - 1);
+}
+function cubicBezierEase(x1, y1, x2, y2) {
+  return (input) => {
+    const t2 = Math.max(0, Math.min(1, input));
+    if (t2 === 0 || t2 === 1) return t2;
+    let lo = 0, hi = 1, u = t2;
+    for (let i = 0; i < 40; i += 1) {
+      u = (lo + hi) / 2;
+      const x = 3 * (1 - u) ** 2 * u * x1 + 3 * (1 - u) * u ** 2 * x2 + u ** 3;
+      if (x < t2) lo = u;
+      else hi = u;
+    }
+    return 3 * (1 - u) ** 2 * u * y1 + 3 * (1 - u) * u ** 2 * y2 + u ** 3;
+  };
+}
+function evaluateChannel(keyframes, t2) {
+  const first = keyframes[0];
+  if (!first) throw new Error("Scene channel carries no keyframes");
+  if (t2 <= first.at) return first.value;
+  for (let i = 1; i < keyframes.length; i += 1) {
+    const next = keyframes[i];
+    if (t2 > next.at) continue;
+    const previous = keyframes[i - 1];
+    const easing = next.easing;
+    if (easing?.kind === "hold") return t2 === next.at ? next.value : previous.value;
+    let progress = (t2 - previous.at) / (next.at - previous.at);
+    if (easing?.kind === "bezier") progress = cubicBezierEase(easing.x1, easing.y1, easing.x2, easing.y2)(progress);
+    return previous.value + (next.value - previous.value) * progress;
+  }
+  return keyframes[keyframes.length - 1].value;
+}
+var AXES = {
+  positionX: ["position", 0],
+  positionY: ["position", 1],
+  positionZ: ["position", 2],
+  rotationX: ["rotation", 0],
+  rotationY: ["rotation", 1],
+  rotationZ: ["rotation", 2]
+};
+var AXIS_PROPERTIES = Object.keys(AXES);
+var channelKey = (channel) => `${channel.target.kind === "layer" ? `layer:${channel.target.layerId}` : channel.target.kind}|${channel.property}`;
+var identityMatrix = () => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+function multiply(a, b) {
+  const out = new Array(16).fill(0);
+  for (let column = 0; column < 4; column += 1) for (let row = 0; row < 4; row += 1) {
+    for (let k = 0; k < 4; k += 1) out[column * 4 + row] += a[k * 4 + row] * b[column * 4 + k];
+  }
+  return out;
+}
+function sceneTransformMatrix(transform) {
+  const [x, y, z2] = transform.position, [rx, ry, rz] = transform.rotation;
+  const cx = Math.cos(rx), sx = Math.sin(rx), cy = Math.cos(ry), sy = Math.sin(ry), cz = Math.cos(rz), sz = Math.sin(rz), s = transform.scale;
+  const t2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z2, 1];
+  const mx = [1, 0, 0, 0, 0, cx, sx, 0, 0, -sx, cx, 0, 0, 0, 0, 1];
+  const my = [cy, 0, -sy, 0, 0, 1, 0, 0, sy, 0, cy, 0, 0, 0, 0, 1];
+  const mz = [cz, sz, 0, 0, -sz, cz, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  const ms = [s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1];
+  return multiply(multiply(t2, mx), multiply(my, multiply(mz, ms)));
+}
+function setAxis(target, property, value) {
+  const [field, index] = AXES[property];
+  target[field][index] = value;
+}
+function evaluateScene(spec2, requestedFrame, durationInFrames) {
+  const u = normalizedTime(requestedFrame, durationInFrames), frame = contentFrame(requestedFrame, durationInFrames);
+  const channels = new Map(spec2.animation.map((channel) => [channelKey(channel), channel]));
+  const sample = (target, property, base) => {
+    const channel = channels.get(`${target}|${property}`);
+    return channel ? evaluateChannel(channel.keyframes, u) : base;
+  };
+  const camera = structuredClone(spec2.camera);
+  for (const property of AXIS_PROPERTIES) {
+    const [field, index] = AXES[property];
+    setAxis(camera, property, sample("camera", property, camera[field][index]));
+  }
+  camera.fov = sample("camera", "fov", camera.fov);
+  const walk = (objects, parentMatrix, parentOpacity) => objects.map((source) => {
+    const object = structuredClone(source);
+    const localOpacity = sample(`layer:${object.id}`, "opacity", object.opacity), worldOpacity = parentOpacity * localOpacity;
+    if (object.kind === "text" && object.space === "screen") {
+      object.x = sample(`layer:${object.id}`, "x", object.x);
+      object.y = sample(`layer:${object.id}`, "y", object.y);
+      object.rotation = sample(`layer:${object.id}`, "rotation", object.rotation);
+      object.scale = sample(`layer:${object.id}`, "scale", object.scale);
+      object.opacity = localOpacity;
+      return { ...object, worldMatrix: null, worldOpacity };
+    }
+    for (const property of AXIS_PROPERTIES) {
+      const [field, index] = AXES[property];
+      setAxis(object.transform, property, sample(`layer:${object.id}`, property, object.transform[field][index]));
+    }
+    object.transform.scale = sample(`layer:${object.id}`, "scale", object.transform.scale);
+    object.opacity = localOpacity;
+    if (object.kind === "laptop") object.openAngle = sample(`layer:${object.id}`, "openAngle", object.openAngle);
+    const worldMatrix = multiply(parentMatrix, sceneTransformMatrix(object.transform));
+    return object.kind === "group" ? { ...object, children: walk(object.children, worldMatrix, worldOpacity), worldMatrix, worldOpacity } : { ...object, worldMatrix, worldOpacity };
+  });
+  const environment = structuredClone(spec2.environment);
+  if (environment.kind !== "photographic-studio-v1") environment.intensity = sample("environment", "intensity", environment.intensity);
+  const focus = spec2.post.focus ? structuredClone(spec2.post.focus) : null;
+  if (focus) {
+    focus.distance = sample("focus", "distance", focus.distance);
+    focus.range = sample("focus", "range", focus.range);
+    focus.maxBlur = sample("focus", "maxBlur", focus.maxBlur);
+  }
+  return { u, contentFrame: frame, camera, environment, focus, layers: walk(spec2.layers, identityMatrix(), 1) };
+}
+
+// ../composition/src/scene/clipRules.ts
+import { ZodError } from "zod";
+function slotOwner(spec2, slot) {
+  const find = (layers) => {
+    for (const layer of layers) {
+      if ("surfaces" in layer && layer.surfaces !== void 0) {
+        for (const binding of Object.values(layer.surfaces)) {
+          if (binding.source === "image" && binding.assetSlot === slot) return layer.id;
+        }
+      }
+      if (layer.kind === "group") {
+        const nested = find(layer.children);
+        if (nested !== void 0) return nested;
+      }
+    }
+    return void 0;
+  };
+  return find(spec2.layers);
+}
+function isSceneShotSource(declaration) {
+  return declaration?.manifest.sceneShot?.version === SCENE_SHOT_SPEC_VERSION && declaration.manifest.graphics.api === "webgl";
+}
+var SOURCE_VERSION_ID = /^[a-f0-9]{64}$/;
+function readSceneSourceRef(props) {
+  const ref = props.componentRef;
+  if (!ref || typeof ref !== "object") return null;
+  const { version, sourceVersionId } = ref;
+  if (version !== 1 || typeof sourceVersionId !== "string" || !SOURCE_VERSION_ID.test(sourceVersionId)) return null;
+  return { sourceVersionId };
+}
+function isTimelineClip(content) {
+  return "source" in content;
+}
+function isSceneShotClip(content, resolveSource) {
+  if (!isTimelineClip(content) || content.source.kind !== "component") return false;
+  const ref = readSceneSourceRef(content.source.props);
+  if (!ref) return false;
+  const declaration = resolveSource(content.source.componentId, ref.sourceVersionId);
+  return isSceneShotSource(declaration) && declaration.componentId === content.source.componentId;
+}
+var FRAME_EPSILON = 1e-6;
+function offFrameLattice(seconds, fps) {
+  const frames = seconds * fps;
+  return Math.abs(frames - Math.round(frames)) > FRAME_EPSILON;
+}
+function latticeDetail(seconds, fps) {
+  return `${seconds} s is not on the ${fps} fps frame lattice; use a whole number of frames (n/${fps} s).`;
+}
+var SCENE_TRANSITION_KINDS = ["cut", "fade"];
+function sceneTransitionDurationIssues(transition, fps) {
+  if (offFrameLattice(transition.duration, fps)) {
+    return [{
+      path: "transitionIn.duration",
+      detail: latticeDetail(transition.duration, fps),
+      code: "validation_error"
+    }];
+  }
+  if (transition.type === "fade" && Math.round(transition.duration * fps) < 1) {
+    return [{
+      path: "transitionIn.duration",
+      detail: `${transition.duration} s is zero frames at ${fps} fps; a fade needs at least one frame. Lengthen the fade or author the boundary as a cut.`,
+      code: "validation_error"
+    }];
+  }
+  return [];
+}
+var SCENE_PROPS_KEYS = /* @__PURE__ */ new Set(["componentRef", "scene"]);
+var COMPETING_PROP_DETAIL = {
+  transition: "a scene clip takes its boundary from `transitionIn` (cut or fade); `props.transition` would be a second owner of the same boundary. Remove it.",
+  sequenceGroup: "scene clips do not join legacy sequence groups; the composition already orders them on the dedicated track. Remove `props.sequenceGroup`.",
+  fadeIn: 'internal fades are refused on scene clips; express a fade with `transitionIn: { type: "fade", duration }`. Remove `props.fadeIn`.',
+  fadeOut: "internal fades are refused on scene clips; the next clip's `transitionIn` fades this one out. Remove `props.fadeOut`."
+};
+function sceneSpecIssues(value, path) {
+  try {
+    return { spec: parseSceneShotSpecV2(value), issues: [] };
+  } catch (error) {
+    if (!(error instanceof ZodError)) throw error;
+    const issues = error.issues.map((issue) => ({
+      path: issue.path.length > 0 ? `${path}.${issue.path.join(".")}` : path,
+      detail: issue.message,
+      code: "validation_error"
+    }));
+    return { spec: null, issues };
+  }
+}
+function bindingIssues(spec2, assets, path, mediaKindById) {
+  const issues = [];
+  const slots = sceneShotImageSlots(spec2);
+  for (const slot of slots) {
+    if (typeof assets[slot] === "string" && assets[slot].length > 0) continue;
+    issues.push({
+      path: `${path}.${slot}`,
+      detail: `slot '${slot}' is referenced by layer '${slotOwner(spec2, slot)}' but not bound; bind it to an image media id.`,
+      code: "validation_error"
+    });
+  }
+  for (const [name, mediaId] of Object.entries(assets)) {
+    if (!SCENE_ASSET_SLOT_PATTERN.test(name)) {
+      issues.push({ path: `${path}.${name}`, detail: `'${name}' is not a valid slot name.`, code: "validation_error" });
+      continue;
+    }
+    if (!slots.includes(name)) {
+      issues.push({
+        path: `${path}.${name}`,
+        detail: `no layer references slot '${name}'; remove the binding or reference the slot from a layer.`,
+        code: "validation_error"
+      });
+      continue;
+    }
+    if (!mediaKindById) continue;
+    const kind = mediaKindById[mediaId];
+    if (kind === void 0) {
+      issues.push({ path: `${path}.${name}`, detail: `media '${mediaId}' is not in this project.`, code: "validation_error" });
+    } else if (kind !== "image") {
+      issues.push({
+        path: `${path}.${name}`,
+        detail: `slot '${name}' needs image media (PNG, JPEG or WebP); '${mediaId}' is ${kind}.`,
+        code: "validation_error"
+      });
+    }
+  }
+  return issues;
+}
+function sceneClipShapeIssues(clip, ctx, options = {}) {
+  const issues = [];
+  const source = clip.source;
+  if (source.kind !== "component") {
+    return [{ path: "source.kind", detail: `a scene shot is a 'component' clip; got '${source.kind}'.`, code: "invalid_composition" }];
+  }
+  if (source.zPlane !== void 0 && source.zPlane !== "front") {
+    issues.push({
+      path: "source.zPlane",
+      detail: `scene shots render on the front plane only; '${source.zPlane}' is refused. Remove zPlane or set it to 'front'.`,
+      code: "validation_error"
+    });
+  }
+  for (const field of ["region", "position", "scale", "rotation", "fit"]) {
+    if (clip[field] !== void 0) {
+      issues.push({
+        path: field,
+        detail: `scene shots are full-frame: \`${field}\` is refused. Place and size content inside the scene (layer transforms), not on the clip.`,
+        code: "validation_error"
+      });
+    }
+  }
+  if (clip.effects !== void 0 && clip.effects.length > 0) {
+    issues.push({
+      path: "effects",
+      detail: "outer per-clip effects are refused on scene shots; use the scene's post (grain, vignette, focus) instead.",
+      code: "validation_error"
+    });
+  }
+  if (clip.animate !== void 0 && Object.keys(clip.animate).length > 0) {
+    issues.push({
+      path: "animate",
+      detail: "outer transform animation is refused on scene shots; animate the camera or layers through `scene.animation`.",
+      code: "validation_error"
+    });
+  }
+  for (const key of Object.keys(source.props)) {
+    if (SCENE_PROPS_KEYS.has(key)) continue;
+    issues.push({
+      path: `source.props.${key}`,
+      detail: COMPETING_PROP_DETAIL[key] ?? `scene shot props carry only \`componentRef\` and \`scene\`; \`${key}\` is refused.`,
+      code: "validation_error"
+    });
+  }
+  if (clip.transitionIn !== void 0) {
+    if (!SCENE_TRANSITION_KINDS.includes(clip.transitionIn.type)) {
+      issues.push({
+        path: "transitionIn.type",
+        detail: `scene shots accept 'cut' or 'fade' transitions; '${clip.transitionIn.type}' is refused.`,
+        code: "validation_error"
+      });
+    }
+    issues.push(...sceneTransitionDurationIssues(clip.transitionIn, ctx.fps));
+  }
+  if (offFrameLattice(clip.startTime, ctx.fps)) {
+    issues.push({ path: "startTime", detail: latticeDetail(clip.startTime, ctx.fps), code: "validation_error" });
+  }
+  if (offFrameLattice(clip.duration, ctx.fps)) {
+    issues.push({ path: "duration", detail: latticeDetail(clip.duration, ctx.fps), code: "validation_error" });
+  }
+  const parsed = sceneSpecIssues(source.props.scene, "source.props.scene");
+  issues.push(...parsed.issues);
+  if (parsed.issues.length === 0) {
+    issues.push(...bindingIssues(parsed.spec, source.assets ?? {}, "source.assets", options.checkMedia ? ctx.mediaKindById : void 0));
+  }
+  return issues;
+}
+function sceneClipOverlapIssue(clip, track) {
+  const end = clip.startTime + clip.duration;
+  for (const other of track.contents) {
+    if (other.id === clip.id) continue;
+    const otherEnd = other.startTime + other.duration;
+    if (clip.startTime < otherEnd && other.startTime < end) {
+      return {
+        path: "startTime",
+        detail: `[${clip.startTime}, ${end}) overlaps '${other.id}' [${other.startTime}, ${otherEnd}) on track '${track.id}'; scene shots on one track cannot overlap.`,
+        code: "invalid_composition"
+      };
+    }
+  }
+  return null;
+}
+function sceneDedicatedTrackIssue(track, resolveSource, path) {
+  if (track.kind !== "overlay") {
+    return {
+      path,
+      detail: `track '${track.id}' is kind '${track.kind}'; scene shots live on a dedicated overlay track. Pass newTrack: true or name an overlay track that holds only scene shots.`,
+      code: "invalid_composition"
+    };
+  }
+  for (const content of track.contents) {
+    if (!isTimelineClip(content) || isSceneShotClip(content, resolveSource)) continue;
+    return {
+      path,
+      detail: `track '${track.id}' holds '${content.id}' (source '${content.source.kind}'); scene shots need a dedicated track holding only scene shots and gaps. Pass newTrack: true or choose such a track.`,
+      code: "invalid_composition"
+    };
+  }
+  return null;
+}
+function collectSceneClipIssues(composition, ctx) {
+  const issues = [];
+  for (const track of composition.tracks) {
+    const clips = track.contents.filter(isTimelineClip);
+    const scenes = clips.filter((clip) => isSceneShotClip(clip, ctx.resolveSource));
+    if (scenes.length === 0) continue;
+    const sceneIds = new Set(scenes.map((clip) => clip.id));
+    for (const clip of clips) {
+      if (sceneIds.has(clip.id)) continue;
+      issues.push({
+        clipId: clip.id,
+        path: "source.kind",
+        message: `clip '${clip.id}' (source '${clip.source.kind}') shares track '${track.id}' with scene shot '${scenes[0].id}'; scene tracks hold only scene shots and gaps. Move it to another overlay track.`
+      });
+    }
+    if (track.kind !== "overlay") {
+      issues.push({
+        clipId: scenes[0].id,
+        path: "trackId",
+        message: `scene shot '${scenes[0].id}' sits on track '${track.id}' of kind '${track.kind}'; scene shots live on a dedicated overlay track.`
+      });
+    }
+    for (const clip of scenes) {
+      for (const issue of sceneClipShapeIssues(clip, ctx)) {
+        issues.push({ clipId: clip.id, path: issue.path, message: `scene shot '${clip.id}' ${issue.path}: ${issue.detail}` });
+      }
+      const overlap = sceneClipOverlapIssue(clip, track);
+      if (overlap) issues.push({ clipId: clip.id, path: overlap.path, message: `scene shot '${clip.id}' ${overlap.path}: ${overlap.detail}` });
+    }
+  }
+  return issues;
+}
+
+// ../composition/src/scene/constraints.ts
+var SceneConstraintRefusal = class extends Error {
+  code;
+  path;
+  detail;
+  constructor(code, path, message, detail) {
+    super(message);
+    this.name = "SceneConstraintRefusal";
+    this.code = code;
+    this.path = path;
+    this.detail = detail;
+  }
+};
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+var length = (value) => Math.hypot(value[0], value[1], value[2]);
+function applyLinear(basis, value) {
+  return [
+    basis[0][0] * value[0] + basis[1][0] * value[1] + basis[2][0] * value[2],
+    basis[0][1] * value[0] + basis[1][1] * value[1] + basis[2][1] * value[2],
+    basis[0][2] * value[0] + basis[1][2] * value[1] + basis[2][2] * value[2]
+  ];
+}
+function add(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function sceneRotationAxesV2(rotation) {
+  const [rotationX, rotationY, rotationZ] = rotation;
+  const cx = Math.cos(rotationX);
+  const sx = Math.sin(rotationX);
+  const cy = Math.cos(rotationY);
+  const sy = Math.sin(rotationY);
+  const cz = Math.cos(rotationZ);
+  const sz = Math.sin(rotationZ);
+  return [
+    [cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz],
+    [-cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz],
+    [sy, -sx * cy, cx * cy]
+  ];
+}
+function affineFor(transform) {
+  const axes = sceneRotationAxesV2(transform.rotation);
+  const scale = transform.scale;
+  return {
+    basis: [
+      [axes[0][0] * scale, axes[0][1] * scale, axes[0][2] * scale],
+      [axes[1][0] * scale, axes[1][1] * scale, axes[1][2] * scale],
+      [axes[2][0] * scale, axes[2][1] * scale, axes[2][2] * scale]
+    ],
+    translation: transform.position
+  };
+}
+function multiplyAffine(a, b) {
+  return {
+    basis: [
+      applyLinear(a.basis, b.basis[0]),
+      applyLinear(a.basis, b.basis[1]),
+      applyLinear(a.basis, b.basis[2])
+    ],
+    translation: add(applyLinear(a.basis, b.translation), a.translation)
+  };
+}
+function composedAffine(transforms) {
+  let result = {
+    basis: [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1]
+    ],
+    translation: [0, 0, 0]
+  };
+  for (const transform of transforms) result = multiplyAffine(result, affineFor(transform));
+  return result;
+}
+function finiteVec3(value) {
+  return value.length === 3 && value.every(Number.isFinite);
+}
+function validTransform(transform) {
+  return finiteVec3(transform.position) && finiteVec3(transform.rotation) && Number.isFinite(transform.scale) && transform.scale > 0;
+}
+function sceneOrientedBoundsV2(body, path = "constraint.body") {
+  const { center, halfExtents } = body.bounds;
+  if (!finiteVec3(center) || !finiteVec3(halfExtents) || halfExtents.some((extent) => extent < 0) || halfExtents.every((extent) => extent === 0) || !Number.isFinite(body.opacity) || body.transforms.some((transform) => !validTransform(transform)) || body.transforms.length === 0) {
+    throw new SceneConstraintRefusal(
+      "scene_constraint_bounds_invalid",
+      path,
+      "A constraint body needs finite non-empty local bounds, finite opacity and a valid evaluated transform chain.",
+      { center, halfExtents, transformCount: body.transforms.length }
+    );
+  }
+  const affine = composedAffine(body.transforms);
+  const lengths = affine.basis.map(length);
+  if (lengths.some((axisLength) => !Number.isFinite(axisLength) || axisLength <= 0)) {
+    throw new SceneConstraintRefusal(
+      "scene_constraint_bounds_invalid",
+      path,
+      "The evaluated transform chain produced a degenerate oriented bound.",
+      { lengths }
+    );
+  }
+  const transformedCenter = add(applyLinear(affine.basis, center), affine.translation);
+  const transformedHalfExtents = [
+    halfExtents[0] * lengths[0],
+    halfExtents[1] * lengths[1],
+    halfExtents[2] * lengths[2]
+  ];
+  if (!finiteVec3(transformedCenter) || !finiteVec3(transformedHalfExtents)) {
+    throw new SceneConstraintRefusal(
+      "scene_constraint_bounds_invalid",
+      path,
+      "The evaluated transform chain overflowed the oriented bound.",
+      { center: transformedCenter, halfExtents: transformedHalfExtents }
+    );
+  }
+  return {
+    center: transformedCenter,
+    axes: [
+      affine.basis[0].map((value) => value / lengths[0]),
+      affine.basis[1].map((value) => value / lengths[1]),
+      affine.basis[2].map((value) => value / lengths[2])
+    ],
+    halfExtents: transformedHalfExtents
+  };
+}
+function sceneSeparatingAxisGapV2(a, b) {
+  const centreDelta = [
+    b.center[0] - a.center[0],
+    b.center[1] - a.center[1],
+    b.center[2] - a.center[2]
+  ];
+  let bestGap = -Infinity;
+  const consider = (candidate) => {
+    const axisLength = length(candidate);
+    if (axisLength < 1e-12) return;
+    const axis = candidate.map((value) => value / axisLength);
+    const radiusA = a.halfExtents[0] * Math.abs(dot(a.axes[0], axis)) + a.halfExtents[1] * Math.abs(dot(a.axes[1], axis)) + a.halfExtents[2] * Math.abs(dot(a.axes[2], axis));
+    const radiusB = b.halfExtents[0] * Math.abs(dot(b.axes[0], axis)) + b.halfExtents[1] * Math.abs(dot(b.axes[1], axis)) + b.halfExtents[2] * Math.abs(dot(b.axes[2], axis));
+    bestGap = Math.max(bestGap, Math.abs(dot(centreDelta, axis)) - radiusA - radiusB);
+  };
+  for (const axis of a.axes) consider(axis);
+  for (const axis of b.axes) consider(axis);
+  for (const axisA of a.axes) {
+    for (const axisB of b.axes) consider(cross(axisA, axisB));
+  }
+  if (!Number.isFinite(bestGap)) {
+    throw new SceneConstraintRefusal(
+      "scene_constraint_bounds_invalid",
+      "constraint.bounds",
+      "The separating-axis calculation produced a non-finite gap.",
+      { separatingAxisGap: bestGap }
+    );
+  }
+  return bestGap;
+}
+function evaluateSceneSeparationV2(constraints, frames) {
+  if (constraints.length === 0) return { pairs: [] };
+  if (frames.length === 0) {
+    throw new SceneConstraintRefusal(
+      "scene_constraint_frames_missing",
+      "constraints",
+      "Separation constraints require the complete evaluated content-frame set.",
+      {}
+    );
+  }
+  const pairs = [];
+  constraints.forEach((constraint, constraintIndex) => {
+    frames.forEach(({ frame, resolveBody }) => {
+      const bodies = constraint.objects.map((authoredId, objectIndex) => {
+        const body = resolveBody(authoredId);
+        const path = `constraints.${constraintIndex}.objects.${objectIndex}`;
+        if (body === null || body === void 0) {
+          throw new SceneConstraintRefusal(
+            "scene_constraint_bounds_missing",
+            path,
+            `No evaluated conservative bound was supplied for authored object "${authoredId}" at content frame ${frame}.`,
+            { authoredId, frame }
+          );
+        }
+        return sceneOrientedBoundsV2(body, path);
+      });
+      for (let first = 0; first < bodies.length; first += 1) {
+        for (let second = first + 1; second < bodies.length; second += 1) {
+          const objectPair = [
+            constraint.objects[first],
+            constraint.objects[second]
+          ];
+          const separatingAxisGap = sceneSeparatingAxisGapV2(
+            bodies[first],
+            bodies[second]
+          );
+          if (!Number.isFinite(separatingAxisGap) || !Number.isFinite(constraint.gap)) {
+            throw new SceneConstraintRefusal(
+              "scene_constraint_bounds_invalid",
+              `constraints.${constraintIndex}.gap`,
+              "The required or evaluated separation gap is not finite.",
+              { separatingAxisGap, requiredGap: constraint.gap }
+            );
+          }
+          const result = {
+            constraintIndex,
+            frame,
+            objects: objectPair,
+            separatingAxisGap,
+            requiredGap: constraint.gap
+          };
+          pairs.push(result);
+          if (separatingAxisGap < constraint.gap) {
+            throw new SceneConstraintRefusal(
+              "scene_min_separation_violated",
+              `constraints.${constraintIndex}.gap`,
+              `Objects "${objectPair[0]}" and "${objectPair[1]}" have separating-axis gap ${separatingAxisGap} at content frame ${frame}; required ${constraint.gap}.`,
+              { ...result }
+            );
+          }
+        }
+      }
+    });
+  });
+  return { pairs };
+}
+
+// ../composition/src/scene/examples.ts
+var t = {
+  position: [0, 0, 0],
+  rotation: [0, 0, 0],
+  scale: 1
+};
+var spec = parseSceneShotSpecV2({
+  version: 2,
+  referenceSize: { width: 1920, height: 1080 },
+  environment: { kind: "photographic-studio-v1" },
+  backdrop: { kind: "solid", color: "$brand:colors.background" },
+  layers: [
+    {
+      kind: "group",
+      id: "cards",
+      transform: t,
+      children: [
+        {
+          kind: "slab",
+          id: "hero",
+          transform: t,
+          width: 720,
+          height: 900,
+          finish: "satin",
+          surfaces: {
+            front: {
+              source: "component",
+              component: {
+                version: 1,
+                componentId: "hero-card",
+                sourceVersionId: "0".repeat(64)
+              },
+              captureFrame: 12,
+              layout: { width: 720, height: 900 }
+            }
+          }
+        },
+        {
+          kind: "page",
+          id: "page",
+          transform: { ...t, position: [760, 0, -20] },
+          width: 640,
+          height: 800,
+          surfaces: { content: { source: "image", assetSlot: "page" } }
+        }
+      ]
+    }
+  ],
+  animation: [
+    {
+      target: { kind: "layer", layerId: "cards" },
+      property: "rotationY",
+      keyframes: [
+        { at: 0, value: 0 },
+        { at: 1, value: Math.PI * 6, easing: { kind: "linear" } }
+      ]
+    }
+  ]
+});
+var SCENE_SHOT_EXAMPLES = [
+  {
+    id: "world-objects",
+    title: "World objects",
+    summary: "Nested satin card and fitted page.",
+    slots: sceneShotImageSlots(spec),
+    spec
+  }
+];
+var sceneShotExample = (id) => SCENE_SHOT_EXAMPLES.find((example) => example.id === id) ?? null;
+function assertSceneShotExamplesValid() {
+  for (const example of SCENE_SHOT_EXAMPLES) SceneShotSpecV2.parse(example.spec);
+}
+
+// ../composition/src/scene/budget.ts
+var STUDIO_SHADOW_MAP_BUDGET = 4096;
+var SCENE_TESSELLATION_VERSION = 1;
+var SCENE_SLAB_BODY_TRIANGLES = 5484;
+var SCENE_SLAB_CONTENT_FACE_TRIANGLES = 2;
+var SCENE_SLAB_CONTENT_OFFSET = 0.6;
+var SCENE_PRESET_TRIANGLES = Object.freeze({
+  laptop: 1954,
+  phone: 3136,
+  slab: 5486,
+  page: 2
+});
+var BYTES_PER_TEXEL = Object.freeze({
+  rgba8: 4,
+  rgba16f: 8,
+  rgba32f: 16,
+  depth24: 4
+});
+function positiveInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`scene_allocation_declaration_invalid: ${field}`);
+  }
+  return value;
+}
+function sceneFullMipLevels(width, height) {
+  positiveInteger(width, "width");
+  positiveInteger(height, "height");
+  return Math.floor(Math.log2(Math.max(width, height))) + 1;
+}
+function sceneMipTexels(width, height, mipLevels) {
+  positiveInteger(width, "width");
+  positiveInteger(height, "height");
+  positiveInteger(mipLevels, "mipLevels");
+  const maximum = sceneFullMipLevels(width, height);
+  if (mipLevels > maximum) {
+    throw new Error(`scene_allocation_declaration_invalid: mipLevels exceeds full chain ${maximum}`);
+  }
+  let texels = 0;
+  for (let level = 0; level < mipLevels; level += 1) {
+    texels += Math.max(1, Math.floor(width / 2 ** level)) * Math.max(1, Math.floor(height / 2 ** level));
+  }
+  if (!Number.isSafeInteger(texels)) throw new Error("scene_allocation_declaration_invalid: texel count");
+  return texels;
+}
+function sceneTextureBytes(allocation2) {
+  const faces = positiveInteger(allocation2.faces ?? 1, "faces");
+  const layers = positiveInteger(allocation2.layers ?? 1, "layers");
+  const samples = positiveInteger(allocation2.samples ?? 1, "samples");
+  const bytes = sceneMipTexels(allocation2.width, allocation2.height, allocation2.mipLevels) * BYTES_PER_TEXEL[allocation2.format] * faces * layers * samples;
+  if (!Number.isSafeInteger(bytes)) throw new Error("scene_allocation_declaration_invalid: byte count");
+  return bytes;
+}
+function sceneTriangleCount(presets) {
+  const total = presets.reduce((sum, preset) => {
+    if (!Object.prototype.hasOwnProperty.call(SCENE_PRESET_TRIANGLES, preset)) {
+      throw new Error(`scene_triangle_preset_unsupported: ${String(preset)}`);
+    }
+    return sum + SCENE_PRESET_TRIANGLES[preset];
+  }, 0);
+  if (!Number.isSafeInteger(total)) throw new Error("scene_triangle_declaration_invalid");
+  return total;
+}
+
+// ../composition/src/scene/device.ts
+function sceneDeviceDimensionsV1(kind, width) {
+  return kind === "phone" ? { w: width, h: Math.round(width * 2.05), t: Math.round(width * 0.03), d: 0, screenInset: Math.round(width * 0.035), radius: Math.round(width * 0.13) } : { w: width, h: Math.round(width * 0.66), t: Math.round(width * 0.011), d: Math.round(width * 0.68), screenInset: Math.round(width * 0.02), radius: Math.round(width * 0.012) };
+}
+function sceneLaptopLayoutV1(dim) {
+  const baseY = -dim.h * 0.32;
+  return { baseY, hingeFromBaseY: dim.t / 2, hingeZ: -dim.d / 2, hingeY: baseY + dim.t / 2, lidCentreY: dim.h / 2, bottomY: baseY - dim.t / 2 };
+}
+var SCENE_DEVICE_SCREEN_OFFSET_V1 = 0.6;
+function sceneLaptopScreenQuadV1(node) {
+  const dim = sceneDeviceDimensionsV1("laptop", node.width);
+  const layout = sceneLaptopLayoutV1(dim);
+  const theta = Math.PI / 2 - node.openAngle;
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  const w = dim.w * 0.86 / 2;
+  const h = dim.h * 0.86 / 2;
+  const z2 = dim.t / 2 + SCENE_DEVICE_SCREEN_OFFSET_V1;
+  const point = (x, y) => [x, layout.hingeY + (layout.lidCentreY + y) * c - z2 * s, layout.hingeZ + (layout.lidCentreY + y) * s + z2 * c];
+  return [point(-w, h), point(w, h), point(w, -h), point(-w, -h)];
+}
+
+// ../composition/src/scene/photographicRig.ts
+var PHOTOGRAPHIC_STUDIO_RIG_ID = "photographic-studio-v1";
+var PHOTOGRAPHIC_STUDIO_HDRI_PATH = "environments/brown_photostudio_02.hdr";
+var PHOTOGRAPHIC_STUDIO_HDRI_SHA256 = "469abc5e6035b6c450bae8adbb448f8d1fa7c51d9e384e501516c28352c91b58";
+var PHOTOGRAPHIC_STUDIO_HDRI_BYTES = 1648130;
+var PHOTOGRAPHIC_STUDIO_PMREM_VERSION = "three-0.183.2-fromEquirectangular-cubeuv256-v1";
+var PHOTOGRAPHIC_STUDIO_LIGHTING_VERSION = 1;
+var PHOTOGRAPHIC_STUDIO_EDGE_INTENSITY = 26;
+var PHOTOGRAPHIC_STUDIO_EDGE_LIGHTS = Object.freeze([
+  Object.freeze([2e3, 350, -700]),
+  Object.freeze([-2e3, 350, -700])
+]);
+var PHOTOGRAPHIC_STUDIO_GPU_BYTES = Object.freeze({
+  sourceRgba16f: 1024 * 512 * 8,
+  pmremTargetRgba16f: 768 * 1024 * 8,
+  pmremTransientRgba16f: 768 * 1024 * 8,
+  preparationPeak: 1024 * 512 * 8 + 2 * 768 * 1024 * 8,
+  retained: 768 * 1024 * 8
+});
+var PHOTOGRAPHIC_STUDIO_RIG_FACTS = Object.freeze({
+  rigId: PHOTOGRAPHIC_STUDIO_RIG_ID,
+  hdri: Object.freeze({
+    path: PHOTOGRAPHIC_STUDIO_HDRI_PATH,
+    sha256: PHOTOGRAPHIC_STUDIO_HDRI_SHA256,
+    bytes: PHOTOGRAPHIC_STUDIO_HDRI_BYTES
+  }),
+  pmremVersion: PHOTOGRAPHIC_STUDIO_PMREM_VERSION,
+  lightingVersion: PHOTOGRAPHIC_STUDIO_LIGHTING_VERSION,
+  studioPreset: "soft",
+  hemisphere: Object.freeze({ skyColor: "#ffffff", groundColor: "#202024", intensity: 0.7 }),
+  studioLights: Object.freeze([
+    Object.freeze({ role: "key", position: Object.freeze([700, 1100, 1300]), intensity: 1.6, castShadow: false }),
+    Object.freeze({ role: "fill", position: Object.freeze([-1100, 400, 900]), intensity: 0.9, castShadow: false }),
+    Object.freeze({ role: "rim", position: Object.freeze([0, 1300, -1900]), intensity: 1, castShadow: false })
+  ]),
+  edgeLights: Object.freeze(
+    PHOTOGRAPHIC_STUDIO_EDGE_LIGHTS.map(
+      (position) => Object.freeze({ position, intensity: PHOTOGRAPHIC_STUDIO_EDGE_INTENSITY, castShadow: false })
+    )
+  ),
+  environmentIntensity: 1,
+  floor: "none",
+  shadows: "none",
+  gpuBytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES
+});
+function photographicStudioPreparationFactsV1(worldScale) {
+  return {
+    identity: {
+      rigId: PHOTOGRAPHIC_STUDIO_RIG_FACTS.rigId,
+      hdriSha256: PHOTOGRAPHIC_STUDIO_RIG_FACTS.hdri.sha256,
+      pmremVersion: PHOTOGRAPHIC_STUDIO_RIG_FACTS.pmremVersion,
+      lightingVersion: PHOTOGRAPHIC_STUDIO_RIG_FACTS.lightingVersion,
+      worldScale,
+      hemisphere: PHOTOGRAPHIC_STUDIO_RIG_FACTS.hemisphere,
+      lightLayout: PHOTOGRAPHIC_STUDIO_RIG_FACTS.studioLights,
+      edgeLightLayout: PHOTOGRAPHIC_STUDIO_RIG_FACTS.edgeLights,
+      environmentIntensity: PHOTOGRAPHIC_STUDIO_RIG_FACTS.environmentIntensity,
+      floor: PHOTOGRAPHIC_STUDIO_RIG_FACTS.floor,
+      shadows: PHOTOGRAPHIC_STUDIO_RIG_FACTS.shadows,
+      retainedGpuBytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.retained,
+      preparationPeakGpuBytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.preparationPeak
+    },
+    allocations: [
+      { owner: "rig:photographic-studio-v1", name: "encoded-hdri", domain: "cpu", resource: "encoded-image", format: "rgbe", bytes: PHOTOGRAPHIC_STUDIO_HDRI_BYTES, lifetime: "preparation" },
+      { owner: "rig:photographic-studio-v1", name: "encoded-hdri-working-copy", domain: "cpu", resource: "encoded-image", format: "rgbe", bytes: PHOTOGRAPHIC_STUDIO_HDRI_BYTES, lifetime: "preparation" },
+      { owner: "rig:photographic-studio-v1", name: "decoded-hdri", domain: "cpu", resource: "decoded-image", format: "rgba16f", bytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.sourceRgba16f, lifetime: "preparation" },
+      { owner: "rig:photographic-studio-v1", name: "rgbe-source", domain: "gl", resource: "pmrem-source", format: "rgba16f", bytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.sourceRgba16f, lifetime: "preparation" },
+      { owner: "rig:photographic-studio-v1", name: "pmrem-transient", domain: "gl", resource: "pmrem-target", format: "rgba16f", bytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.pmremTransientRgba16f, lifetime: "preparation" },
+      { owner: "rig:photographic-studio-v1", name: "pmrem-environment", domain: "gl", resource: "pmrem-target", format: "rgba16f", bytes: PHOTOGRAPHIC_STUDIO_GPU_BYTES.pmremTargetRgba16f, lifetime: "context" }
+    ]
+  };
+}
+var GRAIN_LATTICE_BYTES = 24672;
+function sceneFocusPreparationAllocationsV1(width, height, samples = 4) {
+  if (!Number.isSafeInteger(width) || width <= 0 || !Number.isSafeInteger(height) || height <= 0)
+    throw new Error("scene_focus_allocation_dimensions_invalid");
+  if (samples !== 4) throw new Error("scene_focus_allocation_samples_invalid");
+  const pixels = width * height;
+  return [
+    { owner: "post:focus-resources", name: "world-color-resolve", domain: "gl", resource: "texture", format: "rgba16f", bytes: pixels * 8, lifetime: "context" },
+    { owner: "post:focus-resources", name: "world-depth", domain: "gl", resource: "texture", format: "depth32u", bytes: pixels * 4, lifetime: "context" },
+    { owner: "post:focus-resources", name: "gathered-color", domain: "gl", resource: "texture", format: "rgba16f", bytes: pixels * 8, lifetime: "context" },
+    { owner: "post:focus-resources", name: "grain-lattice", domain: "gl", resource: "texture", format: "rgba32f", bytes: GRAIN_LATTICE_BYTES, lifetime: "context" },
+    { owner: "post:focus-resources", name: "grain-lattice-array", domain: "cpu", resource: "decoded-image", format: "rgba32f", bytes: GRAIN_LATTICE_BYTES, lifetime: "context" },
+    { owner: "post:focus-resources", name: "world-color-msaa", domain: "gl", resource: "renderbuffer", format: "rgba16f-msaa-4", bytes: pixels * 8 * 4, lifetime: "context" },
+    { owner: "post:focus-resources", name: "world-depth-msaa", domain: "gl", resource: "renderbuffer", format: "depth32u-msaa-4", bytes: pixels * 4 * 4, lifetime: "context" }
+  ];
+}
+function photographicSceneRigFactsV1(worldScale, width, height) {
+  const rig = photographicStudioPreparationFactsV1(worldScale);
+  return { identity: rig.identity, allocations: [...rig.allocations, ...sceneFocusPreparationAllocationsV1(width, height, 4)] };
+}
+
+// ../composition/src/scene/videoSchedule.ts
+var SceneVideoAdmissionRefusal = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message} ${code.startsWith("video_") && (code === "video_presentation_index_missing" || code === "video_variable_frame_rate") ? "Render or transcode this asset to CFR with the existing media tools, then prepare the scene again." : ""}`.trim());
+    this.code = code;
+    this.name = "SceneVideoAdmissionRefusal";
+  }
+  code;
+  corrective = "Render or transcode this asset to CFR with the existing media tools, then prepare the scene again.";
+};
+function positiveInteger2(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new SceneVideoAdmissionRefusal("video_rate_invalid", `${field} must be a positive safe integer.`);
+  return BigInt(value);
+}
+function gcd(a, b) {
+  while (b !== 0n) [a, b] = [b, a % b];
+  return a;
+}
+function canonicalSceneVideoRateV1(value, field = "rate") {
+  const num = positiveInteger2(value.num, `${field}.num`);
+  const den = positiveInteger2(value.den, `${field}.den`);
+  const divisor = gcd(num, den);
+  return { num: Number(num / divisor), den: Number(den / divisor) };
+}
+function canonicalBigRate(num, den, field) {
+  const divisor = gcd(num, den);
+  const n = num / divisor;
+  const d = den / divisor;
+  if (n > BigInt(Number.MAX_SAFE_INTEGER) || d > BigInt(Number.MAX_SAFE_INTEGER)) throw new SceneVideoAdmissionRefusal("video_rate_invalid", `${field} exceeds exact safe-integer transport.`);
+  return { num: Number(n), den: Number(d) };
+}
+function verifySceneVideoPresentationIndexV1(index) {
+  if (!index || !Array.isArray(index.pts) || index.pts.length < 2) {
+    throw new SceneVideoAdmissionRefusal("video_presentation_index_missing", "At least two verified presentation timestamps are required.");
+  }
+  if (!index.pts.every(Number.isSafeInteger)) {
+    throw new SceneVideoAdmissionRefusal("video_presentation_index_missing", "Presentation timestamps must be exact integers in the verified stream time base.");
+  }
+  const step = index.pts[1] - index.pts[0];
+  if (step <= 0 || index.pts.some((pts, i) => i > 0 && pts - index.pts[i - 1] !== step)) {
+    throw new SceneVideoAdmissionRefusal("video_variable_frame_rate", "Presentation timestamps do not form one constant positive interval.");
+  }
+  const timeBase = canonicalSceneVideoRateV1(index.timeBase, "timeBase");
+  return {
+    sourceRate: canonicalBigRate(BigInt(timeBase.den), BigInt(timeBase.num) * BigInt(step), "sourceRate"),
+    sourceFrameCount: index.pts.length
+  };
+}
+function prepareSceneVideoScheduleV1(input) {
+  const { sourceRate, sourceFrameCount } = verifySceneVideoPresentationIndexV1(input.presentationIndex);
+  const shotRate = canonicalSceneVideoRateV1(input.shotRate, "shotRate");
+  if (!Number.isSafeInteger(input.contentDuration) || input.contentDuration <= 0) throw new SceneVideoAdmissionRefusal("video_rate_invalid", "contentDuration must be a positive safe integer.");
+  if (!Number.isSafeInteger(input.startFrame) || input.endFrame !== void 0 && !Number.isSafeInteger(input.endFrame)) {
+    throw new SceneVideoAdmissionRefusal("video_trim_not_integer", "Video trims are presentation-frame indices.");
+  }
+  const endFrame = input.endFrame ?? sourceFrameCount;
+  if (input.startFrame < 0 || endFrame <= input.startFrame || endFrame > sourceFrameCount) {
+    throw new SceneVideoAdmissionRefusal("video_trim_out_of_range", "Expected 0 <= startFrame < endFrame <= sourceFrameCount.");
+  }
+  return { sourceRate, shotRate, contentDuration: input.contentDuration, startFrame: input.startFrame, endFrame, sourceFrameCount, addressing: "midpoint" };
+}
+function sceneVideoSourceIndexV1(frame, schedule) {
+  if (!Number.isSafeInteger(frame) || frame < 0) throw new SceneVideoAdmissionRefusal("video_rate_invalid", "content frame must be a nonnegative safe integer.");
+  const c = BigInt(Math.min(frame, schedule.contentDuration - 1));
+  const numerator = c * BigInt(schedule.sourceRate.num) * BigInt(schedule.shotRate.den);
+  const denominator = BigInt(schedule.sourceRate.den) * BigInt(schedule.shotRate.num);
+  const selected = BigInt(schedule.startFrame) + numerator / denominator;
+  return Number(selected < BigInt(schedule.endFrame) ? selected : BigInt(schedule.endFrame - 1));
+}
+function sceneVideoMidpointAddressV1(frame, schedule) {
+  const sourceIndex = sceneVideoSourceIndexV1(frame, schedule);
+  return {
+    sourceIndex,
+    mediaFrame: sourceIndex * 2 + 1,
+    playbackRate: schedule.shotRate.num * schedule.sourceRate.den / (schedule.shotRate.den * 2 * schedule.sourceRate.num)
+  };
+}
+
+// ../composition/src/scene/resolution.ts
+var RESOLUTION_BOUND = 1;
+var ALLOWED_BAKE_SCALES = [2, 3];
+var DEFAULT_BAKE_SCALE = 2;
+function sceneCameraPlanesV2(referenceHeight, fov, scale) {
+  const perspective = referenceHeight / (2 * Math.tan(fov / 2));
+  const p = perspective * scale;
+  return { near: p / 100, far: p * 40 };
+}
+var SceneResolutionRefusal = class extends Error {
+  code;
+  path;
+  detail;
+  constructor(code, message, path, detail) {
+    super(message);
+    this.name = "SceneResolutionRefusal";
+    this.code = code;
+    this.path = path;
+    this.detail = detail;
+  }
+};
+var IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+function mul(a, b) {
+  const o = new Array(16).fill(0);
+  for (let c = 0; c < 4; c += 1) {
+    for (let r = 0; r < 4; r += 1) {
+      let s = 0;
+      for (let k = 0; k < 4; k += 1) s += a[k * 4 + r] * b[c * 4 + k];
+      o[c * 4 + r] = s;
+    }
+  }
+  return o;
+}
+var translate = (x, y, z2) => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z2, 1];
+var scaleM = (s) => [s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1];
+var rotX = (a) => {
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  return [1, 0, 0, 0, 0, c, s, 0, 0, -s, c, 0, 0, 0, 0, 1];
+};
+var rotY = (a) => {
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  return [c, 0, -s, 0, 0, 1, 0, 0, s, 0, c, 0, 0, 0, 0, 1];
+};
+var rotZ = (a) => {
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  return [c, s, 0, 0, -s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+};
+var applyM = (m, p) => [
+  m[0] * p[0] + m[4] * p[1] + m[8] * p[2] + m[12],
+  m[1] * p[0] + m[5] * p[1] + m[9] * p[2] + m[13],
+  m[2] * p[0] + m[6] * p[1] + m[10] * p[2] + m[14]
+];
+function trs(t2, scale) {
+  return mul(
+    mul(
+      translate(t2.position[0] * scale, t2.position[1] * scale, t2.position[2] * scale),
+      mul(rotX(t2.rotation[0]), mul(rotY(t2.rotation[1]), rotZ(t2.rotation[2])))
+    ),
+    scaleM(t2.scale)
+  );
+}
+function projectToOutputPixels(world, camera, output, scale) {
+  const eye = [camera.position[0] * scale, camera.position[1] * scale, camera.position[2] * scale];
+  const R = mul(rotX(camera.rotation[0]), mul(rotY(camera.rotation[1]), rotZ(camera.rotation[2])));
+  const d = [world[0] - eye[0], world[1] - eye[1], world[2] - eye[2]];
+  const cam = [
+    R[0] * d[0] + R[1] * d[1] + R[2] * d[2],
+    R[4] * d[0] + R[5] * d[1] + R[6] * d[2],
+    R[8] * d[0] + R[9] * d[1] + R[10] * d[2]
+  ];
+  if (cam[2] >= -1e-9) return null;
+  const P = output.height / (2 * Math.tan(camera.fov / 2));
+  return [output.width / 2 + P * cam[0] / -cam[2], output.height / 2 - P * cam[1] / -cam[2]];
+}
+var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+function projectedSlotEdges({ slot, chain, camera, output, referenceSize, projectionQuad, path, frame }) {
+  const scale = output.width / referenceSize.width;
+  let m = IDENTITY;
+  for (const t2 of chain) m = mul(m, trs(t2, scale));
+  const hw = slot.width * scale / 2;
+  const hh = slot.height * scale / 2;
+  const supplied = projectionQuad;
+  const local = supplied ? {
+    tl: supplied[0].map((v) => v * scale),
+    tr: supplied[1].map((v) => v * scale),
+    br: supplied[2].map((v) => v * scale),
+    bl: supplied[3].map((v) => v * scale)
+  } : { tl: [-hw, hh, 0], tr: [hw, hh, 0], br: [hw, -hh, 0], bl: [-hw, -hh, 0] };
+  const p = {};
+  for (const key of ["tl", "tr", "br", "bl"]) {
+    const q = projectToOutputPixels(applyM(m, local[key]), camera, output, scale);
+    if (!q) return { behindEye: true, corner: key };
+    p[key] = q;
+  }
+  const widthPx = (dist(p.tl, p.tr) + dist(p.bl, p.br)) / 2;
+  const heightPx = (dist(p.tl, p.bl) + dist(p.tr, p.br)) / 2;
+  if (!Number.isFinite(widthPx) || !Number.isFinite(heightPx) || widthPx <= 0 || heightPx <= 0) {
+    throw new SceneResolutionRefusal(
+      "scene_surface_resolution_insufficient",
+      "Projected slot edges are non-finite or degenerate.",
+      path ?? "surface.projection",
+      { widthPx, heightPx, ...frame === void 0 ? {} : { frame } }
+    );
+  }
+  return { behindEye: false, widthPx, heightPx, corners: p };
+}
+function checkSurfaceResolution(args) {
+  const { surfaceId, slotName, slot, layout, bakeScale, contentDuration, output, referenceSize, evaluate } = args;
+  const raster = { width: layout.width * bakeScale, height: layout.height * bakeScale };
+  let worst = Infinity;
+  let worstAt = null;
+  for (let f = 0; f < contentDuration; f += 1) {
+    const { camera, chain, projectionQuad } = evaluate(f);
+    const e = projectedSlotEdges({ slot, chain, camera, output, referenceSize, projectionQuad, path: `layers.${surfaceId}.surfaces.${slotName}`, frame: f });
+    if (e.behindEye) {
+      throw new SceneResolutionRefusal(
+        "scene_surface_behind_eye",
+        `"${surfaceId}" slot "${slotName}" puts corner ${e.corner} at or behind the eye plane at content frame ${f}; projected magnification is unbounded there, so this is refused rather than clamped.`,
+        `layers.${surfaceId}.surfaces.${slotName}`,
+        { frame: f, corner: e.corner }
+      );
+    }
+    const densityU = raster.width / e.widthPx;
+    const densityV = raster.height / e.heightPx;
+    const d = Math.min(densityU, densityV);
+    if (d < worst) {
+      worst = d;
+      worstAt = { frame: f, densityU, densityV, axis: densityU <= densityV ? "U" : "V", widthPx: e.widthPx, heightPx: e.heightPx };
+    }
+  }
+  if (!worstAt) {
+    throw new SceneResolutionRefusal(
+      "scene_surface_resolution_insufficient",
+      `"${surfaceId}" slot "${slotName}" has a content duration of ${contentDuration} frames, so the check has no frame to evaluate.`,
+      `layers.${surfaceId}.surfaces.${slotName}`,
+      { contentDuration }
+    );
+  }
+  return { raster, bakeScale, worstDensity: worst, worstAt, meetsBound: worst >= RESOLUTION_BOUND, bound: RESOLUTION_BOUND };
+}
+function correctiveLayout(args, worst) {
+  return {
+    width: Math.ceil(args.layout.width / worst.worstDensity),
+    height: Math.ceil(args.layout.height / worst.worstDensity)
+  };
+}
+function selectSceneBakeScale(args, declared) {
+  const results = {};
+  for (const s of ALLOWED_BAKE_SCALES) results[s] = checkSurfaceResolution({ ...args, bakeScale: s });
+  const sufficient = ALLOWED_BAKE_SCALES.filter((s) => results[s].meetsBound);
+  if (declared !== void 0) {
+    if (results[declared].meetsBound) return { selected: declared, reason: "declared", results };
+    const needed = sufficient.length ? Math.min(...sufficient) : null;
+    const worst = results[declared];
+    throw new SceneResolutionRefusal(
+      "scene_surface_resolution_insufficient",
+      `"${args.surfaceId}" slot "${args.slotName}" declares bakeScale ${declared}x, which gives ${worst.worstDensity.toFixed(3)} source texels per output pixel on the ${worst.worstAt.axis} axis at content frame ${worst.worstAt.frame} (bound ${RESOLUTION_BOUND}). ` + (needed ? `Declare bakeScale ${needed}x.` : `No supported bake scale (${ALLOWED_BAKE_SCALES.join("x, ")}x) reaches the bound; increase the declared layout from ${args.layout.width}x${args.layout.height} to at least ${correctiveLayout(args, worst).width}x${correctiveLayout(args, worst).height}, or move the surface further from the camera.`),
+      `layers.${args.surfaceId}.surfaces.${args.slotName}`,
+      { declared, worst, neededScale: needed, correctiveLayout: correctiveLayout(args, worst) }
+    );
+  }
+  if (!sufficient.length) {
+    const largest = Math.max(...ALLOWED_BAKE_SCALES);
+    const best = results[largest];
+    throw new SceneResolutionRefusal(
+      "scene_surface_resolution_insufficient",
+      `"${args.surfaceId}" slot "${args.slotName}" reaches only ${best.worstDensity.toFixed(3)} source texels per output pixel on the ${best.worstAt.axis} axis at content frame ${best.worstAt.frame} even at ${largest}x (bound ${RESOLUTION_BOUND}). Increase the declared layout from ${args.layout.width}x${args.layout.height} to at least ${correctiveLayout(args, best).width}x${correctiveLayout(args, best).height}, or move the surface further from the camera.`,
+      `layers.${args.surfaceId}.surfaces.${args.slotName}`,
+      { worst: best, neededScale: null, correctiveLayout: correctiveLayout(args, best) }
+    );
+  }
+  const selected = Math.min(...sufficient);
+  return {
+    selected,
+    reason: selected === DEFAULT_BAKE_SCALE ? "default-sufficient" : "raised-by-resolution-check",
+    results
+  };
+}
+
+// ../composition/src/scene/preparedRender.ts
+var ScenePreparedPlanRefusal = class extends Error {
+  constructor(path, message) {
+    super(message);
+    this.path = path;
+    this.name = "ScenePreparedPlanRefusal";
+  }
+  path;
+};
+function record(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new ScenePreparedPlanRefusal(path, `${path} must be an object.`);
+  return value;
+}
+function exactKeys(value, keys, path) {
+  const unknown = Object.keys(value).find((key) => !keys.includes(key));
+  if (unknown) throw new ScenePreparedPlanRefusal(`${path}.${unknown}`, `Unknown sealed plan field ${path}.${unknown}.`);
+  const missing = keys.find((key) => value[key] === void 0);
+  if (missing) throw new ScenePreparedPlanRefusal(`${path}.${missing}`, `Missing sealed plan field ${path}.${missing}.`);
+}
+function finiteNumber(value, path, options = {}) {
+  if (typeof value !== "number" || !Number.isFinite(value) || options.integer && !Number.isSafeInteger(value) || options.positive && value <= 0 || options.nonnegative && value < 0)
+    throw new ScenePreparedPlanRefusal(path, `${path} is invalid.`);
+  return value;
+}
+function stringValue(value, path) {
+  if (typeof value !== "string" || value.length === 0) throw new ScenePreparedPlanRefusal(path, `${path} must be a non-empty string.`);
+  return value;
+}
+function booleanValue(value, path) {
+  if (typeof value !== "boolean") throw new ScenePreparedPlanRefusal(path, `${path} must be boolean.`);
+  return value;
+}
+function arrayValue(value, path) {
+  if (!Array.isArray(value)) throw new ScenePreparedPlanRefusal(path, `${path} must be an array.`);
+  return value;
+}
+function enumValue(value, values, path) {
+  if (typeof value !== "string" || !values.includes(value)) throw new ScenePreparedPlanRefusal(path, `${path} is invalid.`);
+  return value;
+}
+function sha256Value(value, path) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw new ScenePreparedPlanRefusal(path, `${path} must be a lowercase SHA-256 digest.`);
+  return value;
+}
+function allocation(value, path) {
+  const row = record(value, path);
+  exactKeys(row, ["owner", "name", "domain", "resource", "format", "bytes", "lifetime"], path);
+  stringValue(row.owner, `${path}.owner`);
+  stringValue(row.name, `${path}.name`);
+  stringValue(row.format, `${path}.format`);
+  if (!["gl", "cpu"].includes(row.domain)) throw new ScenePreparedPlanRefusal(`${path}.domain`, "Invalid allocation domain.");
+  if (!["texture", "renderbuffer", "geometry", "pmrem-source", "pmrem-target", "encoded-image", "decoded-image", "encoded-video", "decoded-video"].includes(row.resource))
+    throw new ScenePreparedPlanRefusal(`${path}.resource`, "Invalid allocation resource.");
+  if (!["preparation", "context"].includes(row.lifetime)) throw new ScenePreparedPlanRefusal(`${path}.lifetime`, "Invalid allocation lifetime.");
+  finiteNumber(row.bytes, `${path}.bytes`, {
+    integer: true,
+    nonnegative: true
+  });
+}
+function allocationArray(value, path) {
+  if (!Array.isArray(value)) throw new ScenePreparedPlanRefusal(path, `${path} must be an array.`);
+  value.forEach((entry, index) => allocation(entry, `${path}.${index}`));
+}
+function vec3(value, path) {
+  if (!Array.isArray(value) || value.length !== 3) throw new ScenePreparedPlanRefusal(path, `${path} must be a vec3.`);
+  value.forEach((entry, index) => finiteNumber(entry, `${path}.${index}`));
+}
+function slotDescriptor(value, path) {
+  const slot = record(value, path);
+  exactKeys(slot, ["slot", "attachment", "dimensions", "projectionQuad", "uvOrigin", "fit", "alpha", "depth", "required", "bakeScales"], path);
+  stringValue(slot.slot, `${path}.slot`);
+  const attachment = record(slot.attachment, `${path}.attachment`);
+  exactKeys(attachment, ["partId", "materialRole"], `${path}.attachment`);
+  stringValue(attachment.partId, `${path}.attachment.partId`);
+  stringValue(attachment.materialRole, `${path}.attachment.materialRole`);
+  const dimensions = record(slot.dimensions, `${path}.dimensions`);
+  exactKeys(dimensions, ["width", "height"], `${path}.dimensions`);
+  finiteNumber(dimensions.width, `${path}.dimensions.width`, {
+    positive: true
+  });
+  finiteNumber(dimensions.height, `${path}.dimensions.height`, {
+    positive: true
+  });
+  const quad = arrayValue(slot.projectionQuad, `${path}.projectionQuad`);
+  if (quad.length !== 4) throw new ScenePreparedPlanRefusal(`${path}.projectionQuad`, "Projection quad must contain four points.");
+  quad.forEach((point, index) => vec3(point, `${path}.projectionQuad.${index}`));
+  enumValue(slot.uvOrigin, ["top-left", "bottom-left"], `${path}.uvOrigin`);
+  enumValue(slot.fit, ["contain", "cover", "stretch"], `${path}.fit`);
+  enumValue(slot.alpha, ["opaque", "straight", "premultiplied"], `${path}.alpha`);
+  enumValue(slot.depth, ["write", "test-only"], `${path}.depth`);
+  booleanValue(slot.required, `${path}.required`);
+  const scales = arrayValue(slot.bakeScales, `${path}.bakeScales`);
+  if (scales.length !== 2 || scales[0] !== 2 || scales[1] !== 3) throw new ScenePreparedPlanRefusal(`${path}.bakeScales`, "Bake scales must be exactly [2,3].");
+}
+function descriptor(value, path) {
+  const row = record(value, path);
+  exactKeys(
+    row,
+    ["kind", "builderVersion", "tessellationVersion", "budgetTriangles", "parts", "surfaceSlots", "materialRoles", "localBounds", "allocations"],
+    path
+  );
+  enumValue(row.kind, ["laptop", "phone", "slab", "page", "text"], `${path}.kind`);
+  finiteNumber(row.builderVersion, `${path}.builderVersion`, {
+    integer: true,
+    positive: true
+  });
+  finiteNumber(row.tessellationVersion, `${path}.tessellationVersion`, {
+    integer: true,
+    positive: true
+  });
+  finiteNumber(row.budgetTriangles, `${path}.budgetTriangles`, {
+    integer: true,
+    nonnegative: true
+  });
+  const presetBudget = SCENE_PRESET_TRIANGLES[row.kind];
+  if (presetBudget !== void 0 && row.budgetTriangles !== presetBudget)
+    throw new ScenePreparedPlanRefusal(`${path}.budgetTriangles`, "Builder budget differs from the frozen preset ceiling.");
+  const parts = arrayValue(row.parts, `${path}.parts`);
+  const slots = arrayValue(row.surfaceSlots, `${path}.surfaceSlots`);
+  const roles = arrayValue(row.materialRoles, `${path}.materialRoles`);
+  if (!roles.length) throw new ScenePreparedPlanRefusal(`${path}.materialRoles`, "At least one material role is required.");
+  roles.forEach((role, index) => stringValue(role, `${path}.materialRoles.${index}`));
+  if (new Set(roles).size !== roles.length) throw new ScenePreparedPlanRefusal(`${path}.materialRoles`, "Material roles must be unique.");
+  parts.forEach((entry, index) => {
+    const part = record(entry, `${path}.parts.${index}`);
+    exactKeys(part, ["partId", "materialRole", "triangles", "mounted"], `${path}.parts.${index}`);
+    stringValue(part.partId, `${path}.parts.${index}.partId`);
+    stringValue(part.materialRole, `${path}.parts.${index}.materialRole`);
+    finiteNumber(part.triangles, `${path}.parts.${index}.triangles`, {
+      integer: true,
+      nonnegative: true
+    });
+    if (typeof part.mounted !== "boolean") throw new ScenePreparedPlanRefusal(`${path}.parts.${index}.mounted`, "mounted must be boolean.");
+  });
+  slots.forEach((entry, index) => slotDescriptor(entry, `${path}.surfaceSlots.${index}`));
+  const bounds = record(row.localBounds, `${path}.localBounds`);
+  exactKeys(bounds, ["center", "halfExtents"], `${path}.localBounds`);
+  vec3(bounds.center, `${path}.localBounds.center`);
+  vec3(bounds.halfExtents, `${path}.localBounds.halfExtents`);
+  allocationArray(row.allocations, `${path}.allocations`);
+  const halfExtents = bounds.halfExtents;
+  if (halfExtents.some((entry) => entry < 0) || halfExtents.every((entry) => entry === 0))
+    throw new ScenePreparedPlanRefusal(`${path}.localBounds.halfExtents`, "Bounds must be nonnegative and nondegenerate.");
+  const partRows = parts;
+  if (new Set(partRows.map((part) => part.partId)).size !== partRows.length) throw new ScenePreparedPlanRefusal(`${path}.parts`, "Part ids must be unique.");
+  for (const part of partRows) if (!roles.includes(part.materialRole)) throw new ScenePreparedPlanRefusal(`${path}.parts`, "Part material role is undeclared.");
+  const slotRows = slots;
+  if (new Set(slotRows.map((slot) => slot.slot)).size !== slotRows.length)
+    throw new ScenePreparedPlanRefusal(`${path}.surfaceSlots`, "Slot ids must be unique.");
+  for (const slot of slotRows) {
+    const attachment = slot.attachment;
+    const part = partRows.find((entry) => entry.partId === attachment.partId);
+    if (!part || part.materialRole !== attachment.materialRole)
+      throw new ScenePreparedPlanRefusal(`${path}.surfaceSlots`, "Slot attachment does not match a declared part.");
+  }
+}
+function validateSlabDescriptor(value, slab, path) {
+  const builder = value;
+  if (builder.builderVersion !== 1) throw new ScenePreparedPlanRefusal(`${path}.builderVersion`, "Slab builder version must be 1.");
+  if (builder.tessellationVersion !== 1) throw new ScenePreparedPlanRefusal(`${path}.tessellationVersion`, "Slab tessellation version must be 1.");
+  const parts = builder.parts;
+  const bound = slab.surfaces?.front !== void 0;
+  if (parts.length !== 2 || parts[0]?.partId !== "body" || parts[0]?.materialRole !== "body" || parts[0]?.mounted !== true || !Number.isSafeInteger(parts[0]?.triangles) || parts[0]?.triangles <= 0 || parts[1]?.partId !== "front" || parts[1]?.materialRole !== "face" || parts[1]?.triangles !== SCENE_SLAB_CONTENT_FACE_TRIANGLES || parts[1]?.mounted !== bound)
+    throw new ScenePreparedPlanRefusal(`${path}.parts`, "Slab parts disagree with the production descriptor contract.");
+  if (canonicalScenePreparedJsonV1(builder.materialRoles) !== canonicalScenePreparedJsonV1(["body", "face"]))
+    throw new ScenePreparedPlanRefusal(`${path}.materialRoles`, "Slab material roles are not canonical.");
+  const slots = builder.surfaceSlots;
+  if (slots.length !== 1 || slots[0]?.slot !== "front") throw new ScenePreparedPlanRefusal(`${path}.surfaceSlots`, "Slab must declare exactly its front slot.");
+  const z2 = slab.thickness / 2 + SCENE_SLAB_CONTENT_OFFSET;
+  const expectedSlot = {
+    slot: "front",
+    attachment: { partId: "front", materialRole: "face" },
+    dimensions: { width: slab.width, height: slab.height },
+    projectionQuad: [
+      [-slab.width / 2, slab.height / 2, z2],
+      [slab.width / 2, slab.height / 2, z2],
+      [slab.width / 2, -slab.height / 2, z2],
+      [-slab.width / 2, -slab.height / 2, z2]
+    ],
+    uvOrigin: "top-left",
+    fit: "contain",
+    alpha: "straight",
+    depth: "test-only",
+    required: false,
+    bakeScales: [2, 3]
+  };
+  if (canonicalScenePreparedJsonV1(slots[0]) !== canonicalScenePreparedJsonV1(expectedSlot))
+    throw new ScenePreparedPlanRefusal(`${path}.surfaceSlots.0`, "Slab front slot facts are not canonical.");
+  const expectedBounds = { center: [0, 0, 0], halfExtents: [slab.width / 2, slab.height / 2, slab.thickness / 2] };
+  if (canonicalScenePreparedJsonV1(builder.localBounds) !== canonicalScenePreparedJsonV1(expectedBounds))
+    throw new ScenePreparedPlanRefusal(`${path}.localBounds`, "Slab local bounds are not canonical.");
+  if (!builder.allocations.length) throw new ScenePreparedPlanRefusal(`${path}.allocations`, "Slab production allocations are missing.");
+}
+var geometryAllocationPairV1 = (owner, name, bytes) => [
+  { owner, name, domain: "gl", resource: "geometry", format: "three-buffer-attributes-and-index", bytes, lifetime: "context" },
+  { owner, name: `${name}-arrays`, domain: "cpu", resource: "geometry", format: "three-typed-arrays", bytes, lifetime: "context" }
+];
+function sceneW5PresetAllocationsV1(object) {
+  const owner = `${object.kind}:${object.id}`;
+  if (object.kind === "page") return geometryAllocationPairV1(owner, "content-geometry", 140);
+  const rows = geometryAllocationPairV1(owner, "shell-geometry", object.kind === "phone" ? 300672 : 93312);
+  if (object.kind === "laptop") rows.push(...geometryAllocationPairV1(owner, "base-geometry", 93312));
+  for (const name of object.kind === "phone" ? ["screen", "glass"] : ["keyboard", "trackpad", "bezel", "screen", "glass"]) rows.push(...geometryAllocationPairV1(owner, `${name}-geometry`, 140));
+  return rows;
+}
+function sceneW5WorldTextAllocationsV1(object, referenceWidth, outputWidth) {
+  const width = object.maxWidth ?? referenceWidth, height = object.lines.length * object.fontSize * object.lineHeight, scale = outputWidth / referenceWidth;
+  const rw = Math.max(1, Math.ceil(width * scale)), rh = Math.max(1, Math.ceil(height * scale)), cpu = rw * rh * 4;
+  let mips = 0;
+  for (let w = rw, h = rh; ; w = Math.max(1, Math.floor(w / 2)), h = Math.max(1, Math.floor(h / 2))) {
+    mips += w * h * 4;
+    if (w === 1 && h === 1) break;
+  }
+  return [
+    ...geometryAllocationPairV1(`text:${object.id}`, "plane-geometry", 140),
+    { owner: `text:${object.id}`, name: "raster-canvas", domain: "cpu", resource: "decoded-image", format: "rgba8", bytes: cpu, lifetime: "context" },
+    { owner: `text:${object.id}`, name: "raster-mip-chain", domain: "gl", resource: "texture", format: "rgba8-mip-chain", bytes: mips, lifetime: "context" }
+  ];
+}
+function sceneW5GeneratedRigAllocationsV1(edge, width, height) {
+  const shadow = edge ** 2 * 4, pixels = width * height;
+  return [
+    { owner: "studio:rim", name: "shadow-color", domain: "gl", resource: "texture", format: "rgba8", bytes: shadow, lifetime: "context" },
+    { owner: "studio:rim", name: "shadow-depth", domain: "gl", resource: "renderbuffer", format: "depth24-charged-rgba32", bytes: shadow, lifetime: "context" },
+    { owner: "studio:environment", name: "pmrem-cubeuv", domain: "gl", resource: "pmrem-target", format: "rgba16f", bytes: 6 * 1024 * 1024, lifetime: "context" },
+    { owner: "studio:environment", name: "pmrem-ping-pong", domain: "gl", resource: "pmrem-target", format: "rgba16f", bytes: 6 * 1024 * 1024, lifetime: "preparation" },
+    { owner: "studio:environment", name: "pmrem-depth", domain: "gl", resource: "renderbuffer", format: "depth24-charged-rgba32", bytes: 3 * 1024 * 1024, lifetime: "preparation" },
+    { owner: "post:focus-resources", name: "world-color-resolve", domain: "gl", resource: "texture", format: "rgba16f", bytes: pixels * 8, lifetime: "context" },
+    { owner: "post:focus-resources", name: "world-depth", domain: "gl", resource: "texture", format: "depth32u", bytes: pixels * 4, lifetime: "context" },
+    { owner: "post:focus-resources", name: "gathered-color", domain: "gl", resource: "texture", format: "rgba16f", bytes: pixels * 8, lifetime: "context" },
+    { owner: "post:focus-resources", name: "grain-lattice", domain: "gl", resource: "texture", format: "rgba32f", bytes: 24672, lifetime: "context" },
+    { owner: "post:focus-resources", name: "grain-lattice-array", domain: "cpu", resource: "decoded-image", format: "rgba32f", bytes: 24672, lifetime: "context" },
+    { owner: "post:focus-resources", name: "world-color-msaa", domain: "gl", resource: "renderbuffer", format: "rgba16f-msaa-4", bytes: pixels * 32, lifetime: "context" },
+    { owner: "post:focus-resources", name: "world-depth-msaa", domain: "gl", resource: "renderbuffer", format: "depth32u-msaa-4", bytes: pixels * 16, lifetime: "context" }
+  ];
+}
+function validateW5Descriptor(value, object, path) {
+  const builder = value;
+  if (builder.builderVersion !== 1) throw new ScenePreparedPlanRefusal(`${path}.builderVersion`, `${object.kind} builder version must be 1.`);
+  if (builder.tessellationVersion !== 1) throw new ScenePreparedPlanRefusal(`${path}.tessellationVersion`, `${object.kind} tessellation version must be 1.`);
+  const parts = builder.parts;
+  const slots = builder.surfaceSlots;
+  const roles = builder.materialRoles;
+  if (object.kind === "page") {
+    if (builder.budgetTriangles !== SCENE_PRESET_TRIANGLES.page) throw new ScenePreparedPlanRefusal(`${path}.budgetTriangles`, "Page triangle budget is not canonical.");
+    if (canonicalScenePreparedJsonV1(parts) !== canonicalScenePreparedJsonV1([{ partId: "base", materialRole: "base", triangles: 2, mounted: true }])) throw new ScenePreparedPlanRefusal(`${path}.parts`, "Page parts are not canonical.");
+    if (canonicalScenePreparedJsonV1(roles) !== canonicalScenePreparedJsonV1(["base"])) throw new ScenePreparedPlanRefusal(`${path}.materialRoles`, "Page material roles are not canonical.");
+    const expected = { slot: "content", attachment: { partId: "base", materialRole: "base" }, dimensions: { width: object.width, height: object.height }, projectionQuad: [[-object.width / 2, object.height / 2, 0], [object.width / 2, object.height / 2, 0], [object.width / 2, -object.height / 2, 0], [-object.width / 2, -object.height / 2, 0]], uvOrigin: "top-left", fit: object.fit, alpha: object.transparency, depth: object.depthWrite ? "write" : "test-only", required: true, bakeScales: [2, 3] };
+    if (canonicalScenePreparedJsonV1(slots) !== canonicalScenePreparedJsonV1([expected])) throw new ScenePreparedPlanRefusal(`${path}.surfaceSlots`, "Page content slot is not canonical.");
+    if (canonicalScenePreparedJsonV1(builder.localBounds) !== canonicalScenePreparedJsonV1({ center: [0, 0, 0], halfExtents: [object.width / 2, object.height / 2, 0] })) throw new ScenePreparedPlanRefusal(`${path}.localBounds`, "Page bounds are not canonical.");
+    const expectedAllocations = sceneW5PresetAllocationsV1(object);
+    if (canonicalScenePreparedJsonV1(builder.allocations) !== canonicalScenePreparedJsonV1(expectedAllocations)) throw new ScenePreparedPlanRefusal(`${path}.allocations`, "Page allocations are not canonical.");
+    return;
+  }
+  const dim = sceneDeviceDimensionsV1(object.kind, object.width);
+  const screenW = object.kind === "laptop" ? dim.w * 0.86 : dim.w - 2 * dim.screenInset;
+  const screenH = object.kind === "laptop" ? dim.h * 0.86 : dim.h - 2 * dim.screenInset;
+  const expectedSlot = { slot: "screen", attachment: { partId: "screen", materialRole: "screen" }, dimensions: { width: screenW, height: screenH }, projectionQuad: object.kind === "laptop" ? sceneLaptopScreenQuadV1(object) : [[-screenW / 2, screenH / 2, dim.t / 2 + SCENE_DEVICE_SCREEN_OFFSET_V1], [screenW / 2, screenH / 2, dim.t / 2 + SCENE_DEVICE_SCREEN_OFFSET_V1], [screenW / 2, -screenH / 2, dim.t / 2 + SCENE_DEVICE_SCREEN_OFFSET_V1], [-screenW / 2, -screenH / 2, dim.t / 2 + SCENE_DEVICE_SCREEN_OFFSET_V1]], uvOrigin: "top-left", fit: "contain", alpha: "straight", depth: "test-only", required: false, bakeScales: [2, 3] };
+  if (canonicalScenePreparedJsonV1(slots) !== canonicalScenePreparedJsonV1([expectedSlot])) throw new ScenePreparedPlanRefusal(`${path}.surfaceSlots`, `${object.kind} screen slot is not canonical.`);
+  const expectedParts = object.kind === "phone" ? [["shell", "shell", 3132], ["screen", "screen", 2], ["glass", "glass", 2]] : [["base", "shell", 972], ["lid", "shell", 972], ["keyboard", "keyboard", 2], ["trackpad", "trackpad", 2], ["bezel", "bezel", 2], ["screen", "screen", 2], ["glass", "glass", 2]];
+  if (parts.length !== expectedParts.length || expectedParts.some((p, i) => parts[i]?.partId !== p[0] || parts[i]?.materialRole !== p[1] || parts[i]?.triangles !== p[2] || parts[i]?.mounted !== true)) throw new ScenePreparedPlanRefusal(`${path}.parts`, `${object.kind} parts are not canonical.`);
+  const expectedRoles = object.kind === "phone" ? ["shell", "screen", "glass"] : ["shell", "keyboard", "trackpad", "bezel", "screen", "glass"];
+  if (canonicalScenePreparedJsonV1(roles) !== canonicalScenePreparedJsonV1(expectedRoles)) throw new ScenePreparedPlanRefusal(`${path}.materialRoles`, `${object.kind} material roles are not canonical.`);
+  if (builder.budgetTriangles !== SCENE_PRESET_TRIANGLES[object.kind]) throw new ScenePreparedPlanRefusal(`${path}.budgetTriangles`, `${object.kind} triangle budget is not canonical.`);
+  const expectedBounds = object.kind === "phone" ? { center: [0, 0, 0], halfExtents: [dim.w / 2, dim.h / 2, dim.t / 2 + SCENE_DEVICE_SCREEN_OFFSET_V1 * 2] } : (() => {
+    const layout = sceneLaptopLayoutV1(dim), quad = sceneLaptopScreenQuadV1(object), ys = [layout.bottomY, ...quad.map((p) => p[1])], zs = [-dim.d / 2, dim.d / 2, ...quad.map((p) => p[2])];
+    return { center: [0, (Math.max(...ys) + Math.min(...ys)) / 2, (Math.max(...zs) + Math.min(...zs)) / 2], halfExtents: [dim.w / 2, (Math.max(...ys) - Math.min(...ys)) / 2, (Math.max(...zs) - Math.min(...zs)) / 2] };
+  })();
+  if (canonicalScenePreparedJsonV1(builder.localBounds) !== canonicalScenePreparedJsonV1(expectedBounds)) throw new ScenePreparedPlanRefusal(`${path}.localBounds`, `${object.kind} bounds are not canonical.`);
+  const allocations = sceneW5PresetAllocationsV1(object);
+  if (canonicalScenePreparedJsonV1(builder.allocations) !== canonicalScenePreparedJsonV1(allocations)) throw new ScenePreparedPlanRefusal(`${path}.allocations`, `${object.kind} allocations are not canonical.`);
+}
+function validateWorldTextDescriptor(value, object, referenceWidth, outputWidth, path) {
+  const builder = value;
+  const width = object.maxWidth ?? referenceWidth;
+  const height = object.lines.length * object.fontSize * object.lineHeight;
+  if (builder.builderVersion !== 1) throw new ScenePreparedPlanRefusal(`${path}.builderVersion`, "World text builder version must be 1.");
+  if (builder.tessellationVersion !== 1) throw new ScenePreparedPlanRefusal(`${path}.tessellationVersion`, "World text tessellation version must be 1.");
+  if (builder.budgetTriangles !== 2) throw new ScenePreparedPlanRefusal(`${path}.budgetTriangles`, "World text triangle contribution must be 2.");
+  if (canonicalScenePreparedJsonV1(builder.parts) !== canonicalScenePreparedJsonV1([{ partId: "quad", materialRole: "glyphs", triangles: 2, mounted: true }])) throw new ScenePreparedPlanRefusal(`${path}.parts`, "World text parts are not canonical.");
+  if (canonicalScenePreparedJsonV1(builder.surfaceSlots) !== canonicalScenePreparedJsonV1([]) || canonicalScenePreparedJsonV1(builder.materialRoles) !== canonicalScenePreparedJsonV1(["glyphs"])) throw new ScenePreparedPlanRefusal(`${path}.materialRoles`, "World text roles and slots are not canonical.");
+  if (canonicalScenePreparedJsonV1(builder.localBounds) !== canonicalScenePreparedJsonV1({ center: [0, 0, 0], halfExtents: [width / 2, height / 2, 0] })) throw new ScenePreparedPlanRefusal(`${path}.localBounds`, "World text bounds are not canonical.");
+  const allocations = builder.allocations;
+  const expectedAllocations = sceneW5WorldTextAllocationsV1(object, referenceWidth, outputWidth);
+  if (canonicalScenePreparedJsonV1(allocations) !== canonicalScenePreparedJsonV1(expectedAllocations)) throw new ScenePreparedPlanRefusal(`${path}.allocations`, "World text allocations are not canonical.");
+}
+function imageFacts(value, path, pngOnly = false) {
+  const image = record(value, path);
+  exactKeys(image, ["handle", "mimeType", "byteLength", "width", "height", "decodedSha256"], path);
+  stringValue(image.handle, `${path}.handle`);
+  const mimes = pngOnly ? ["image/png"] : ["image/png", "image/jpeg", "image/webp"];
+  enumValue(image.mimeType, mimes, `${path}.mimeType`);
+  finiteNumber(image.byteLength, `${path}.byteLength`, {
+    integer: true,
+    positive: true
+  });
+  finiteNumber(image.width, `${path}.width`, { integer: true, positive: true });
+  finiteNumber(image.height, `${path}.height`, {
+    integer: true,
+    positive: true
+  });
+  sha256Value(image.decodedSha256, `${path}.decodedSha256`);
+}
+function videoFacts(value, path) {
+  const video = record(value, path);
+  exactKeys(video, ["handle", "mimeType", "byteLength", "width", "height", "encodedSha256", "presentationIndex"], path);
+  stringValue(video.handle, `${path}.handle`);
+  enumValue(video.mimeType, ["video/mp4", "video/webm"], `${path}.mimeType`);
+  for (const key of ["byteLength", "width", "height"]) finiteNumber(video[key], `${path}.${key}`, { integer: true, positive: true });
+  sha256Value(video.encodedSha256, `${path}.encodedSha256`);
+  const index = record(video.presentationIndex, `${path}.presentationIndex`);
+  exactKeys(index, ["pts", "timeBase"], `${path}.presentationIndex`);
+  const pts = arrayValue(index.pts, `${path}.presentationIndex.pts`);
+  pts.forEach((entry, i) => finiteNumber(entry, `${path}.presentationIndex.pts.${i}`, { integer: true }));
+  const timeBase = record(index.timeBase, `${path}.presentationIndex.timeBase`);
+  exactKeys(timeBase, ["num", "den"], `${path}.presentationIndex.timeBase`);
+  finiteNumber(timeBase.num, `${path}.presentationIndex.timeBase.num`, { integer: true, positive: true });
+  finiteNumber(timeBase.den, `${path}.presentationIndex.timeBase.den`, { integer: true, positive: true });
+  return video;
+}
+function resolutionResult(value, path, scale) {
+  const result = record(value, path);
+  exactKeys(result, ["raster", "bakeScale", "worstDensity", "worstAt", "meetsBound", "bound"], path);
+  if (result.bakeScale !== scale) throw new ScenePreparedPlanRefusal(`${path}.bakeScale`, "Resolution result scale disagrees with its key.");
+  const raster = record(result.raster, `${path}.raster`);
+  exactKeys(raster, ["width", "height"], `${path}.raster`);
+  finiteNumber(raster.width, `${path}.raster.width`, {
+    integer: true,
+    positive: true
+  });
+  finiteNumber(raster.height, `${path}.raster.height`, {
+    integer: true,
+    positive: true
+  });
+  finiteNumber(result.worstDensity, `${path}.worstDensity`, {
+    nonnegative: true
+  });
+  finiteNumber(result.bound, `${path}.bound`, { positive: true });
+  booleanValue(result.meetsBound, `${path}.meetsBound`);
+  if (result.meetsBound !== result.worstDensity >= result.bound)
+    throw new ScenePreparedPlanRefusal(`${path}.meetsBound`, "Resolution bound result is inconsistent.");
+  const worst = record(result.worstAt, `${path}.worstAt`);
+  exactKeys(worst, ["frame", "densityU", "densityV", "axis", "widthPx", "heightPx"], `${path}.worstAt`);
+  finiteNumber(worst.frame, `${path}.worstAt.frame`, {
+    integer: true,
+    nonnegative: true
+  });
+  for (const key of ["densityU", "densityV", "widthPx", "heightPx"]) finiteNumber(worst[key], `${path}.worstAt.${key}`, { positive: true });
+  enumValue(worst.axis, ["U", "V"], `${path}.worstAt.axis`);
+  const expectedWorst = Math.min(worst.densityU, worst.densityV);
+  if (result.worstDensity !== expectedWorst || worst.axis !== (worst.densityU <= worst.densityV ? "U" : "V"))
+    throw new ScenePreparedPlanRefusal(`${path}.worstAt`, "Worst resolution evidence is inconsistent.");
+}
+var SCENE_CAPTURE_IDENTITY_FIELDS_V1 = [
+  "componentId",
+  "sourceVersionId",
+  "params",
+  "assetBindings",
+  "layoutWidth",
+  "layoutHeight",
+  "bakeScale",
+  "captureFrame",
+  "durationInFrames",
+  "fps",
+  "seed",
+  "brandFacts",
+  "fontFacts",
+  "mediaFacts",
+  "rasterWidth",
+  "rasterHeight",
+  "runtimeIdentity",
+  "dependencyIdentity",
+  "browserProduct",
+  "browserVersion",
+  "browserExecutableSha256",
+  "headless",
+  "rasterAffectingFlags",
+  "os",
+  "arch",
+  "deviceScaleFactor",
+  "colorProfile",
+  "requestedGlBackend",
+  "actualGlBackend",
+  "actualRenderer",
+  "gpuIdentity"
+];
+function captureIdentity(value, path) {
+  const identity = record(value, path);
+  exactKeys(identity, SCENE_CAPTURE_IDENTITY_FIELDS_V1, path);
+  for (const key of [
+    "componentId",
+    "sourceVersionId",
+    "seed",
+    "runtimeIdentity",
+    "dependencyIdentity",
+    "browserProduct",
+    "browserVersion",
+    "os",
+    "arch",
+    "colorProfile",
+    "requestedGlBackend",
+    "actualGlBackend",
+    "actualRenderer"
+  ])
+    stringValue(identity[key], `${path}.${key}`);
+  sha256Value(identity.sourceVersionId, `${path}.sourceVersionId`);
+  sha256Value(identity.browserExecutableSha256, `${path}.browserExecutableSha256`);
+  for (const key of ["layoutWidth", "layoutHeight", "captureFrame", "durationInFrames", "rasterWidth", "rasterHeight"])
+    finiteNumber(identity[key], `${path}.${key}`, {
+      integer: true,
+      ...key === "captureFrame" ? { nonnegative: true } : { positive: true }
+    });
+  if (identity.bakeScale !== 2 && identity.bakeScale !== 3) throw new ScenePreparedPlanRefusal(`${path}.bakeScale`, "Invalid capture bake scale.");
+  if (identity.deviceScaleFactor !== identity.bakeScale)
+    throw new ScenePreparedPlanRefusal(`${path}.deviceScaleFactor`, "Captured DPR disagrees with bake scale.");
+  if (identity.rasterWidth !== identity.layoutWidth * identity.bakeScale || identity.rasterHeight !== identity.layoutHeight * identity.bakeScale)
+    throw new ScenePreparedPlanRefusal(`${path}.rasterWidth`, "Capture raster disagrees with layout and scale.");
+  booleanValue(identity.headless, `${path}.headless`);
+  if (identity.gpuIdentity !== null) stringValue(identity.gpuIdentity, `${path}.gpuIdentity`);
+  const fps = record(identity.fps, `${path}.fps`);
+  exactKeys(fps, ["num", "den"], `${path}.fps`);
+  finiteNumber(fps.num, `${path}.fps.num`, { integer: true, positive: true });
+  finiteNumber(fps.den, `${path}.fps.den`, { integer: true, positive: true });
+  for (const key of ["params", "assetBindings", "brandFacts", "fontFacts", "mediaFacts", "rasterAffectingFlags"])
+    canonicalScenePreparedJsonV1(identity[key], `${path}.${key}`);
+}
+function canonicalCaptureIdentityV1(value) {
+  const ordered = Object.fromEntries(SCENE_CAPTURE_IDENTITY_FIELDS_V1.map((field) => [field, JSON.parse(canonicalScenePreparedJsonV1(value[field]))]));
+  return JSON.stringify(ordered);
+}
+function expectedSceneEntries(scene) {
+  const objects = [];
+  const surfaces = [];
+  const visit = (layers, prefix = "layers", parentId = null) => layers.forEach((object, index) => {
+    const path = `${prefix}.${index}`;
+    objects.push({ object, parentId, path });
+    if ("surfaces" in object && object.surfaces)
+      for (const [slot, binding] of Object.entries(object.surfaces))
+        surfaces.push({
+          object,
+          path: `${path}.surfaces.${slot}`,
+          slot,
+          binding
+        });
+    if (object.kind === "group") visit(object.children, `${path}.children`, object.id);
+  });
+  visit(scene.layers);
+  return { objects, surfaces };
+}
+function fullMipBytes(width, height) {
+  let bytes = 0;
+  for (let w = width, h = height; ; w = Math.max(1, Math.floor(w / 2)), h = Math.max(1, Math.floor(h / 2))) {
+    bytes += w * h * 4;
+    if (w === 1 && h === 1) return bytes;
+  }
+}
+function validateNestedPlan(plan, scene) {
+  const output = plan.output;
+  const camera = record(plan.cameraIdentity, "plan.cameraIdentity");
+  exactKeys(camera, ["position", "fov", "near", "far"], "plan.cameraIdentity");
+  vec3(camera.position, "plan.cameraIdentity.position");
+  finiteNumber(camera.fov, "plan.cameraIdentity.fov", { positive: true });
+  finiteNumber(camera.near, "plan.cameraIdentity.near", { positive: true });
+  finiteNumber(camera.far, "plan.cameraIdentity.far", { positive: true });
+  if (camera.far <= camera.near) throw new ScenePreparedPlanRefusal("plan.cameraIdentity.far", "Camera far must exceed near.");
+  const motion = record(plan.motion, "plan.motion");
+  exactKeys(motion, ["channels", "contentDurationInFrames", "finalContentFrame", "cameraClipPlanes"], "plan.motion");
+  if (canonicalScenePreparedJsonV1(motion.channels, "plan.motion.channels") !== canonicalScenePreparedJsonV1(scene.animation, "plan.scene.animation"))
+    throw new ScenePreparedPlanRefusal("plan.motion.channels", "Motion channels must equal the parsed authored animation.");
+  finiteNumber(motion.contentDurationInFrames, "plan.motion.contentDurationInFrames", { integer: true, positive: true });
+  finiteNumber(motion.finalContentFrame, "plan.motion.finalContentFrame", {
+    integer: true,
+    nonnegative: true
+  });
+  if (motion.contentDurationInFrames !== output.durationInFrames || motion.finalContentFrame !== motion.contentDurationInFrames - 1)
+    throw new ScenePreparedPlanRefusal("plan.motion.finalContentFrame", "Output duration, motion duration and final hold disagree.");
+  const planes = arrayValue(motion.cameraClipPlanes, "plan.motion.cameraClipPlanes");
+  if (planes.length !== motion.contentDurationInFrames)
+    throw new ScenePreparedPlanRefusal("plan.motion.cameraClipPlanes", "Clip-plane schedule must cover every content frame.");
+  planes.forEach((entry, index) => {
+    const plane = record(entry, `plan.motion.cameraClipPlanes.${index}`);
+    exactKeys(plane, ["near", "far"], `plan.motion.cameraClipPlanes.${index}`);
+    finiteNumber(plane.near, `plan.motion.cameraClipPlanes.${index}.near`, {
+      positive: true
+    });
+    finiteNumber(plane.far, `plan.motion.cameraClipPlanes.${index}.far`, {
+      positive: true
+    });
+    if (plane.far <= plane.near)
+      throw new ScenePreparedPlanRefusal(`plan.motion.cameraClipPlanes.${index}.far`, "Camera far must exceed near.");
+  });
+  if (camera.near !== planes[0].near || camera.far !== planes[0].far)
+    throw new ScenePreparedPlanRefusal("plan.cameraIdentity.near", "Camera identity clip planes disagree with frame zero.");
+  const frame0 = evaluateScene(scene, 0, output.durationInFrames).camera;
+  if (canonicalScenePreparedJsonV1(camera.position) !== canonicalScenePreparedJsonV1(frame0.position) || camera.fov !== frame0.fov)
+    throw new ScenePreparedPlanRefusal("plan.cameraIdentity", "Camera identity disagrees with evaluated frame zero.");
+  allocationArray(plan.rigAllocations, "plan.rigAllocations");
+  canonicalScenePreparedJsonV1(plan.rigIdentity, "plan.rigIdentity");
+  if (scene.environment.kind === "photographic-studio-v1") {
+    const expectedRig = photographicSceneRigFactsV1(
+      output.height / scene.referenceSize.height,
+      output.width,
+      output.height
+    );
+    if (canonicalScenePreparedJsonV1(plan.rigIdentity) !== canonicalScenePreparedJsonV1(expectedRig.identity))
+      throw new ScenePreparedPlanRefusal("plan.rigIdentity", "Photographic rig identity differs from the fixed production rig.");
+    if (canonicalScenePreparedJsonV1(plan.rigAllocations) !== canonicalScenePreparedJsonV1(expectedRig.allocations))
+      throw new ScenePreparedPlanRefusal(
+        "plan.rigAllocations",
+        "Photographic rig allocations must match the fixed environment and output-sized 4-sample Focus resources."
+      );
+  } else {
+    const rig = record(plan.rigIdentity, "plan.rigIdentity");
+    exactKeys(rig, ["lightingProfile", "preset", "intensity", "floorY", "shadowOpacity", "shadowMapEdge", "environmentVersion"], "plan.rigIdentity");
+    for (const key of ["lightingProfile", "preset", "intensity", "floorY", "shadowOpacity"]) if (rig[key] !== scene.environment[key]) throw new ScenePreparedPlanRefusal(`plan.rigIdentity.${key}`, "Generated studio identity disagrees with the authored rig.");
+    if (rig.environmentVersion !== 1) throw new ScenePreparedPlanRefusal("plan.rigIdentity.environmentVersion", "Generated studio environment version must be 1.");
+    if (rig.shadowMapEdge !== 2048 && rig.shadowMapEdge !== 4096) throw new ScenePreparedPlanRefusal("plan.rigIdentity.shadowMapEdge", "Generated studio shadow edge must be 2048 or 4096.");
+    const expected2 = sceneW5GeneratedRigAllocationsV1(rig.shadowMapEdge, output.width, output.height);
+    if (canonicalScenePreparedJsonV1(plan.rigAllocations) !== canonicalScenePreparedJsonV1(expected2)) throw new ScenePreparedPlanRefusal("plan.rigAllocations", "Generated studio allocations disagree with the exact production rig and FocusResources allocation contract.");
+  }
+  const fonts = arrayValue(plan.fonts, "plan.fonts");
+  fonts.forEach((entry, index) => {
+    const path = `plan.fonts.${index}`;
+    const face = record(entry, path);
+    exactKeys(face, face.url === void 0 ? ["family", "weight", "style", "paths"] : ["family", "weight", "style", "url", "paths"], path);
+    stringValue(face.family, `${path}.family`);
+    finiteNumber(face.weight, `${path}.weight`, {
+      integer: true,
+      positive: true
+    });
+    enumValue(face.style, ["normal", "italic"], `${path}.style`);
+    if (face.url !== void 0) stringValue(face.url, `${path}.url`);
+    const paths = arrayValue(face.paths, `${path}.paths`);
+    if (!paths.length) throw new ScenePreparedPlanRefusal(`${path}.paths`, "A font face needs at least one authored path.");
+    paths.forEach((entry2, i) => stringValue(entry2, `${path}.paths.${i}`));
+  });
+  const expected = expectedSceneEntries(scene);
+  const expectedText = new Map(
+    expected.objects.filter(({ object }) => object.kind === "text").map(({ object, path }) => {
+      const text = object;
+      return [
+        path,
+        {
+          family: text.fontFamily,
+          weight: text.fontWeight,
+          style: text.fontStyle
+        }
+      ];
+    })
+  );
+  const coveredText = /* @__PURE__ */ new Set();
+  fonts.forEach((entry, index) => {
+    const face = entry;
+    for (const fontPath of face.paths) {
+      const expectedFace = expectedText.get(fontPath);
+      if (!expectedFace || coveredText.has(fontPath) || expectedFace.family !== face.family || expectedFace.weight !== face.weight || expectedFace.style !== face.style)
+        throw new ScenePreparedPlanRefusal(`plan.fonts.${index}.paths`, "Font paths must cover each authored text face exactly once.");
+      coveredText.add(fontPath);
+    }
+  });
+  if (coveredText.size !== expectedText.size) throw new ScenePreparedPlanRefusal("plan.fonts", "Sealed fonts do not cover every authored text face.");
+  const objects = arrayValue(plan.objects, "plan.objects");
+  if (objects.length !== expected.objects.length)
+    throw new ScenePreparedPlanRefusal("plan.objects", "Prepared objects must cover every authored object exactly once.");
+  objects.forEach((entry, index) => {
+    const path = `plan.objects.${index}`;
+    const object = record(entry, path);
+    exactKeys(object, ["authoredId", "parentId", "kind", "builder", "parts"], path);
+    const authored = expected.objects[index];
+    if (object.authoredId !== authored.object.id || object.parentId !== authored.parentId || object.kind !== authored.object.kind)
+      throw new ScenePreparedPlanRefusal(path, "Prepared object identity disagrees with authored traversal.");
+    const builderless = authored.object.kind === "group" || authored.object.kind === "text" && authored.object.space === "screen";
+    if (object.builder === null) {
+      if (!builderless) throw new ScenePreparedPlanRefusal(`${path}.builder`, "A renderable object requires a builder.");
+    } else {
+      if (builderless) throw new ScenePreparedPlanRefusal(`${path}.builder`, "This authored object must not carry a builder.");
+      descriptor(object.builder, `${path}.builder`);
+      if (object.builder.kind !== object.kind)
+        throw new ScenePreparedPlanRefusal(`${path}.builder.kind`, "Builder kind disagrees with object kind.");
+      if (authored.object.kind === "slab") validateSlabDescriptor(object.builder, authored.object, `${path}.builder`);
+      if (authored.object.kind === "laptop" || authored.object.kind === "phone" || authored.object.kind === "page") validateW5Descriptor(object.builder, authored.object, `${path}.builder`);
+      if (authored.object.kind === "text" && authored.object.space === "world") validateWorldTextDescriptor(object.builder, authored.object, scene.referenceSize.width, output.width, `${path}.builder`);
+    }
+    const parts = arrayValue(object.parts, `${path}.parts`);
+    parts.forEach((partValue, partIndex) => {
+      const partPath = `${path}.parts.${partIndex}`;
+      const part = record(partValue, partPath);
+      exactKeys(part, ["id", "partId", "materialRole", "triangles", "mounted"], partPath);
+      for (const key of ["id", "partId", "materialRole"]) stringValue(part[key], `${partPath}.${key}`);
+      finiteNumber(part.triangles, `${partPath}.triangles`, {
+        integer: true,
+        nonnegative: true
+      });
+      booleanValue(part.mounted, `${partPath}.mounted`);
+    });
+    const builderParts = object.builder && object.builder.parts;
+    if (canonicalScenePreparedJsonV1(
+      parts.map((part) => {
+        const { id: _id, ...rest } = part;
+        return rest;
+      })
+    ) !== canonicalScenePreparedJsonV1(builderParts ?? []))
+      throw new ScenePreparedPlanRefusal(`${path}.parts`, "Prepared parts disagree with builder parts.");
+    parts.forEach((part) => {
+      const row = part;
+      if (row.id !== `${object.authoredId}:${row.partId}`) throw new ScenePreparedPlanRefusal(`${path}.parts`, "Prepared part id is not canonical.");
+    });
+  });
+  const surfaces = arrayValue(plan.surfaces, "plan.surfaces");
+  if (surfaces.length !== expected.surfaces.length)
+    throw new ScenePreparedPlanRefusal("plan.surfaces", "Sealed surfaces must cover every authored binding exactly once.");
+  surfaces.forEach((entry, index) => {
+    const path = `plan.surfaces.${index}`;
+    const surface = record(entry, path);
+    const allowed = ["path", "authoredObjectId", "slot", "binding", "descriptor", "bakeScale", "bakeScaleReason", "resolutionCheck", "realized"];
+    const unknown = Object.keys(surface).find((key) => !allowed.includes(key));
+    if (unknown) throw new ScenePreparedPlanRefusal(`${path}.${unknown}`, "Unknown sealed surface field.");
+    const authored = expected.surfaces[index];
+    if (surface.path !== authored.path || surface.authoredObjectId !== authored.object.id || surface.slot !== authored.slot)
+      throw new ScenePreparedPlanRefusal(path, "Sealed surface identity disagrees with authored traversal.");
+    const parsedBinding = SceneSurfaceBindingV2.safeParse(surface.binding);
+    if (!parsedBinding.success)
+      throw new ScenePreparedPlanRefusal(
+        `${path}.binding${parsedBinding.error.issues[0]?.path.map((part) => `.${String(part)}`).join("") ?? ""}`,
+        "Invalid sealed surface binding."
+      );
+    if (canonicalScenePreparedJsonV1(parsedBinding.data) !== canonicalScenePreparedJsonV1(authored.binding))
+      throw new ScenePreparedPlanRefusal(`${path}.binding`, "Sealed binding differs from authored scene.");
+    slotDescriptor(surface.descriptor, `${path}.descriptor`);
+    const owner = objects.find((object) => object.authoredId === surface.authoredObjectId);
+    const builderSlots = owner.builder.surfaceSlots;
+    const builderSlot = builderSlots.find((slot) => slot.slot === surface.slot);
+    if (!builderSlot || canonicalScenePreparedJsonV1(builderSlot) !== canonicalScenePreparedJsonV1(surface.descriptor))
+      throw new ScenePreparedPlanRefusal(`${path}.descriptor`, "Surface descriptor differs from its builder slot.");
+    const binding = parsedBinding.data;
+    const realized = record(surface.realized, `${path}.realized`);
+    if (realized.source !== binding.source) throw new ScenePreparedPlanRefusal(`${path}.realized.source`, "Realized source disagrees with binding.");
+    if (binding.source === "color") {
+      exactKeys(realized, ["source", "color"], `${path}.realized`);
+      if (realized.color !== binding.color || surface.bakeScale !== void 0 || surface.bakeScaleReason !== void 0 || surface.resolutionCheck !== void 0)
+        throw new ScenePreparedPlanRefusal(`${path}.realized.color`, "Color realization is inconsistent.");
+    } else if (binding.source === "image") {
+      exactKeys(realized, ["source", "image"], `${path}.realized`);
+      imageFacts(realized.image, `${path}.realized.image`);
+      if (surface.bakeScale !== void 0 || surface.bakeScaleReason !== void 0 || surface.resolutionCheck !== void 0)
+        throw new ScenePreparedPlanRefusal(path, "Image realization carries component-only scale facts.");
+    } else if (binding.source === "video") {
+      exactKeys(realized, ["source", "video", "schedule"], `${path}.realized`);
+      const video = videoFacts(realized.video, `${path}.realized.video`);
+      let expected2;
+      try {
+        expected2 = prepareSceneVideoScheduleV1({ presentationIndex: video.presentationIndex, shotRate: output.fps, contentDuration: output.durationInFrames, startFrame: binding.startFrame, endFrame: binding.endFrame });
+      } catch (error) {
+        throw new ScenePreparedPlanRefusal(`${path}.realized.schedule`, error instanceof Error ? error.message : String(error));
+      }
+      if (canonicalScenePreparedJsonV1(realized.schedule) !== canonicalScenePreparedJsonV1(expected2)) throw new ScenePreparedPlanRefusal(`${path}.realized.schedule`, "Video schedule disagrees with verified presentation timestamps, trims, or output rate.");
+      if (surface.bakeScale !== void 0 || surface.bakeScaleReason !== void 0 || surface.resolutionCheck !== void 0) throw new ScenePreparedPlanRefusal(path, "Video realization carries component-only scale facts.");
+    } else {
+      exactKeys(realized, ["source", "captureIdentitySha256", "captureIdentityFacts", "image"], `${path}.realized`);
+      sha256Value(realized.captureIdentitySha256, `${path}.realized.captureIdentitySha256`);
+      captureIdentity(realized.captureIdentityFacts, `${path}.realized.captureIdentityFacts`);
+      imageFacts(realized.image, `${path}.realized.image`, true);
+      if (surface.bakeScale !== 2 && surface.bakeScale !== 3) throw new ScenePreparedPlanRefusal(`${path}.bakeScale`, "Component surface needs a bake scale.");
+      enumValue(surface.bakeScaleReason, ["declared", "default-sufficient", "raised-by-resolution-check"], `${path}.bakeScaleReason`);
+      const selection = record(surface.resolutionCheck, `${path}.resolutionCheck`);
+      exactKeys(selection, ["selected", "reason", "results"], `${path}.resolutionCheck`);
+      if (selection.selected !== surface.bakeScale || selection.reason !== surface.bakeScaleReason)
+        throw new ScenePreparedPlanRefusal(`${path}.resolutionCheck`, "Resolution selection disagrees with sealed surface.");
+      const results = record(selection.results, `${path}.resolutionCheck.results`);
+      exactKeys(results, ["2", "3"], `${path}.resolutionCheck.results`);
+      resolutionResult(results["2"], `${path}.resolutionCheck.results.2`, 2);
+      resolutionResult(results["3"], `${path}.resolutionCheck.results.3`, 3);
+      const result2 = results["2"];
+      const result3 = results["3"];
+      for (const [scale, result] of [
+        [2, result2],
+        [3, result3]
+      ]) {
+        const raster = result.raster;
+        if (raster.width !== binding.layout.width * scale || raster.height !== binding.layout.height * scale || result.worstAt.frame >= output.durationInFrames)
+          throw new ScenePreparedPlanRefusal(`${path}.resolutionCheck.results.${scale}`, "Resolution evidence disagrees with layout or output duration.");
+      }
+      if (surface.bakeScaleReason === "declared" && binding.bakeScale !== surface.bakeScale || surface.bakeScaleReason === "default-sufficient" && (binding.bakeScale !== void 0 || surface.bakeScale !== 2 || result2.meetsBound !== true) || surface.bakeScaleReason === "raised-by-resolution-check" && (binding.bakeScale !== void 0 || surface.bakeScale !== 3 || result2.meetsBound !== false || result3.meetsBound !== true))
+        throw new ScenePreparedPlanRefusal(`${path}.bakeScaleReason`, "Bake-scale reason disagrees with authored selection evidence.");
+      const identity = realized.captureIdentityFacts;
+      if (identity.componentId !== binding.component.componentId || identity.sourceVersionId !== binding.component.sourceVersionId || identity.captureFrame !== binding.captureFrame || identity.layoutWidth !== binding.layout.width || identity.layoutHeight !== binding.layout.height || identity.bakeScale !== surface.bakeScale || identity.captureFrame >= identity.durationInFrames || canonicalScenePreparedJsonV1(identity.fps) !== canonicalScenePreparedJsonV1(output.fps) || canonicalScenePreparedJsonV1(identity.params) !== canonicalScenePreparedJsonV1(binding.params ?? {}) || realized.image.width !== identity.rasterWidth || realized.image.height !== identity.rasterHeight)
+        throw new ScenePreparedPlanRefusal(`${path}.realized.captureIdentityFacts`, "Capture identity disagrees with binding, output or PNG.");
+    }
+  });
+  const separation = record(plan.separation, "plan.separation");
+  exactKeys(separation, ["pairs"], "plan.separation");
+  const pairs = arrayValue(separation.pairs, "plan.separation.pairs");
+  pairs.forEach((entry, index) => {
+    const path = `plan.separation.pairs.${index}`;
+    const pair = record(entry, path);
+    exactKeys(pair, ["constraintIndex", "frame", "objects", "separatingAxisGap", "requiredGap"], path);
+    finiteNumber(pair.constraintIndex, `${path}.constraintIndex`, {
+      integer: true,
+      nonnegative: true
+    });
+    finiteNumber(pair.frame, `${path}.frame`, {
+      integer: true,
+      nonnegative: true
+    });
+    if (pair.frame >= output.durationInFrames) throw new ScenePreparedPlanRefusal(`${path}.frame`, "Separation frame exceeds output.");
+    const ids = arrayValue(pair.objects, `${path}.objects`);
+    if (ids.length !== 2) throw new ScenePreparedPlanRefusal(`${path}.objects`, "Separation pair needs two objects.");
+    ids.forEach((id, i) => stringValue(id, `${path}.objects.${i}`));
+    if (ids.some((id) => !expected.objects.some((candidate) => candidate.object.id === id)))
+      throw new ScenePreparedPlanRefusal(`${path}.objects`, "Separation pair names an unknown object.");
+    finiteNumber(pair.separatingAxisGap, `${path}.separatingAxisGap`, {
+      nonnegative: true
+    });
+    finiteNumber(pair.requiredGap, `${path}.requiredGap`, {
+      nonnegative: true
+    });
+    if (pair.separatingAxisGap < pair.requiredGap)
+      throw new ScenePreparedPlanRefusal(`${path}.separatingAxisGap`, "Sealed separation result violates its required gap.");
+  });
+  const expectedPairs = [];
+  scene.constraints.forEach((constraint, constraintIndex) => {
+    for (let frame = 0; frame < output.durationInFrames; frame += 1) {
+      for (let first = 0; first < constraint.objects.length; first += 1)
+        for (let second = first + 1; second < constraint.objects.length; second += 1)
+          expectedPairs.push({
+            constraintIndex,
+            frame,
+            objects: [constraint.objects[first], constraint.objects[second]],
+            requiredGap: constraint.gap
+          });
+    }
+  });
+  if (pairs.length !== expectedPairs.length)
+    throw new ScenePreparedPlanRefusal("plan.separation.pairs", "Separation evidence must cover every constraint pair and frame.");
+  pairs.forEach((entry, index) => {
+    const pair = entry;
+    const expectedPair = expectedPairs[index];
+    if (pair.constraintIndex !== expectedPair.constraintIndex || pair.frame !== expectedPair.frame || pair.requiredGap !== expectedPair.requiredGap || canonicalScenePreparedJsonV1(pair.objects) !== canonicalScenePreparedJsonV1(expectedPair.objects))
+      throw new ScenePreparedPlanRefusal(`plan.separation.pairs.${index}`, "Separation evidence order or authored constraint facts disagree.");
+  });
+  const ledger = record(plan.ledger, "plan.ledger");
+  exactKeys(
+    ledger,
+    [
+      "owner",
+      "invariant",
+      "allocations",
+      "byOwner",
+      "surfaceTextureBytes",
+      "contextGlBytes",
+      "preparationPeakGlBytes",
+      "cpuBytes",
+      "peakDeclaredLiveBytes",
+      "budgetTriangles",
+      "instantiatedTriangles",
+      "exclusions"
+    ],
+    "plan.ledger"
+  );
+  stringValue(ledger.owner, "plan.ledger.owner");
+  if (ledger.invariant !== "one-plan-one-webgl-context") throw new ScenePreparedPlanRefusal("plan.ledger.invariant", "Invalid ledger invariant.");
+  allocationArray(ledger.allocations, "plan.ledger.allocations");
+  const canonicalOwner = `scene-plan:${objects.map((value) => value.authoredId).join(",")}`;
+  if (ledger.owner !== canonicalOwner) throw new ScenePreparedPlanRefusal("plan.ledger.owner", "Ledger owner does not match prepared objects.");
+  const allocationRows = ledger.allocations;
+  const byOwner = {};
+  for (const allocation2 of allocationRows) {
+    const row = byOwner[allocation2.owner] ??= {
+      contextGlBytes: 0,
+      preparationGlBytes: 0,
+      cpuBytes: 0
+    };
+    if (allocation2.domain === "cpu") row.cpuBytes += allocation2.bytes;
+    else if (allocation2.lifetime === "context") row.contextGlBytes += allocation2.bytes;
+    else row.preparationGlBytes += allocation2.bytes;
+  }
+  const suppliedOwners = record(ledger.byOwner, "plan.ledger.byOwner");
+  if (canonicalScenePreparedJsonV1(suppliedOwners) !== canonicalScenePreparedJsonV1(byOwner))
+    throw new ScenePreparedPlanRefusal("plan.ledger.byOwner", "Owner totals do not recompute from allocation rows.");
+  const exclusions = record(ledger.exclusions, "plan.ledger.exclusions");
+  exactKeys(
+    exclusions,
+    [
+      "crossContextAndHostAggregation",
+      "videoDecode",
+      "browserProcess",
+      "sourceBundles",
+      "captureSession",
+      "driverAllocations",
+      "compositorSurfaces",
+      "decoderCaches"
+    ],
+    "plan.ledger.exclusions"
+  );
+  const requiredExclusions = {
+    crossContextAndHostAggregation: "W7",
+    videoDecode: surfaces.some((surface) => surface.binding && surface.binding.source === "video") ? "binding-owned" : "W6",
+    browserProcess: "host-owned",
+    sourceBundles: "host-owned",
+    captureSession: "provider-owned",
+    driverAllocations: "excluded-unmeasured",
+    compositorSurfaces: "excluded-unmeasured",
+    decoderCaches: "excluded-unmeasured"
+  };
+  if (canonicalScenePreparedJsonV1(exclusions) !== canonicalScenePreparedJsonV1(requiredExclusions))
+    throw new ScenePreparedPlanRefusal("plan.ledger.exclusions", "Ledger exclusions are not canonical.");
+  const contextGl = allocationRows.filter((row) => row.domain === "gl" && row.lifetime === "context").reduce((sum, row) => sum + row.bytes, 0);
+  const preparationGl = allocationRows.filter((row) => row.domain === "gl" && row.lifetime === "preparation").reduce((sum, row) => sum + row.bytes, 0);
+  const cpu = allocationRows.filter((row) => row.domain === "cpu").reduce((sum, row) => sum + row.bytes, 0);
+  const surfaceBytes = allocationRows.filter((row) => row.domain === "gl" && row.resource === "texture" && row.name === "surface-texture").reduce((sum, row) => sum + row.bytes, 0);
+  const budgetTriangles = objects.reduce(
+    (sum, value) => sum + (value.builder?.budgetTriangles ?? 0),
+    0
+  );
+  const instantiatedTriangles = objects.flatMap((value) => value.parts).reduce((sum, part) => sum + (part.mounted ? part.triangles : 0), 0);
+  const totals = {
+    surfaceTextureBytes: surfaceBytes,
+    contextGlBytes: contextGl,
+    preparationPeakGlBytes: contextGl + preparationGl,
+    cpuBytes: cpu,
+    peakDeclaredLiveBytes: contextGl + preparationGl + cpu,
+    budgetTriangles,
+    instantiatedTriangles
+  };
+  for (const [key, expectedValue] of Object.entries(totals)) {
+    finiteNumber(ledger[key], `plan.ledger.${key}`, {
+      integer: true,
+      nonnegative: true
+    });
+    if (ledger[key] !== expectedValue) throw new ScenePreparedPlanRefusal(`plan.ledger.${key}`, `${key} does not recompute from sealed facts.`);
+  }
+  if (surfaceBytes > SCENE_SURFACE_TEXTURE_BUDGET_BYTES || contextGl + preparationGl > SCENE_CONTEXT_GL_BUDGET_BYTES || budgetTriangles > SCENE_MAX_TRIANGLES)
+    throw new ScenePreparedPlanRefusal("plan.ledger", "Sealed plan exceeds the portable scene budget.");
+  const expectedBase = [
+    ...objects.flatMap((value) => {
+      const object = value;
+      const builder = object.builder;
+      return (builder?.allocations ?? []).map((allocation2) => ({
+        ...allocation2,
+        owner: `${object.authoredId}:${allocation2.owner}`
+      }));
+    }),
+    ...plan.rigAllocations.map((allocation2) => ({ ...allocation2, owner: `rig:${allocation2.owner}` }))
+  ];
+  const actualBase = allocationRows.filter(
+    (row) => row.name !== "surface-texture" && row.name !== "owned-video-canvas" && !(row.owner.startsWith("capture:") && ["encoded-image", "decoded-rgba", "encoded-video"].includes(row.name))
+  );
+  if (canonicalScenePreparedJsonV1(actualBase) !== canonicalScenePreparedJsonV1(expectedBase))
+    throw new ScenePreparedPlanRefusal("plan.ledger.allocations", "Base allocation rows disagree with object and rig facts.");
+  const expectedSurfaceRows = surfaces.flatMap((value) => {
+    const surface = value;
+    const realized = surface.realized;
+    if (realized.source === "color") return [];
+    const image = realized.source === "video" ? realized.video : realized.image;
+    return [
+      {
+        owner: surface.path,
+        name: "surface-texture",
+        domain: "gl",
+        resource: "texture",
+        format: "rgba8",
+        bytes: fullMipBytes(image.width, image.height),
+        lifetime: "context"
+      }
+    ];
+  });
+  const actualSurfaceRows = allocationRows.filter((row) => row.name === "surface-texture");
+  if (canonicalScenePreparedJsonV1(actualSurfaceRows) !== canonicalScenePreparedJsonV1(expectedSurfaceRows))
+    throw new ScenePreparedPlanRefusal("plan.ledger.surfaceTextureBytes", "Surface texture rows disagree with realized images.");
+  const seenHandles = /* @__PURE__ */ new Set();
+  const expectedCaptureRows = surfaces.flatMap((value) => {
+    const realized = value.realized;
+    if (realized.source === "color") return [];
+    const image = realized.source === "video" ? realized.video : realized.image;
+    const handle = image.handle;
+    const firstHandle = !seenHandles.has(handle);
+    seenHandles.add(handle);
+    if (realized.source === "video") return [
+      ...firstHandle ? [{ owner: `capture:${handle}`, name: "encoded-video", domain: "cpu", resource: "encoded-video", format: image.mimeType, bytes: image.byteLength, lifetime: "context" }] : [],
+      { owner: value.path, name: "owned-video-canvas", domain: "cpu", resource: "decoded-video", format: "rgba8", bytes: image.width * image.height * 4, lifetime: "context" }
+    ];
+    if (!firstHandle) return [];
+    return [
+      {
+        owner: `capture:${handle}`,
+        name: "encoded-image",
+        domain: "cpu",
+        resource: "encoded-image",
+        format: image.mimeType,
+        bytes: image.byteLength,
+        lifetime: "context"
+      },
+      {
+        owner: `capture:${handle}`,
+        name: "decoded-rgba",
+        domain: "cpu",
+        resource: "decoded-image",
+        format: "rgba8",
+        bytes: image.width * image.height * 4,
+        lifetime: "preparation"
+      }
+    ];
+  });
+  const actualCaptureRows = allocationRows.filter((row) => row.owner.startsWith("capture:") && ["encoded-image", "decoded-rgba", "encoded-video"].includes(row.name) || row.name === "owned-video-canvas");
+  if (canonicalScenePreparedJsonV1(actualCaptureRows) !== canonicalScenePreparedJsonV1(expectedCaptureRows))
+    throw new ScenePreparedPlanRefusal("plan.ledger.allocations", "Capture allocation rows disagree with realized images.");
+  canonicalScenePreparedJsonV1(plan);
+}
+function canonicalScenePreparedJsonV1(value, path = "plan") {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new ScenePreparedPlanRefusal(path, `${path} must be finite.`);
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map((entry, index) => canonicalScenePreparedJsonV1(entry, `${path}.${index}`)).join(",")}]`;
+  const object = record(value, path);
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalScenePreparedJsonV1(object[key], `${path}.${key}`)}`).join(",")}}`;
+}
+function parseSealedSceneShotPlanV1(value) {
+  const plan = record(value, "plan");
+  exactKeys(
+    plan,
+    [
+      "version",
+      "status",
+      "sealSha256",
+      "scene",
+      "output",
+      "cameraIdentity",
+      "motion",
+      "objects",
+      "surfaces",
+      "separation",
+      "rigIdentity",
+      "rigAllocations",
+      "fonts",
+      "ledger"
+    ],
+    "plan"
+  );
+  if (plan.version !== 1) throw new ScenePreparedPlanRefusal("plan.version", "Prepared plan version must be 1.");
+  if (plan.status !== "sealed") throw new ScenePreparedPlanRefusal("plan.status", "Prepared plan status must be sealed.");
+  sha256Value(plan.sealSha256, "plan.sealSha256");
+  const output = record(plan.output, "plan.output");
+  exactKeys(output, ["width", "height", "fps", "durationInFrames"], "plan.output");
+  const fps = record(output.fps, "plan.output.fps");
+  exactKeys(fps, ["num", "den"], "plan.output.fps");
+  for (const [path, number] of [
+    ["plan.output.width", output.width],
+    ["plan.output.height", output.height],
+    ["plan.output.durationInFrames", output.durationInFrames],
+    ["plan.output.fps.num", fps.num],
+    ["plan.output.fps.den", fps.den]
+  ]) {
+    if (!Number.isSafeInteger(number) || number <= 0) throw new ScenePreparedPlanRefusal(path, `${path} must be a positive safe integer.`);
+  }
+  const gcd2 = (a, b) => b === 0 ? a : gcd2(b, a % b);
+  if (gcd2(fps.num, fps.den) !== 1)
+    throw new ScenePreparedPlanRefusal("plan.output.fps", "Sealed output FPS must be reduced to canonical terms.");
+  for (const key of ["objects", "surfaces", "rigAllocations", "fonts"])
+    if (!Array.isArray(plan[key])) throw new ScenePreparedPlanRefusal(`plan.${key}`, `plan.${key} must be an array.`);
+  let scene;
+  try {
+    scene = parseSceneShotSpecV2(plan.scene);
+  } catch (error) {
+    const issue = error && typeof error === "object" && "issues" in error && Array.isArray(error.issues) ? error.issues[0]?.path ?? [] : [];
+    throw new ScenePreparedPlanRefusal(`plan.scene${issue.map((part) => `.${String(part)}`).join("")}`, "Invalid authored scene in sealed plan.");
+  }
+  if (scene.referenceSize.width * output.height !== scene.referenceSize.height * output.width)
+    throw new ScenePreparedPlanRefusal("plan.scene.referenceSize", "Scene reference size and sealed output have different aspect ratios.");
+  validateNestedPlan(plan, scene);
+  const clone = structuredClone(plan);
+  clone.scene = scene;
+  canonicalScenePreparedJsonV1(clone);
+  return clone;
+}
+async function verifySealedSceneShotPlanV1(value, sha256) {
+  const plan = parseSealedSceneShotPlanV1(value);
+  const { sealSha256, ...facts } = plan;
+  const actual = await sha256(canonicalScenePreparedJsonV1(facts));
+  if (actual !== sealSha256) throw new ScenePreparedPlanRefusal("plan.sealSha256", "Prepared plan seal does not match its canonical facts.");
+  for (const [index, surface] of plan.surfaces.entries()) {
+    if (surface.realized.source !== "component") continue;
+    const captureSha256 = await sha256(canonicalCaptureIdentityV1(surface.realized.captureIdentityFacts));
+    if (captureSha256 !== surface.realized.captureIdentitySha256)
+      throw new ScenePreparedPlanRefusal(
+        `plan.surfaces.${index}.realized.captureIdentitySha256`,
+        "Component capture identity digest does not match its canonical facts."
+      );
+  }
+  const freeze = (entry) => {
+    if (entry && typeof entry === "object" && !Object.isFrozen(entry)) {
+      Object.freeze(entry);
+      Object.values(entry).forEach(freeze);
+    }
+  };
+  freeze(plan);
+  return plan;
+}
+
+export {
+  SCENE_SHOT_SPEC_VERSION,
+  SCENE_MAX_LAYERS,
+  SCENE_MAX_GROUP_DEPTH,
+  SCENE_MAX_KEYFRAMES_PER_CHANNEL,
+  SCENE_MAX_KEYFRAMES_PER_SHOT,
+  SCENE_MAX_SURFACES,
+  SCENE_FOV_MIN,
+  SCENE_FOV_MAX,
+  SCENE_LAYER_ID_PATTERN,
+  SCENE_ASSET_SLOT_PATTERN,
+  SCENE_BRAND_COLOR_TOKENS,
+  SCENE_BRAND_FONT_TOKENS,
+  SceneHexColor,
+  SceneBrandColorRef,
+  SceneColor,
+  SceneBrandFontRef,
+  SCENE_FONT_FAMILY_PATTERN,
+  SceneAdmittedFontFamily,
+  SceneFontFamily,
+  SceneLayerId,
+  SceneAssetSlot,
+  SceneReferenceSizeV2,
+  SceneCameraInputV2,
+  SceneCameraV2,
+  SceneTransformV2,
+  SceneBackdropV2,
+  SceneSurfaceBindingV2,
+  SceneMaterialOverrideV2,
+  SceneObjectV2,
+  SceneEasingV2,
+  SceneKeyframeV2,
+  SceneChannelTargetV2,
+  SceneChannelV2,
+  SCENE_CAMERA_PROPERTIES,
+  SCENE_WORLD_OBJECT_PROPERTIES,
+  SCENE_LAPTOP_PROPERTIES,
+  SCENE_SCREEN_TEXT_PROPERTIES,
+  SCENE_ENVIRONMENT_PROPERTIES,
+  SCENE_FOCUS_PROPERTIES,
+  SCENE_CHANNEL_PROPERTIES,
+  SceneFocusV2,
+  ScenePostV2,
+  SceneRigV2,
+  SceneConstraintV2,
+  SCENE_PRESET_SLOTS,
+  SCENE_PRESET_MATERIAL_ROLES,
+  SceneShotSpecV2,
+  parseSceneShotSpecV2,
+  sceneShotImageSlots,
+  sceneShotVideoSlots,
+  sceneShotSurfaceCount,
+  sceneShotJsonSchema,
+  sceneShotJsonSchemaText,
+  contentFrame,
+  normalizedTime,
+  cubicBezierEase,
+  evaluateChannel,
+  sceneTransformMatrix,
+  evaluateScene,
+  isSceneShotSource,
+  readSceneSourceRef,
+  isTimelineClip,
+  isSceneShotClip,
+  offFrameLattice,
+  SCENE_TRANSITION_KINDS,
+  sceneTransitionDurationIssues,
+  sceneSpecIssues,
+  sceneClipShapeIssues,
+  sceneClipOverlapIssue,
+  sceneDedicatedTrackIssue,
+  collectSceneClipIssues,
+  SceneConstraintRefusal,
+  sceneRotationAxesV2,
+  sceneOrientedBoundsV2,
+  sceneSeparatingAxisGapV2,
+  evaluateSceneSeparationV2,
+  SCENE_SHOT_EXAMPLES,
+  sceneShotExample,
+  assertSceneShotExamplesValid,
+  STUDIO_SHADOW_MAP_BUDGET,
+  SCENE_TESSELLATION_VERSION,
+  SCENE_SLAB_BODY_TRIANGLES,
+  SCENE_SLAB_CONTENT_FACE_TRIANGLES,
+  SCENE_SLAB_CONTENT_OFFSET,
+  SCENE_PRESET_TRIANGLES,
+  sceneFullMipLevels,
+  sceneMipTexels,
+  sceneTextureBytes,
+  sceneTriangleCount,
+  sceneDeviceDimensionsV1,
+  sceneLaptopLayoutV1,
+  SCENE_DEVICE_SCREEN_OFFSET_V1,
+  sceneLaptopScreenQuadV1,
+  PHOTOGRAPHIC_STUDIO_RIG_ID,
+  PHOTOGRAPHIC_STUDIO_HDRI_PATH,
+  PHOTOGRAPHIC_STUDIO_HDRI_SHA256,
+  PHOTOGRAPHIC_STUDIO_HDRI_BYTES,
+  PHOTOGRAPHIC_STUDIO_PMREM_VERSION,
+  PHOTOGRAPHIC_STUDIO_LIGHTING_VERSION,
+  PHOTOGRAPHIC_STUDIO_EDGE_INTENSITY,
+  PHOTOGRAPHIC_STUDIO_EDGE_LIGHTS,
+  PHOTOGRAPHIC_STUDIO_GPU_BYTES,
+  PHOTOGRAPHIC_STUDIO_RIG_FACTS,
+  photographicStudioPreparationFactsV1,
+  sceneFocusPreparationAllocationsV1,
+  photographicSceneRigFactsV1,
+  SceneVideoAdmissionRefusal,
+  canonicalSceneVideoRateV1,
+  verifySceneVideoPresentationIndexV1,
+  prepareSceneVideoScheduleV1,
+  sceneVideoSourceIndexV1,
+  sceneVideoMidpointAddressV1,
+  RESOLUTION_BOUND,
+  ALLOWED_BAKE_SCALES,
+  DEFAULT_BAKE_SCALE,
+  sceneCameraPlanesV2,
+  SceneResolutionRefusal,
+  projectToOutputPixels,
+  projectedSlotEdges,
+  checkSurfaceResolution,
+  selectSceneBakeScale,
+  ScenePreparedPlanRefusal,
+  sceneW5PresetAllocationsV1,
+  sceneW5WorldTextAllocationsV1,
+  sceneW5GeneratedRigAllocationsV1,
+  SCENE_CAPTURE_IDENTITY_FIELDS_V1,
+  canonicalScenePreparedJsonV1,
+  parseSealedSceneShotPlanV1,
+  verifySealedSceneShotPlanV1
+};