@cueframe/kernel 0.2.1 → 0.2.3

package/dist/{chunk-6XI57FZZ.js → chunk-YFSBFCXO.js}

@@ -3,6 +3,10 @@ import {
   buildEasedZooms,
   buildPannedCenters
 } from "./chunk-QH3YI3ND.js";
+import {
+  flattenCompoundClips,
+  hasCompoundClips
+} from "./chunk-QISFYLBB.js";
 import {
   DOMINANCE_WEIGHTS,
   ENTER_SEC,
@@ -20,11 +24,7 @@ import {
   scoreAndRank,
   segmentShots,
   stabilizeSelectionHysteresis
-} from "./chunk-LNBVTDFR.js";
-import {
-  flattenCompoundClips,
-  hasCompoundClips
-} from "./chunk-QISFYLBB.js";
+} from "./chunk-L2AHS3AW.js";
 import {
   compositionHasVo,
   roleDefaultGainDb
@@ -36,7 +36,856 @@ import {
 import {
   CueframeError,
   encodeError
-} from "./chunk-4FOOBSEE.js";
+} from "./chunk-J3DIUG24.js";
+import {
+  bundledFontFaceExists,
+  mergedCaptionFaceIssues,
+  unrenderableFaceField
+} from "./chunk-TARKDVP6.js";
+import {
+  SCENE_CAPTURE_IDENTITY_FIELDS_V1,
+  SCENE_PRESET_TRIANGLES,
+  SCENE_SLAB_CONTENT_FACE_TRIANGLES,
+  SCENE_SLAB_CONTENT_OFFSET,
+  collectSceneClipIssues,
+  evaluateScene,
+  evaluateSceneSeparationV2,
+  isSceneShotClip,
+  parseSceneShotSpecV2,
+  prepareSceneVideoScheduleV1,
+  sceneFullMipLevels,
+  sceneTextureBytes,
+  selectSceneBakeScale
+} from "./chunk-MH3UPKWR.js";
+import {
+  SCENE_CONTEXT_GL_BUDGET_BYTES,
+  SCENE_MAX_TRIANGLES,
+  SCENE_SURFACE_TEXTURE_BUDGET_BYTES
+} from "./chunk-2L7PYYJK.js";
+
+// ../execution/core/src/render/sceneCaptureIdentity.ts
+var INTENT_FIELDS = [
+  "componentId",
+  "sourceVersionId",
+  "params",
+  "assetBindings",
+  "layoutWidth",
+  "layoutHeight",
+  "bakeScale",
+  "captureFrame",
+  "durationInFrames",
+  "fps",
+  "seed",
+  "brandFacts",
+  "fontFacts",
+  "mediaFacts",
+  "rasterWidth",
+  "rasterHeight",
+  "expectedDeviceScaleFactor",
+  "runtimeIdentity",
+  "dependencyIdentity",
+  "requestedGlBackend",
+  "rasterAffectingFlags"
+];
+var SCENE_CAPTURE_IDENTITY_FIELDS = SCENE_CAPTURE_IDENTITY_FIELDS_V1;
+var SceneCaptureIdentityRefusal = class extends Error {
+  constructor(path, message) {
+    super(message);
+    this.path = path;
+    this.name = "SceneCaptureIdentityRefusal";
+  }
+  path;
+};
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value).sort().map((key) => [key, canonical(value[key])])
+    );
+  }
+  return value;
+}
+function canonicalSceneJsonV1(value, path = "value") {
+  assertJson(value, path);
+  return JSON.stringify(canonical(value));
+}
+function assertJson(value, path) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) return;
+    throw new SceneCaptureIdentityRefusal(path, `${path} must be finite.`);
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertJson(entry, `${path}.${index}`));
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, entry] of Object.entries(value)) assertJson(entry, `${path}.${key}`);
+    return;
+  }
+  throw new SceneCaptureIdentityRefusal(path, `${path} must be canonical JSON.`);
+}
+function normalizedRate(value, path = "fps") {
+  const fps = value;
+  if (!fps || typeof fps !== "object" || Array.isArray(fps) || Object.keys(fps).length !== 2 || Object.keys(fps).some((key) => key !== "num" && key !== "den") || !Number.isSafeInteger(fps.num) || !Number.isSafeInteger(fps.den) || fps.num <= 0 || fps.den <= 0) throw new SceneCaptureIdentityRefusal(path, `${path} must be an exact positive safe-integer rational.`);
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  const divisor = gcd(fps.num, fps.den);
+  return { num: fps.num / divisor, den: fps.den / divisor };
+}
+function parseSceneComponentCaptureIntentV1(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new SceneCaptureIdentityRefusal("captureIntent", "captureIntent must be an object.");
+  const record = value;
+  const allowed = new Set(INTENT_FIELDS);
+  const unknown = Object.keys(record).find((key) => !allowed.has(key));
+  if (unknown) throw new SceneCaptureIdentityRefusal(unknown, `Unknown capture intent field ${unknown}.`);
+  for (const field of INTENT_FIELDS) if (!(field in record)) throw new SceneCaptureIdentityRefusal(field, `Missing capture intent field ${field}.`);
+  for (const field of ["params", "assetBindings", "brandFacts", "fontFacts", "mediaFacts", "rasterAffectingFlags"]) assertJson(record[field], field);
+  for (const field of ["layoutWidth", "layoutHeight", "durationInFrames", "rasterWidth", "rasterHeight"]) if (!Number.isSafeInteger(record[field]) || record[field] <= 0) throw new SceneCaptureIdentityRefusal(field, `${field} must be a positive safe integer.`);
+  if (!Number.isSafeInteger(record.captureFrame) || record.captureFrame < 0 || record.captureFrame >= record.durationInFrames) throw new SceneCaptureIdentityRefusal("captureFrame", "captureFrame must be within component duration.");
+  if (record.bakeScale !== 2 && record.bakeScale !== 3) throw new SceneCaptureIdentityRefusal("bakeScale", "bakeScale must be 2 or 3.");
+  if (record.expectedDeviceScaleFactor !== record.bakeScale) throw new SceneCaptureIdentityRefusal("expectedDeviceScaleFactor", "Expected page DPR must equal selected bakeScale.");
+  if (record.rasterWidth !== record.layoutWidth * record.bakeScale || record.rasterHeight !== record.layoutHeight * record.bakeScale) throw new SceneCaptureIdentityRefusal("rasterWidth", "Raster dimensions must equal layout multiplied by bakeScale.");
+  for (const field of ["componentId", "sourceVersionId", "seed", "runtimeIdentity", "dependencyIdentity", "requestedGlBackend"]) if (typeof record[field] !== "string" || !record[field].length) throw new SceneCaptureIdentityRefusal(field, `${field} must be a non-empty string.`);
+  if (!/^[a-f0-9]{64}$/.test(record.sourceVersionId)) throw new SceneCaptureIdentityRefusal("sourceVersionId", "sourceVersionId must be a lowercase SHA-256 digest.");
+  return { ...record, fps: normalizedRate(record.fps) };
+}
+var integerFields = /* @__PURE__ */ new Set([
+  "layoutWidth",
+  "layoutHeight",
+  "captureFrame",
+  "durationInFrames",
+  "rasterWidth",
+  "rasterHeight"
+]);
+var jsonFields = /* @__PURE__ */ new Set([
+  "params",
+  "assetBindings",
+  "brandFacts",
+  "fontFacts",
+  "mediaFacts",
+  "rasterAffectingFlags"
+]);
+function parseSceneComponentCaptureIdentityV1(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new SceneCaptureIdentityRefusal("captureIdentity", "captureIdentity must be an object.");
+  }
+  const record = value;
+  const allowed = new Set(SCENE_CAPTURE_IDENTITY_FIELDS);
+  const unknown = Object.keys(record).find((key) => !allowed.has(key));
+  if (unknown) throw new SceneCaptureIdentityRefusal(unknown, `Unknown capture identity field ${unknown}.`);
+  for (const field of SCENE_CAPTURE_IDENTITY_FIELDS) {
+    if (!(field in record)) throw new SceneCaptureIdentityRefusal(field, `Missing capture identity field ${field}.`);
+    const entry = record[field];
+    if (jsonFields.has(field)) assertJson(entry, field);
+    else if (integerFields.has(field) && (!Number.isSafeInteger(entry) || entry < (field === "captureFrame" ? 0 : 1))) {
+      throw new SceneCaptureIdentityRefusal(field, `${field} must be a ${field === "captureFrame" ? "non-negative" : "positive"} safe integer.`);
+    }
+  }
+  if (record.bakeScale !== 2 && record.bakeScale !== 3) throw new SceneCaptureIdentityRefusal("bakeScale", "bakeScale must be 2 or 3.");
+  if (record.headless !== true && record.headless !== false) throw new SceneCaptureIdentityRefusal("headless", "headless must be boolean.");
+  if (typeof record.deviceScaleFactor !== "number" || !Number.isFinite(record.deviceScaleFactor) || record.deviceScaleFactor <= 0) throw new SceneCaptureIdentityRefusal("deviceScaleFactor", "deviceScaleFactor must be positive and finite.");
+  const fps = normalizedRate(record.fps);
+  if (record.captureFrame >= record.durationInFrames) throw new SceneCaptureIdentityRefusal("captureFrame", "captureFrame must be before durationInFrames.");
+  if (record.rasterWidth !== record.layoutWidth * record.bakeScale || record.rasterHeight !== record.layoutHeight * record.bakeScale) throw new SceneCaptureIdentityRefusal("rasterWidth", "raster dimensions must equal layout multiplied by bakeScale.");
+  for (const field of SCENE_CAPTURE_IDENTITY_FIELDS) {
+    if (jsonFields.has(field) || integerFields.has(field) || field === "fps" || field === "bakeScale" || field === "headless" || field === "deviceScaleFactor") continue;
+    if (field === "gpuIdentity" && record[field] === null) continue;
+    if (typeof record[field] !== "string" || record[field].length === 0) throw new SceneCaptureIdentityRefusal(field, `${field} must be a non-empty string.`);
+  }
+  for (const digestField of ["sourceVersionId", "browserExecutableSha256"]) {
+    if (!/^[a-f0-9]{64}$/.test(record[digestField])) throw new SceneCaptureIdentityRefusal(digestField, `${digestField} must be a lowercase SHA-256 digest.`);
+  }
+  return { ...record, fps };
+}
+function completeSceneComponentCaptureIdentityV1(intent, attestation) {
+  intent = parseSceneComponentCaptureIntentV1(intent);
+  if (attestation.loadedRuntimeIdentity !== intent.runtimeIdentity) throw new SceneCaptureIdentityRefusal("runtimeIdentity", "The admitted session loaded a different runtime identity.");
+  if (attestation.loadedDependencyIdentity !== intent.dependencyIdentity) throw new SceneCaptureIdentityRefusal("dependencyIdentity", "The admitted session loaded a different dependency identity.");
+  const intendedFlags = intent.rasterAffectingFlags.browserArguments;
+  const observedFlags = attestation.observedRasterAffectingFlags.browserArguments;
+  if (!Array.isArray(intendedFlags) || !Array.isArray(observedFlags) || intendedFlags.some((flag) => typeof flag !== "string") || observedFlags.some((flag) => typeof flag !== "string"))
+    throw new SceneCaptureIdentityRefusal("rasterAffectingFlags", "The admitted session did not report canonical browser arguments.");
+  const dynamicVideoThreads = observedFlags.filter((flag) => /^--video-threads=[1-9]\d*$/.test(flag));
+  const comparableObserved = observedFlags.filter((flag) => !flag.startsWith("--video-threads="));
+  if (dynamicVideoThreads.length !== 1 || JSON.stringify(canonical(comparableObserved)) !== JSON.stringify(canonical(intendedFlags)))
+    throw new SceneCaptureIdentityRefusal("rasterAffectingFlags", "The admitted session used different raster-affecting flags.");
+  if (attestation.deviceScaleFactor !== intent.expectedDeviceScaleFactor) throw new SceneCaptureIdentityRefusal("deviceScaleFactor", "The capture page device scale factor differs from the selected bake scale.");
+  const { loadedRuntimeIdentity: _runtime, loadedDependencyIdentity: _dependency, observedRasterAffectingFlags: _flags, ...observedIdentity } = attestation;
+  const { expectedDeviceScaleFactor: _expectedDsf, ...identityIntent } = intent;
+  return parseSceneComponentCaptureIdentityV1({ ...identityIntent, ...observedIdentity, rasterAffectingFlags: attestation.observedRasterAffectingFlags });
+}
+function canonicalSceneComponentCaptureIdentityV1(value) {
+  const identity = parseSceneComponentCaptureIdentityV1(value);
+  const ordered = Object.fromEntries(
+    SCENE_CAPTURE_IDENTITY_FIELDS.map((field) => [field, canonical(identity[field])])
+  );
+  return JSON.stringify(ordered);
+}
+
+// ../execution/core/src/render/slabDescriptor.ts
+var SCENE_SLAB_CONTENT_OFFSET_V1 = SCENE_SLAB_CONTENT_OFFSET;
+function sceneSlabBuilderDescriptorV1(slab, allocations, measuredBodyTriangles) {
+  const z = slab.thickness / 2 + SCENE_SLAB_CONTENT_OFFSET_V1;
+  return {
+    kind: "slab",
+    builderVersion: 1,
+    tessellationVersion: 1,
+    budgetTriangles: SCENE_PRESET_TRIANGLES.slab,
+    parts: [
+      { partId: "body", materialRole: "body", triangles: measuredBodyTriangles, mounted: true },
+      { partId: "front", materialRole: "face", triangles: SCENE_SLAB_CONTENT_FACE_TRIANGLES, mounted: slab.surfaces?.front !== void 0 }
+    ],
+    surfaceSlots: [{
+      slot: "front",
+      attachment: { partId: "front", materialRole: "face" },
+      dimensions: { width: slab.width, height: slab.height },
+      projectionQuad: [
+        [-slab.width / 2, slab.height / 2, z],
+        [slab.width / 2, slab.height / 2, z],
+        [slab.width / 2, -slab.height / 2, z],
+        [-slab.width / 2, -slab.height / 2, z]
+      ],
+      uvOrigin: "top-left",
+      fit: "contain",
+      alpha: "straight",
+      depth: "test-only",
+      required: false,
+      bakeScales: [2, 3]
+    }],
+    materialRoles: ["body", "face"],
+    localBounds: { center: [0, 0, 0], halfExtents: [slab.width / 2, slab.height / 2, slab.thickness / 2] },
+    allocations
+  };
+}
+function createSceneSlabDescriptorRegistryV1(factsFor) {
+  return {
+    resolve(object) {
+      if (object.kind !== "slab") return null;
+      const facts = factsFor(object);
+      return sceneSlabBuilderDescriptorV1(object, facts.allocations, facts.measuredBodyTriangles);
+    }
+  };
+}
+function createSceneBuilderDescriptorRegistryV1(resolveDescriptor) {
+  return {
+    resolve(object, context) {
+      const descriptor = resolveDescriptor(object, context);
+      if (!descriptor) return null;
+      if (descriptor.kind !== object.kind) throw new Error(`scene_builder_descriptor_kind_mismatch: ${object.id}`);
+      return descriptor;
+    }
+  };
+}
+
+// ../execution/core/src/render/sceneShotPlan.ts
+var ScenePlanRefusal = class extends Error {
+  constructor(code, path, message, detail = {}) {
+    super(message);
+    this.code = code;
+    this.path = path;
+    this.detail = detail;
+    this.name = "ScenePlanRefusal";
+  }
+  code;
+  path;
+  detail;
+};
+function normalizeOutput(output) {
+  if (!Number.isSafeInteger(output.width) || output.width <= 0) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "output.width", "Output width must be a positive safe integer.");
+  if (!Number.isSafeInteger(output.height) || output.height <= 0) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "output.height", "Output height must be a positive safe integer.");
+  if (!Number.isSafeInteger(output.durationInFrames) || output.durationInFrames <= 0) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "output.durationInFrames", "Duration must be a positive safe integer.");
+  if (!Number.isSafeInteger(output.fps.num) || !Number.isSafeInteger(output.fps.den) || output.fps.num <= 0 || output.fps.den <= 0) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "output.fps", "Output fps must be an exact positive rational.");
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  const divisor = gcd(output.fps.num, output.fps.den);
+  return { ...output, fps: { num: output.fps.num / divisor, den: output.fps.den / divisor } };
+}
+function flatten(objects, parentId = null, prefix = "layers") {
+  const out = [];
+  objects.forEach((object, index) => {
+    const path = `${prefix}.${index}`;
+    out.push({ object, parentId, path });
+    if (object.kind === "group") out.push(...flatten(object.children, object.id, `${path}.children`));
+  });
+  return out;
+}
+function evaluatedChains(objects, ancestors = [], out = /* @__PURE__ */ new Map()) {
+  for (const object of objects) {
+    if (object.kind === "text" && object.space === "screen") continue;
+    const chain = [...ancestors, object.transform];
+    out.set(object.id, chain);
+    if (object.kind === "group" && object.children) evaluatedChains(object.children, chain, out);
+  }
+  return out;
+}
+function evaluatedById(objects, out = /* @__PURE__ */ new Map()) {
+  for (const object of objects) {
+    out.set(object.id, object);
+    if (object.kind === "group" && object.children) evaluatedById(object.children, out);
+  }
+  return out;
+}
+function assertFiniteEvaluation(frame, evaluation) {
+  const { layers: objects, camera } = evaluation;
+  const cameraValues = [...camera.position, ...camera.rotation, camera.fov];
+  if (cameraValues.some((value) => !Number.isFinite(value)) || camera.fov < 18 * Math.PI / 180 || camera.fov > 80 * Math.PI / 180) {
+    throw new ScenePlanRefusal("scene_evaluated_value_invalid", "camera", `Camera is invalid at content frame ${frame}.`, { frame, camera });
+  }
+  for (const entry of flatten(objects)) {
+    const object = entry.object;
+    if (!Number.isFinite(object.opacity) || object.opacity < 0 || object.opacity > 1) throw new ScenePlanRefusal("scene_evaluated_value_invalid", `${entry.path}.opacity`, `Object ${object.id} opacity is invalid at content frame ${frame}.`, { frame, authoredId: object.id });
+    if (object.kind === "text" && object.space === "screen") {
+      if ([object.x, object.y, object.rotation, object.scale].some((value) => !Number.isFinite(value)) || object.scale <= 0) throw new ScenePlanRefusal("scene_evaluated_value_invalid", entry.path, `Screen text ${object.id} is invalid at content frame ${frame}.`, { frame, authoredId: object.id });
+      continue;
+    }
+    const values = [...object.transform.position, ...object.transform.rotation, object.transform.scale, object.opacity];
+    if (values.some((value) => !Number.isFinite(value)) || object.transform.scale <= 0) {
+      throw new ScenePlanRefusal("scene_evaluated_value_invalid", entry.path, `Object ${object.id} is invalid at content frame ${frame}.`, { frame, authoredId: object.id });
+    }
+    const evaluated = object;
+    if (!evaluated.worldMatrix || evaluated.worldMatrix.some((value) => !Number.isFinite(value))) throw new ScenePlanRefusal("scene_evaluated_value_invalid", `${entry.path}.transform`, `Object ${object.id} world matrix is invalid at content frame ${frame}.`, { frame, authoredId: object.id });
+    if (object.kind === "laptop" && (!Number.isFinite(object.openAngle) || object.openAngle < 0 || object.openAngle > Math.PI)) throw new ScenePlanRefusal("scene_evaluated_value_invalid", `${entry.path}.openAngle`, `Laptop hinge is invalid at content frame ${frame}.`, { frame, authoredId: object.id });
+  }
+  if (evaluation.environment.kind !== "photographic-studio-v1" && (!Number.isFinite(evaluation.environment.intensity) || evaluation.environment.intensity < 0)) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "environment.intensity", `Environment intensity is invalid at content frame ${frame}.`, { frame });
+  if (evaluation.focus && (!Number.isFinite(evaluation.focus.distance) || evaluation.focus.distance <= 0 || !Number.isFinite(evaluation.focus.range) || evaluation.focus.range <= 0 || !Number.isFinite(evaluation.focus.maxBlur) || evaluation.focus.maxBlur < 0 || evaluation.focus.maxBlur > 64)) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "post.focus", `Focus is invalid at content frame ${frame}.`, { frame, focus: evaluation.focus });
+}
+function descriptorFor(entry, registry, context) {
+  if (entry.object.kind === "group" || entry.object.kind === "text" && entry.object.space === "screen") return null;
+  const descriptor = registry.resolve(entry.object, context);
+  if (!descriptor) throw new ScenePlanRefusal("scene_builder_descriptor_unavailable", `${entry.path}.kind`, `No implemented builder descriptor is available for ${entry.object.kind}.`, { authoredId: entry.object.id, kind: entry.object.kind });
+  if (descriptor.kind !== entry.object.kind || !Number.isSafeInteger(descriptor.builderVersion) || descriptor.builderVersion <= 0 || !Number.isSafeInteger(descriptor.tessellationVersion) || descriptor.tessellationVersion <= 0) {
+    throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} does not match its materialized object state.`, { descriptor });
+  }
+  const presetBudget = SCENE_PRESET_TRIANGLES[entry.object.kind];
+  if (presetBudget !== void 0 && descriptor.budgetTriangles !== presetBudget) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} does not match the frozen preset triangle contribution.`);
+  const finiteVec = (value) => value.length === 3 && value.every(Number.isFinite);
+  if (!finiteVec(descriptor.localBounds.center) || !finiteVec(descriptor.localBounds.halfExtents) || descriptor.localBounds.halfExtents.some((value) => value < 0) || descriptor.localBounds.halfExtents.every((value) => value === 0)) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} has invalid bounds.`);
+  if (descriptor.parts.some((part) => !part.partId || !part.materialRole || typeof part.mounted !== "boolean" || !Number.isSafeInteger(part.triangles) || part.triangles < 0)) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} has invalid part facts.`);
+  if (descriptor.surfaceSlots.some((slot) => slot.dimensions.width <= 0 || slot.dimensions.height <= 0 || slot.projectionQuad.length !== 4 || slot.projectionQuad.some((point) => !finiteVec(point)))) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} has invalid slot facts.`);
+  if (!descriptor.materialRoles.length || descriptor.allocations.some((allocation) => !allocation.owner || !allocation.name || !["gl", "cpu"].includes(allocation.domain) || !["texture", "renderbuffer", "geometry", "pmrem-source", "pmrem-target", "encoded-image", "decoded-image"].includes(allocation.resource) || !allocation.format || !["preparation", "context"].includes(allocation.lifetime) || !Number.isSafeInteger(allocation.bytes) || allocation.bytes < 0)) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} has invalid allocation facts.`);
+  const partIds = descriptor.parts.map((part) => part.partId);
+  const slotIds = descriptor.surfaceSlots.map((slot) => slot.slot);
+  if (new Set(partIds).size !== partIds.length || new Set(slotIds).size !== slotIds.length || new Set(descriptor.materialRoles).size !== descriptor.materialRoles.length) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Builder descriptor for ${entry.object.id} has duplicate identities.`);
+  for (const part of descriptor.parts) if (!descriptor.materialRoles.includes(part.materialRole)) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Part ${part.partId} references undeclared material role ${part.materialRole}.`);
+  for (const slot of descriptor.surfaceSlots) if (!partIds.includes(slot.attachment.partId) || !descriptor.materialRoles.includes(slot.attachment.materialRole) || !slot.bakeScales.length || slot.bakeScales.some((scale) => scale !== 2 && scale !== 3)) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, `Slot ${slot.slot} has invalid attachment or scale facts.`);
+  for (const slot of descriptor.surfaceSlots) {
+    const part = descriptor.parts.find((candidate) => candidate.partId === slot.attachment.partId);
+    if (!part || part.materialRole !== slot.attachment.materialRole) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.surfaces.${slot.slot}`, `Slot ${slot.slot} attachment role does not match its part.`);
+    if (slot.bakeScales.length !== 2 || slot.bakeScales[0] !== 2 || slot.bakeScales[1] !== 3) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.surfaces.${slot.slot}`, `Slot ${slot.slot} must declare the complete supported bake-scale set.`);
+  }
+  if ("materials" in entry.object && entry.object.materials) {
+    const unlitRoles = entry.object.kind === "page" ? /* @__PURE__ */ new Set(["base"]) : /* @__PURE__ */ new Set(["screen", "face"]);
+    for (const [index, material] of entry.object.materials.entries()) {
+      if (!descriptor.materialRoles.includes(material.role)) throw new ScenePlanRefusal("scene_material_role_unsupported", `${entry.path}.materials.${index}.role`, `Builder ${entry.object.kind} has no material role ${material.role}.`);
+      const expected = unlitRoles.has(material.role) ? "unlit" : "physical";
+      if (material.type !== expected) throw new ScenePlanRefusal("scene_material_type_mismatch", `${entry.path}.materials.${index}.type`, `${material.role} is a ${expected} material role.`);
+    }
+  }
+  if (descriptor.kind === "slab" && entry.object.kind === "slab") {
+    const body = descriptor.parts.find((part) => part.partId === "body");
+    const front = descriptor.parts.find((part) => part.partId === "front");
+    if (descriptor.parts.length !== 2 || !body || !Number.isSafeInteger(body.triangles) || body.triangles <= 0 || body.materialRole !== "body" || !body.mounted || front?.triangles !== SCENE_SLAB_CONTENT_FACE_TRIANGLES || front.materialRole !== "face" || descriptor.surfaceSlots.length !== 1 || descriptor.surfaceSlots[0]?.slot !== "front" || descriptor.materialRoles.join(",") !== "body,face" || descriptor.allocations.length === 0) {
+      throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, "Slab descriptor does not match the admitted production builder facts.");
+    }
+    const canonical2 = sceneSlabBuilderDescriptorV1(entry.object, descriptor.allocations, body.triangles);
+    if (canonicalSceneJsonV1(descriptor) !== canonicalSceneJsonV1(canonical2)) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", `${entry.path}.kind`, "Slab descriptor differs from the canonical production descriptor for its materialized parameters.");
+  }
+  return descriptor;
+}
+function prepareSceneShotPreflightV1(args) {
+  const output = normalizeOutput(args.output);
+  const scene = parseSceneShotSpecV2(args.authoredScene);
+  if (scene.referenceSize.width * output.height !== scene.referenceSize.height * output.width) throw new ScenePlanRefusal("scene_reference_aspect_mismatch", "referenceSize", "Scene reference size and requested output have different aspect ratios.", { referenceSize: scene.referenceSize, output: { width: output.width, height: output.height } });
+  const entries = flatten(scene.layers);
+  const descriptorById = /* @__PURE__ */ new Map();
+  const objects = entries.map((entry) => {
+    const builder = descriptorFor(entry, args.descriptors, { referenceSize: scene.referenceSize, output });
+    descriptorById.set(entry.object.id, builder);
+    return {
+      authoredId: entry.object.id,
+      parentId: entry.parentId,
+      kind: entry.object.kind,
+      builder,
+      parts: builder?.parts.map((part) => ({
+        id: `${entry.object.id}:${part.partId}`,
+        partId: part.partId,
+        materialRole: part.materialRole,
+        triangles: part.triangles,
+        mounted: part.mounted
+      })) ?? []
+    };
+  });
+  const frameEvaluations = Array.from({ length: output.durationInFrames }, (_, frame) => {
+    const evaluated = evaluateScene(scene, frame, output.durationInFrames);
+    assertFiniteEvaluation(frame, evaluated);
+    return { evaluated, chains: evaluatedChains(evaluated.layers), byId: evaluatedById(evaluated.layers) };
+  });
+  const worldBounds = { minX: -scene.referenceSize.width / 2, maxX: scene.referenceSize.width / 2, minY: Math.min(-scene.referenceSize.height / 2, scene.environment.kind === "photographic-studio-v1" ? -scene.referenceSize.height / 2 : scene.environment.floorY), maxY: scene.referenceSize.height / 2, minZ: 0, maxZ: 0 };
+  const include = (x, y, z) => {
+    worldBounds.minX = Math.min(worldBounds.minX, x);
+    worldBounds.maxX = Math.max(worldBounds.maxX, x);
+    worldBounds.minY = Math.min(worldBounds.minY, y);
+    worldBounds.maxY = Math.max(worldBounds.maxY, y);
+    worldBounds.minZ = Math.min(worldBounds.minZ, z);
+    worldBounds.maxZ = Math.max(worldBounds.maxZ, z);
+  };
+  for (const frame of frameEvaluations) for (const entry of entries) {
+    const evaluated = frame.byId.get(entry.object.id);
+    if (!evaluated || evaluated.kind === "group" || evaluated.kind === "text" && evaluated.space === "screen" || !evaluated.worldMatrix) continue;
+    const descriptor = args.descriptors.resolve(evaluated, { referenceSize: scene.referenceSize, output });
+    if (!descriptor) continue;
+    const { center, halfExtents } = descriptor.localBounds;
+    for (const dx of [-halfExtents[0], halfExtents[0]]) for (const dy of [-halfExtents[1], halfExtents[1]]) for (const dz of [-halfExtents[2], halfExtents[2]]) {
+      const x = center[0] + dx, y = center[1] + dy, z = center[2] + dz, m = evaluated.worldMatrix;
+      include(m[0] * x + m[4] * y + m[8] * z + m[12], m[1] * x + m[5] * y + m[9] * z + m[13], m[2] * x + m[6] * y + m[10] * z + m[14]);
+    }
+  }
+  const rigFacts = args.resolveRigFacts(scene, worldBounds);
+  if (!rigFacts) throw new ScenePlanRefusal("scene_builder_descriptor_unavailable", "environment", "No admitted production rig identity is available.");
+  const cameraClipPlanes = frameEvaluations.map((_, frame) => {
+    const planes = args.resolveCameraClipPlanes(scene, frame, output.durationInFrames);
+    if (!Number.isFinite(planes.near) || !Number.isFinite(planes.far) || planes.near <= 0 || planes.far <= planes.near) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "camera", `Production camera clip planes are invalid at content frame ${frame}.`, { frame, planes });
+    return planes;
+  });
+  const surfaces = [];
+  for (const entry of entries) {
+    const builder = descriptorById.get(entry.object.id);
+    if (!builder || !("surfaces" in entry.object) || !entry.object.surfaces) continue;
+    for (const [slot, binding] of Object.entries(entry.object.surfaces)) {
+      const descriptor = builder.surfaceSlots.find((candidate) => candidate.slot === slot);
+      const path = `${entry.path}.surfaces.${slot}`;
+      if (!descriptor) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", path, `Builder descriptor does not declare bound slot ${slot}.`);
+      const prepared = { path, authoredObjectId: entry.object.id, slot, binding, descriptor };
+      if (binding.source === "component") {
+        const facts = args.resolveComponentFacts?.(binding, path);
+        if (!facts) throw new ScenePlanRefusal("scene_component_facts_missing", path, `Component capture facts are unavailable for ${path}.`);
+        const selection = selectSceneBakeScale({
+          surfaceId: entry.object.id,
+          slotName: slot,
+          slot: descriptor.dimensions,
+          layout: binding.layout,
+          contentDuration: output.durationInFrames,
+          output,
+          referenceSize: scene.referenceSize,
+          evaluate: (frame) => {
+            const evaluation = frameEvaluations[frame];
+            const evaluatedObject = evaluation.byId.get(entry.object.id);
+            if (!evaluatedObject) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", path, `Evaluated object ${entry.object.id} is missing.`);
+            const evaluatedDescriptor = args.descriptors.resolve(evaluatedObject, { referenceSize: scene.referenceSize, output });
+            const evaluatedSlot = evaluatedDescriptor?.surfaceSlots.find((candidate) => candidate.slot === slot);
+            if (!evaluatedDescriptor || evaluatedDescriptor.kind !== builder.kind || evaluatedDescriptor.builderVersion !== builder.builderVersion || evaluatedDescriptor.tessellationVersion !== builder.tessellationVersion || !evaluatedSlot) throw new ScenePlanRefusal("scene_builder_descriptor_invalid", path, `Builder did not supply stable evaluated attachment facts for ${path}.`, { frame });
+            return { camera: evaluation.evaluated.camera, chain: evaluation.chains.get(entry.object.id), projectionQuad: evaluatedSlot.projectionQuad };
+          }
+        }, binding.bakeScale);
+        prepared.bakeScale = selection.selected;
+        prepared.bakeScaleReason = selection.reason;
+        prepared.resolutionCheck = selection;
+        prepared.captureIntent = {
+          componentId: binding.component.componentId,
+          sourceVersionId: binding.component.sourceVersionId,
+          params: facts.params,
+          assetBindings: facts.assetBindings,
+          layoutWidth: binding.layout.width,
+          layoutHeight: binding.layout.height,
+          bakeScale: selection.selected,
+          captureFrame: binding.captureFrame,
+          durationInFrames: facts.durationInFrames,
+          fps: output.fps,
+          seed: facts.seed,
+          brandFacts: facts.brandFacts,
+          fontFacts: facts.fontFacts,
+          mediaFacts: facts.mediaFacts,
+          rasterWidth: binding.layout.width * selection.selected,
+          rasterHeight: binding.layout.height * selection.selected,
+          expectedDeviceScaleFactor: selection.selected,
+          runtimeIdentity: facts.runtimeIdentity,
+          dependencyIdentity: facts.dependencyIdentity,
+          requestedGlBackend: facts.requestedGlBackend,
+          rasterAffectingFlags: facts.rasterAffectingFlags
+        };
+      }
+      surfaces.push(prepared);
+    }
+  }
+  const separation = evaluateSceneSeparationV2(scene.constraints, frameEvaluations.map(({ evaluated, chains }) => ({
+    frame: evaluated.contentFrame,
+    resolveBody: (authoredId) => {
+      const chain = chains.get(authoredId);
+      const object = evaluated.layers.length ? evaluatedById(evaluated.layers).get(authoredId) : void 0;
+      if (!object || !chain) return null;
+      const builder = args.descriptors.resolve(object, { referenceSize: scene.referenceSize, output });
+      if (!builder) return null;
+      return { bounds: builder.localBounds, transforms: chain, opacity: object.worldOpacity };
+    }
+  })));
+  const frame0 = frameEvaluations[0].evaluated.camera;
+  return {
+    version: 1,
+    scene,
+    output,
+    cameraIdentity: { position: [...frame0.position], fov: frame0.fov, ...cameraClipPlanes[0] },
+    motion: { channels: structuredClone(scene.animation), contentDurationInFrames: output.durationInFrames, finalContentFrame: output.durationInFrames - 1, cameraClipPlanes },
+    objects,
+    surfaces,
+    separation,
+    rigIdentity: structuredClone(rigFacts.identity),
+    rigAllocations: structuredClone(rigFacts.allocations),
+    fonts: structuredClone(args.fonts ?? [])
+  };
+}
+function assertScenePlanOutputV1(plan, requested) {
+  const normalized = normalizeOutput(requested);
+  if (plan.output.width !== normalized.width || plan.output.height !== normalized.height || plan.output.durationInFrames !== normalized.durationInFrames || plan.output.fps.num !== normalized.fps.num || plan.output.fps.den !== normalized.fps.den) {
+    throw new ScenePlanRefusal("scene_plan_output_mismatch", "output", "The sealed scene plan targets a different output; prepare it again.", { sealed: plan.output, requested: normalized });
+  }
+}
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const entry of Object.values(value)) deepFreeze(entry);
+  }
+  return value;
+}
+async function settleCleanup(cleanups) {
+  const results = await Promise.allSettled(cleanups.map((cleanup) => cleanup()));
+  const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (failures.length) throw new AggregateError(failures, "scene_plan_cleanup_failed");
+}
+async function realizeSceneShotPlanV1(preflight, deps) {
+  const intents = /* @__PURE__ */ new Map();
+  for (const surface of preflight.surfaces) {
+    if (!surface.captureIntent) continue;
+    const intent = parseSceneComponentCaptureIntentV1(surface.captureIntent);
+    intents.set(surface.path, intent);
+    const execution = await deps.capture.resolveExecutionFacts(intent, deps.signal);
+    for (const key of ["runtimeIdentity", "dependencyIdentity", "requestedGlBackend", "rasterAffectingFlags"]) {
+      if (canonicalSceneJsonV1(intent[key]) !== canonicalSceneJsonV1(execution[key])) throw new ScenePlanRefusal("scene_component_capture_invalid", `captureIntent.${key}`, `Capture execution fact ${key} changed after preflight.`);
+    }
+  }
+  const cleanups = [];
+  try {
+    const surfaces = [];
+    const componentCaptures = /* @__PURE__ */ new Map();
+    for (const surface of preflight.surfaces) {
+      const { captureIntent: _captureIntent, ...sealedBase } = surface;
+      if (surface.binding.source === "video") {
+        const lease = await deps.resolveVideo?.(surface.binding, surface.path, deps.signal);
+        if (!lease) throw new ScenePlanRefusal("scene_video_facts_missing", surface.path, `Verified presentation-index facts are unavailable for ${surface.path}.`);
+        cleanups.push(lease.release);
+        const schedule = prepareSceneVideoScheduleV1({ presentationIndex: lease.video.presentationIndex, shotRate: preflight.output.fps, contentDuration: preflight.output.durationInFrames, startFrame: surface.binding.startFrame, endFrame: surface.binding.endFrame });
+        surfaces.push({ ...sealedBase, realized: { source: "video", video: lease.video, schedule } });
+        continue;
+      }
+      if (surface.binding.source === "color") {
+        surfaces.push({ ...sealedBase, realized: { source: "color", color: surface.binding.color } });
+        continue;
+      }
+      if (surface.binding.source === "image") {
+        const lease = await deps.resolveImage(surface.binding, surface.path);
+        if (!lease) throw new ScenePlanRefusal("scene_image_facts_missing", surface.path, `Verified decoded image facts are unavailable for ${surface.path}.`);
+        cleanups.push(lease.release);
+        const { image } = lease;
+        if (!["image/png", "image/jpeg", "image/webp"].includes(image.mimeType) || !Number.isSafeInteger(image.width) || image.width <= 0 || !Number.isSafeInteger(image.height) || image.height <= 0 || !Number.isSafeInteger(image.byteLength) || image.byteLength <= 0 || !/^[a-f0-9]{64}$/.test(image.decodedSha256)) throw new ScenePlanRefusal("scene_image_facts_missing", surface.path, `Verified decoded image facts are invalid for ${surface.path}.`);
+        surfaces.push({ ...sealedBase, realized: { source: "image", image } });
+        continue;
+      }
+      const intent = intents.get(surface.path);
+      if (!intent) throw new ScenePlanRefusal("scene_component_facts_missing", surface.path, "Component capture intent is missing.");
+      const captureKey = canonicalSceneJsonV1(intent);
+      let capture = componentCaptures.get(captureKey);
+      if (!capture) {
+        capture = (async () => {
+          const session = await deps.capture.openSession(intent, deps.signal);
+          cleanups.push(session.close);
+          const result2 = await session.capture(intent, deps.signal);
+          const captureIdentityFacts2 = completeSceneComponentCaptureIdentityV1(intent, result2.attestation);
+          const captureIdentitySha2562 = await deps.sha256(canonicalSceneComponentCaptureIdentityV1(captureIdentityFacts2));
+          return { result: result2, captureIdentityFacts: captureIdentityFacts2, captureIdentitySha256: captureIdentitySha2562 };
+        })();
+        componentCaptures.set(captureKey, capture);
+      }
+      const { result, captureIdentityFacts, captureIdentitySha256 } = await capture;
+      if (!/^[a-f0-9]{64}$/.test(captureIdentitySha256) || result.cacheScope !== "session" || result.png.width !== intent.rasterWidth || result.png.height !== intent.rasterHeight || result.png.mimeType !== "image/png" || !/^[a-f0-9]{64}$/.test(result.png.decodedSha256) || !Number.isSafeInteger(result.png.byteLength) || result.png.byteLength <= 0) throw new ScenePlanRefusal("scene_component_capture_invalid", surface.path, `Captured PNG facts do not match the sealed intent for ${surface.path}.`);
+      surfaces.push({ ...sealedBase, realized: { source: "component", captureIdentitySha256, captureIdentityFacts, image: result.png } });
+    }
+    const baseAllocations = [
+      ...preflight.objects.flatMap((object) => (object.builder?.allocations ?? []).map((allocation) => ({ ...allocation, owner: `${object.authoredId}:${allocation.owner}` }))),
+      ...preflight.rigAllocations.map((allocation) => ({ ...allocation, owner: `rig:${allocation.owner}` }))
+    ];
+    const textureAllocations = surfaces.flatMap((surface) => surface.realized.source === "color" ? [] : [{
+      owner: surface.path,
+      name: "surface-texture",
+      domain: "gl",
+      resource: "texture",
+      format: "rgba8",
+      bytes: sceneTextureBytes({ width: (surface.realized.source === "video" ? surface.realized.video : surface.realized.image).width, height: (surface.realized.source === "video" ? surface.realized.video : surface.realized.image).height, format: "rgba8", mipLevels: sceneFullMipLevels((surface.realized.source === "video" ? surface.realized.video : surface.realized.image).width, (surface.realized.source === "video" ? surface.realized.video : surface.realized.image).height) }),
+      lifetime: "context"
+    }]);
+    const seenCpuHandles = /* @__PURE__ */ new Set();
+    const cpuAllocations = surfaces.flatMap((surface) => {
+      if (surface.realized.source === "color") return [];
+      const media = surface.realized.source === "video" ? surface.realized.video : surface.realized.image;
+      const firstHandle = !seenCpuHandles.has(media.handle);
+      seenCpuHandles.add(media.handle);
+      if (surface.realized.source === "video") return [
+        ...firstHandle ? [{ owner: `capture:${media.handle}`, name: "encoded-video", domain: "cpu", resource: "encoded-video", format: media.mimeType, bytes: media.byteLength, lifetime: "context" }] : [],
+        { owner: surface.path, name: "owned-video-canvas", domain: "cpu", resource: "decoded-video", format: "rgba8", bytes: media.width * media.height * 4, lifetime: "context" }
+      ];
+      if (!firstHandle) return [];
+      return [
+        { owner: `capture:${media.handle}`, name: "encoded-image", domain: "cpu", resource: "encoded-image", format: media.mimeType, bytes: media.byteLength, lifetime: "context" },
+        { owner: `capture:${media.handle}`, name: "decoded-rgba", domain: "cpu", resource: "decoded-image", format: "rgba8", bytes: media.width * media.height * 4, lifetime: "preparation" }
+      ];
+    });
+    const allocations = [...baseAllocations, ...textureAllocations, ...cpuAllocations];
+    const byOwner = {};
+    for (const allocation of allocations) {
+      const row = byOwner[allocation.owner] ??= { contextGlBytes: 0, preparationGlBytes: 0, cpuBytes: 0 };
+      if (allocation.domain === "cpu") row.cpuBytes += allocation.bytes;
+      else if (allocation.lifetime === "context") row.contextGlBytes += allocation.bytes;
+      else row.preparationGlBytes += allocation.bytes;
+    }
+    const surfaceTextureBytes = textureAllocations.reduce((sum, allocation) => sum + allocation.bytes, 0);
+    const contextGlBytes = Object.values(byOwner).reduce((sum, row) => sum + row.contextGlBytes, 0);
+    const preparationGlBytes = Object.values(byOwner).reduce((sum, row) => sum + row.preparationGlBytes, 0);
+    const cpuBytes = Object.values(byOwner).reduce((sum, row) => sum + row.cpuBytes, 0);
+    const budgetTriangles = preflight.objects.reduce((sum, object) => sum + (object.builder?.budgetTriangles ?? 0), 0);
+    const instantiatedTriangles = preflight.objects.flatMap((object) => object.parts).reduce((sum, part) => sum + (part.mounted ? part.triangles : 0), 0);
+    const ledger = {
+      owner: `scene-plan:${preflight.objects.map((object) => object.authoredId).join(",")}`,
+      invariant: "one-plan-one-webgl-context",
+      allocations,
+      byOwner,
+      surfaceTextureBytes,
+      contextGlBytes,
+      preparationPeakGlBytes: contextGlBytes + preparationGlBytes,
+      cpuBytes,
+      peakDeclaredLiveBytes: contextGlBytes + preparationGlBytes + cpuBytes,
+      budgetTriangles,
+      instantiatedTriangles,
+      exclusions: {
+        crossContextAndHostAggregation: "W7",
+        videoDecode: surfaces.some((surface) => surface.realized.source === "video") ? "binding-owned" : "W6",
+        browserProcess: "host-owned",
+        sourceBundles: "host-owned",
+        captureSession: "provider-owned",
+        driverAllocations: "excluded-unmeasured",
+        compositorSurfaces: "excluded-unmeasured",
+        decoderCaches: "excluded-unmeasured"
+      }
+    };
+    if (surfaceTextureBytes > SCENE_SURFACE_TEXTURE_BUDGET_BYTES || ledger.preparationPeakGlBytes > SCENE_CONTEXT_GL_BUDGET_BYTES || budgetTriangles > SCENE_MAX_TRIANGLES) throw new ScenePlanRefusal("scene_budget_exceeded", "ledger", "The prepared scene exceeds its per-shot or per-context budget.", { ledger, limits: { surfaceTextureBytes: SCENE_SURFACE_TEXTURE_BUDGET_BYTES, contextGlBytes: SCENE_CONTEXT_GL_BUDGET_BYTES, triangles: SCENE_MAX_TRIANGLES }, corrective: "Reduce surfaces or objects, or change camera/layout and prepare a new seal; lower bakeScale only when a new resolution check passes." });
+    const planFacts = { ...preflight, status: "sealed", surfaces, ledger };
+    const sealSha256 = await deps.sha256(canonicalSceneJsonV1(planFacts));
+    if (!/^[a-f0-9]{64}$/.test(sealSha256)) throw new ScenePlanRefusal("scene_component_capture_invalid", "sealSha256", "Plan hash supplier returned an invalid SHA-256 digest.");
+    const plan = deepFreeze(structuredClone({ ...planFacts, sealSha256 }));
+    let cleanupPromise = null;
+    return { plan, cleanup: () => cleanupPromise ??= settleCleanup(cleanups) };
+  } catch (error) {
+    try {
+      await settleCleanup(cleanups);
+    } catch (cleanupError) {
+      if (error instanceof Error && error.cause === void 0) error.cause = cleanupError;
+      else throw new AggregateError([error, cleanupError], "Scene realization and cleanup both failed.");
+    }
+    throw error;
+  }
+}
+
+// ../execution/core/src/render/sceneShotPreparation.ts
+var SCENE_SHOT_PREPARATION_STAGE = "preparation";
+var SCENE_SHOT_PARAM = "scene";
+var SCENE_SHOT_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp"];
+var SCENE_SHOT_VIDEO_MIME_TYPES = ["video/mp4", "video/webm"];
+function readSceneShotManifest(manifest, context) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) return null;
+  const record = manifest;
+  if (record.sceneShot === void 0) return null;
+  const sceneShot = record.sceneShot;
+  if (sceneShot?.version !== 2) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "manifest.sceneShot.version", `Scene source ${context.componentId ?? ""} does not declare authored scene version 2.`);
+  const graphics = record.graphics;
+  if (graphics?.api !== "webgl") throw new ScenePlanRefusal("scene_evaluated_value_invalid", "manifest.graphics.api", "Scene sources require WebGL.");
+  const assets = record.assets;
+  if (!assets || typeof assets !== "object" || Array.isArray(assets)) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "manifest.assets", "Scene source assets must be declared.");
+  return { version: 2, api: "webgl", assets };
+}
+function sceneSourceResolverForPinnedRows(rows) {
+  return (componentId, sourceVersionId) => {
+    const row = Object.values(rows).find(
+      (candidate) => candidate.source.componentId === componentId && candidate.sourceVersionId === sourceVersionId
+    );
+    if (!row) return null;
+    return { componentId, manifest: row.source.manifest };
+  };
+}
+function assertSceneClipShapes(composition, context) {
+  const issues = collectSceneClipIssues(composition, context);
+  if (issues[0]) throw new ScenePlanRefusal("scene_evaluated_value_invalid", issues[0].path, issues[0].message, { clipId: issues[0].clipId });
+}
+var HEX = /^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i;
+function resolveBrandValue(value, kind, brand, path) {
+  const prefix = `$brand:${kind}.`;
+  if (!value.startsWith(prefix)) return value;
+  const key = value.slice(prefix.length);
+  const record = brand?.[kind];
+  const raw = record?.[key];
+  const resolved = kind === "fonts" && raw && typeof raw === "object" ? raw.family : raw;
+  if (typeof resolved !== "string" || resolved.length === 0 || kind === "colors" && !HEX.test(resolved)) {
+    throw new ScenePlanRefusal("scene_brand_unresolved", path, `Brand reference ${value} has no admitted ${kind === "colors" ? "color" : "font family"} fact.`);
+  }
+  return kind === "colors" ? resolved.toLowerCase() : resolved;
+}
+function resolvePinnedSceneFactsV1(authored, context, componentFactsByPath = {}) {
+  const brand = context.input.brandKit;
+  const faces = /* @__PURE__ */ new Map();
+  const custom = new Map((brand?.fontAssets ?? []).map((asset) => [`${asset.family}\0${asset.weight}\0${asset.style ?? "normal"}`, asset.url]));
+  const customFamilies = new Set((brand?.fontAssets ?? []).map((asset) => asset.family));
+  const customFacts = {
+    hasFamily: (family) => customFamilies.has(family),
+    hasWeight: (family, weight) => [...custom.keys()].some((key) => key.startsWith(`${family}\0${weight}\0`))
+  };
+  const visit = (objects, prefix = "layers") => objects.map((object, index) => {
+    const path = `${prefix}.${index}`;
+    if (object.kind === "group") return { ...object, children: visit(object.children, `${path}.children`) };
+    const materials = "materials" in object && object.materials?.map((material, materialIndex) => ({
+      ...material,
+      ...material.color ? { color: resolveBrandValue(material.color, "colors", brand, `${path}.materials.${materialIndex}.color`) } : {}
+    }));
+    const surfaces = "surfaces" in object && object.surfaces ? Object.fromEntries(Object.entries(object.surfaces).map(([slot, binding]) => [
+      slot,
+      binding.source === "color" ? { ...binding, color: resolveBrandValue(binding.color, "colors", brand, `${path}.surfaces.${slot}.color`) } : binding
+    ])) : void 0;
+    if (object.kind !== "text") return { ...object, ...materials ? { materials } : {}, ...surfaces ? { surfaces } : {} };
+    const family = resolveBrandValue(object.fontFamily, "fonts", brand, `${path}.fontFamily`);
+    const key = `${family}\0${object.fontWeight}\0${object.fontStyle}`;
+    const url = custom.get(key);
+    if (!url && !bundledFontFaceExists(family, object.fontWeight, object.fontStyle)) {
+      const field = unrenderableFaceField(family, object.fontWeight, object.fontStyle, customFacts);
+      throw new ScenePlanRefusal("scene_font_unavailable", `${path}.${field}`, `Font face ${family} ${object.fontWeight} ${object.fontStyle} has no admitted bytes.`);
+    }
+    const existing = faces.get(key);
+    if (existing) existing.paths.push(path);
+    else faces.set(key, { family, weight: object.fontWeight, style: object.fontStyle, ...url ? { url } : {}, paths: [path] });
+    return {
+      ...object,
+      fontFamily: family,
+      color: resolveBrandValue(object.color, "colors", brand, `${path}.color`),
+      lines: object.lines.map((line, lineIndex) => ({ runs: line.runs.map((run, runIndex) => ({
+        ...run,
+        ...run.color ? { color: resolveBrandValue(run.color, "colors", brand, `${path}.lines.${lineIndex}.runs.${runIndex}.color`) } : {}
+      })) }))
+    };
+  });
+  const backdrop = authored.backdrop.kind === "solid" ? { ...authored.backdrop, color: resolveBrandValue(authored.backdrop.color, "colors", brand, "backdrop.color") } : authored.backdrop.kind === "linear" || authored.backdrop.kind === "radial" ? { ...authored.backdrop, stops: authored.backdrop.stops.map((stop, index) => ({ ...stop, color: resolveBrandValue(stop.color, "colors", brand, `backdrop.stops.${index}.color`) })) } : authored.backdrop;
+  const scene = parseSceneShotSpecV2({ ...authored, backdrop, layers: visit(authored.layers) });
+  return { scene, componentFactsByPath, fonts: [...faces.values()] };
+}
+function exactOutput(input, durationInFrames) {
+  const width = input.outputWidth ?? input.width;
+  const height = input.outputHeight ?? input.height;
+  const fps = input.fpsRational ?? (Number.isSafeInteger(input.fps) ? { num: input.fps, den: 1 } : null);
+  if (!fps) throw new ScenePlanRefusal("scene_evaluated_value_invalid", "fpsRational", "A non-integer render rate requires authoritative exact rational transport.");
+  if (input.fps * fps.den !== fps.num) throw new ScenePlanRefusal("scene_plan_output_mismatch", "fpsRational", "Numeric fps and exact rational fps disagree.");
+  return { width, height, fps, durationInFrames };
+}
+async function prepareOverlay(input, overlay, dependencies) {
+  if (!overlay.componentId || !overlay.sourceVersionId) return null;
+  if (overlay.template !== "component") throw new ScenePlanRefusal("scene_evaluated_value_invalid", "overlay.template", `Scene candidate ${overlay.id} must use the component overlay template.`);
+  const row = input.componentSources?.[overlay.id];
+  if (!row) throw new ScenePlanRefusal("scene_component_facts_missing", `componentSources.${overlay.id}`, `Pinned source facts are missing for scene candidate ${overlay.id}.`);
+  if (row.source.componentId !== overlay.componentId || row.sourceVersionId !== overlay.sourceVersionId) throw new ScenePlanRefusal("scene_component_facts_missing", `componentSources.${overlay.id}`, `Pinned source facts do not match scene candidate ${overlay.id}.`);
+  const manifest = readSceneShotManifest(row.source.manifest, { clipId: overlay.id, componentId: overlay.componentId });
+  if (!manifest) return null;
+  const rawScene = overlay.params[SCENE_SHOT_PARAM];
+  const authored = parseSceneShotSpecV2(rawScene);
+  const referencedImageSlots = /* @__PURE__ */ new Set();
+  const checkAssets = (objects, prefix = "layers") => {
+    objects.forEach((object, index) => {
+      const path = `${prefix}.${index}`;
+      if (object.kind === "group") checkAssets(object.children, `${path}.children`);
+      for (const [slot, binding] of Object.entries("surfaces" in object ? object.surfaces ?? {} : {})) {
+        if (binding.source !== "image" && binding.source !== "video") continue;
+        const assetSlot = binding.source === "image" ? binding.assetSlot : binding.mediaId;
+        const mimes = binding.source === "image" ? SCENE_SHOT_IMAGE_MIME_TYPES : SCENE_SHOT_VIDEO_MIME_TYPES;
+        referencedImageSlots.add(assetSlot);
+        const declaration = manifest.assets[assetSlot];
+        const expectedKind = binding.source;
+        if (!declaration || declaration.kind !== expectedKind || declaration.required !== true || !Array.isArray(declaration.mimeTypes) || !declaration.mimeTypes.some((mime) => mimes.includes(mime))) {
+          throw new ScenePlanRefusal(binding.source === "image" ? "scene_image_facts_missing" : "scene_video_facts_missing", `${path}.surfaces.${slot}`, `Manifest does not declare required admitted ${expectedKind} slot ${assetSlot}.`);
+        }
+        const admitted = declaration.mimeTypes;
+        if (!admitted.every((mime) => typeof mime === "string" && mimes.includes(mime))) throw new ScenePlanRefusal(binding.source === "image" ? "scene_image_facts_missing" : "scene_video_facts_missing", `${path}.surfaces.${slot}`, `Manifest ${expectedKind} slot ${assetSlot} contains an unsupported MIME type.`);
+        const asset = row.assets[assetSlot];
+        if (!asset || asset.kind !== expectedKind || !admitted.includes(asset.mimeType) || !mimes.includes(asset.mimeType) || !Number.isSafeInteger(asset.width) || (asset.width ?? 0) <= 0 || !Number.isSafeInteger(asset.height) || (asset.height ?? 0) <= 0) {
+          throw new ScenePlanRefusal(binding.source === "image" ? "scene_image_facts_missing" : "scene_video_facts_missing", `${path}.surfaces.${slot}`, `Pinned ${expectedKind} slot ${assetSlot} has no admitted MIME and decoded dimensions.`);
+        }
+      }
+    });
+  };
+  checkAssets(authored.layers);
+  for (const slot of Object.keys(manifest.assets)) if (!referencedImageSlots.has(slot)) throw new ScenePlanRefusal("scene_image_facts_missing", `manifest.assets.${slot}`, `Pinned scene source declares stale unreferenced asset slot ${slot}.`);
+  for (const slot of Object.keys(row.assets)) if (!referencedImageSlots.has(slot)) throw new ScenePlanRefusal("scene_image_facts_missing", `componentSources.${overlay.id}.assets.${slot}`, `Pinned scene source binds stale unreferenced asset slot ${slot}.`);
+  const extension = dependencies.resolveComponentFacts ? await dependencies.resolveComponentFacts(authored, { input, overlay }) : null;
+  const resolved = resolvePinnedSceneFactsV1(
+    authored,
+    { input, overlay },
+    extension ?? dependencies.componentFactsByPath
+  );
+  const preflight = prepareSceneShotPreflightV1({
+    authoredScene: resolved.scene,
+    output: exactOutput(input, overlay.durationInFrames),
+    descriptors: dependencies.descriptors,
+    resolveComponentFacts: (_binding, path) => resolved.componentFactsByPath[path] ?? null,
+    resolveRigFacts: dependencies.resolveRigFacts,
+    resolveCameraClipPlanes: dependencies.resolveCameraClipPlanes,
+    fonts: resolved.fonts
+  });
+  return realizeSceneShotPlanV1(preflight, dependencies.realizationForOverlay?.({ input, overlay }) ?? dependencies.realization);
+}
+async function prepareSceneShotRenderInput(input, dependencies) {
+  const clone = structuredClone(input);
+  const leases = [];
+  try {
+    for (let index = 0; index < clone.overlays.length; index += 1) {
+      const overlay = clone.overlays[index];
+      const lease = await prepareOverlay(clone, overlay, dependencies);
+      if (!lease) continue;
+      leases.push(lease);
+      clone.overlays[index] = {
+        ...overlay,
+        params: {
+          ...overlay.params,
+          scene: lease.plan.scene
+        },
+        sceneShot: {
+          version: 1,
+          authoredSceneVersion: 2,
+          componentId: overlay.componentId,
+          sourceVersionId: overlay.sourceVersionId,
+          sealSha256: lease.plan.sealSha256,
+          contentDurationInFrames: lease.plan.output.durationInFrames,
+          plan: lease.plan
+        }
+      };
+    }
+    let cleanupPromise = null;
+    return {
+      input: clone,
+      cleanup: () => cleanupPromise ??= Promise.allSettled(leases.map((lease) => lease.cleanup())).then((results) => {
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length) throw new AggregateError(failures, "scene_render_input_cleanup_failed");
+      })
+    };
+  } catch (error) {
+    const results = await Promise.allSettled(leases.map((lease) => lease.cleanup()));
+    const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length) {
+      const cleanupError = new AggregateError(failures, "scene_render_input_cleanup_failed");
+      if (error instanceof Error && error.cause === void 0) error.cause = cleanupError;
+      else throw new AggregateError([error, cleanupError], "Scene input preparation and cleanup both failed.");
+    }
+    throw error;
+  }
+}
 
 // ../execution/core/src/render/emphasis.ts
 function buildEmphasisSet(emphasisWords) {
@@ -400,7 +1249,7 @@ function assertBehindSubjectCaptionCoverage(captionSegments, clips, fps) {
   }
 }
 
-// ../execution/core/src/render/compositionRender.ts
+// ../execution/core/src/render/trackProjection.ts
 function projectClipEffects(clip, renderClipId, identity) {
   const effects = clip.effects;
   if (!effects || effects.length === 0) return [];
@@ -420,33 +1269,6 @@ function visualIdentity(track, trackIndex, trackCount, contentIndex) {
     contentIndex
   };
 }
-function compositionFormatDimensions(format) {
-  const fps = format.fps ?? 30;
-  const resolution = format.resolution ?? "fhd";
-  const dims = {
-    "9:16": {
-      hd: { width: 720, height: 1280 },
-      fhd: { width: 1080, height: 1920 },
-      "4k": { width: 2160, height: 3840 }
-    },
-    "1:1": {
-      hd: { width: 720, height: 720 },
-      fhd: { width: 1080, height: 1080 },
-      "4k": { width: 2160, height: 2160 }
-    },
-    "4:5": {
-      hd: { width: 720, height: 900 },
-      fhd: { width: 1080, height: 1350 },
-      "4k": { width: 2160, height: 2700 }
-    },
-    "16:9": {
-      hd: { width: 1280, height: 720 },
-      fhd: { width: 1920, height: 1080 },
-      "4k": { width: 3840, height: 2160 }
-    }
-  };
-  return { ...dims[format.aspectRatio][resolution], fps };
-}
 function frames(seconds, fps) {
   return Math.max(0, Math.round(seconds * fps));
 }
@@ -467,12 +1289,32 @@ function mapTransitionType(type) {
       return "fade";
   }
 }
-function overlayTransitionFields(c, fps) {
-  return c.transitionIn ? {
+function overlayTransitionFields(c, fps, isSceneClip, locator) {
+  if (!c.transitionIn) return {};
+  const exact = c.transitionIn.duration * fps;
+  const frames2 = Math.round(exact);
+  if (isSceneClip(c)) {
+    if (Math.abs(exact - frames2) > FRAME_LATTICE_EPSILON) {
+      throw renderInputError(
+        "component_scene_invalid",
+        `${locator.compositionPath}.transitionIn.duration: scene shot '${c.id}' authors a ${c.transitionIn.duration}s boundary, which is ${exact} frames at ${fps} fps. Quantize it through the frame lattice (n/${fps} s) rather than letting the render round it.`,
+        { ...locator, path: "transitionIn.duration" }
+      );
+    }
+    if (c.transitionIn.type === "fade" && frames2 < 1) {
+      throw renderInputError(
+        "component_scene_invalid",
+        `${locator.compositionPath}.transitionIn.duration: scene shot '${c.id}' authors a ${c.transitionIn.duration}s fade, which is zero frames at ${fps} fps. Lengthen the fade to at least one frame or author the boundary as a cut.`,
+        { ...locator, path: "transitionIn.duration" }
+      );
+    }
+  }
+  return {
     transitionIn: mapTransitionType(c.transitionIn.type),
-    transitionDurationFrames: Math.max(1, Math.round(c.transitionIn.duration * fps))
-  } : {};
+    transitionDurationFrames: Math.max(1, frames2)
+  };
 }
+var FRAME_LATTICE_EPSILON = 1e-6;
 function rendersNoFrames(c) {
   return !(c.duration > 0);
 }
@@ -690,10 +1532,15 @@ function clipTransformChannel(c) {
     ...c.animate !== void 0 ? { animate: c.animate } : {}
   };
 }
-function projectOverlayTrack(track, trackIndex, trackCount, fps, alphaUrls = {}) {
+function projectOverlayTrack(track, trackIndex, trackCount, fps, alphaUrls = {}, isSceneClip = () => false) {
   const overlays = [];
   for (let i = 0; i < track.contents.length; i++) {
     const c = track.contents[i];
+    const transitionLocator = {
+      trackId: track.id,
+      clipId: c.id,
+      compositionPath: `composition.tracks[${track.id}].contents[${i}]`
+    };
     if (!("source" in c) || !c.source) continue;
     if (c.effects && c.effects.length > 0) {
       throw renderInputError(
@@ -702,6 +1549,45 @@ function projectOverlayTrack(track, trackIndex, trackCount, fps, alphaUrls = {})
         { trackId: track.id, clipId: c.id, compositionPath: `composition.tracks[${track.id}].contents[${i}].effects` }
       );
     }
+    if (c.source.kind === "component") {
+      const { startFrame: startFrame2, durationInFrames: durationInFrames2 } = timelineSpanFrames(
+        c.startTime,
+        c.startTime + c.duration,
+        fps
+      );
+      if (durationInFrames2 === 0) continue;
+      const rawRef = c.source.props.componentRef;
+      const ref = rawRef && typeof rawRef === "object" && !Array.isArray(rawRef) ? rawRef : null;
+      if (ref?.version !== 1 || typeof ref.sourceVersionId !== "string" || !/^[a-f0-9]{64}$/.test(ref.sourceVersionId)) {
+        throw renderInputError(
+          "invalid_composition",
+          `composition.tracks[${track.id}].contents[${i}].source: component clip ${c.id} has no immutable source version`,
+          { trackId: track.id, clipId: c.id, componentId: c.source.componentId }
+        );
+      }
+      const { componentRef: _reserved, renderSeed, ...params } = c.source.props;
+      if (renderSeed !== void 0 && (typeof renderSeed !== "string" || renderSeed.length === 0)) {
+        throw renderInputError("invalid_composition", `composition.tracks[${track.id}].contents[${i}].source.props.renderSeed must be a non-empty string`, transitionLocator);
+      }
+      overlays.push({
+        ...visualIdentity(track, trackIndex, trackCount, i),
+        id: c.id,
+        template: "component",
+        componentId: c.source.componentId,
+        sourceVersionId: ref.sourceVersionId,
+        ...renderSeed !== void 0 ? { renderSeed } : {},
+        componentAssets: c.source.assets ?? {},
+        startFrame: startFrame2,
+        durationInFrames: durationInFrames2,
+        params,
+        ...c.source.zPlane !== void 0 ? { zPlane: c.source.zPlane } : {},
+        ...c.region !== void 0 ? { region: c.region } : {},
+        ...c.fit !== void 0 ? { fit: c.fit } : {},
+        ...overlayTransitionFields(c, fps, isSceneClip, transitionLocator),
+        ...clipTransformChannel(c)
+      });
+      continue;
+    }
     if (c.source.kind === "alpha-layer") {
       const { startFrame: startFrame2, durationInFrames: durationInFrames2 } = timelineSpanFrames(
         c.startTime,
@@ -732,7 +1618,7 @@ function projectOverlayTrack(track, trackIndex, trackCount, fps, alphaUrls = {})
         ...c.source.zPlane !== void 0 ? { zPlane: c.source.zPlane } : {},
         ...c.region !== void 0 ? { region: c.region } : {},
         ...c.fit !== void 0 ? { fit: c.fit } : {},
-        ...overlayTransitionFields(c, fps),
+        ...overlayTransitionFields(c, fps, isSceneClip, transitionLocator),
         ...clipTransformChannel(c)
       });
       continue;
@@ -757,7 +1643,7 @@ function projectOverlayTrack(track, trackIndex, trackCount, fps, alphaUrls = {})
         ...c.source.zPlane !== void 0 ? { zPlane: c.source.zPlane } : {},
         ...c.region !== void 0 ? { region: c.region } : {},
         ...c.fit !== void 0 ? { fit: c.fit } : {},
-        ...overlayTransitionFields(c, fps),
+        ...overlayTransitionFields(c, fps, isSceneClip, transitionLocator),
         ...clipTransformChannel(c)
       });
       continue;
@@ -795,7 +1681,7 @@ function projectOverlayTrack(track, trackIndex, trackCount, fps, alphaUrls = {})
       ...c.source.parallax !== void 0 ? { parallax: c.source.parallax } : {},
       ...c.region !== void 0 ? { region: c.region } : {},
       ...c.fit !== void 0 ? { fit: c.fit } : {},
-      ...overlayTransitionFields(c, fps),
+      ...overlayTransitionFields(c, fps, isSceneClip, transitionLocator),
       ...clipTransformChannel(c)
     });
   }
@@ -831,6 +1717,35 @@ function projectEffectTrack(track, trackIndex, trackCount, fps) {
   }
   return effects;
 }
+
+// ../execution/core/src/render/compositionRender.ts
+function compositionFormatDimensions(format) {
+  const fps = format.fps ?? 30;
+  const resolution = format.resolution ?? "fhd";
+  const dims = {
+    "9:16": {
+      hd: { width: 720, height: 1280 },
+      fhd: { width: 1080, height: 1920 },
+      "4k": { width: 2160, height: 3840 }
+    },
+    "1:1": {
+      hd: { width: 720, height: 720 },
+      fhd: { width: 1080, height: 1080 },
+      "4k": { width: 2160, height: 2160 }
+    },
+    "4:5": {
+      hd: { width: 720, height: 900 },
+      fhd: { width: 1080, height: 1350 },
+      "4k": { width: 2160, height: 2700 }
+    },
+    "16:9": {
+      hd: { width: 1280, height: 720 },
+      fhd: { width: 1920, height: 1080 },
+      "4k": { width: 3840, height: 2160 }
+    }
+  };
+  return { ...dims[format.aspectRatio][resolution], fps };
+}
 function referencedMediaIds(composition) {
   const ids = /* @__PURE__ */ new Set();
   for (const track of composition.tracks) {
@@ -843,9 +1758,25 @@ function referencedMediaIds(composition) {
   }
   return [...ids];
 }
-function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUrls, alphaUrls, subCompositions, trajectories) {
+function assertMergedCaptionFacesDrawable(composition) {
+  const captions = composition.captions;
+  if (!captions?.segments.some((segment) => segment.words.length > 0)) return;
+  const brandCaption = composition.brandKit?.caption;
+  const issues = mergedCaptionFaceIssues(captions.style, brandCaption);
+  if (issues.length === 0) return;
+  throw renderInputError(
+    "font_not_reproducible",
+    "The caption style this render draws is the brand kit's caption block over the composition's own style, and that merge names a face with no file behind it: " + issues.map((issue) => `${issue.path}: ${issue.message}`).join(" "),
+    {
+      compositionPath: issues[0].path,
+      fields: issues.map((issue) => issue.path)
+    }
+  );
+}
+function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUrls, alphaUrls, subCompositions, trajectories, options) {
   const flattened = hasCompoundClips(composition) ? flattenCompoundClips(composition, (id) => subCompositions?.[id]) : composition;
   composition = flattened;
+  assertMergedCaptionFacesDrawable(composition);
   const { width, height, fps } = compositionFormatDimensions(composition.format);
   const clips = [];
   const overlays = [];
@@ -884,7 +1815,8 @@ function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUr
         trackIndex,
         trackCount,
         fps,
-        alphaUrls ?? {}
+        alphaUrls ?? {},
+        options?.isSceneClip
       ));
     } else if (track.kind === "effect") {
       effects.push(...projectEffectTrack(track, trackIndex, trackCount, fps));
@@ -948,6 +1880,7 @@ function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUr
   const captionStyle = hasCaptions && (cap || baseStyle || captionMotion) ? {
     ...baseStyle ?? {},
     ...cap?.fontFamily ? { fontFamily: cap.fontFamily } : {},
+    ...cap?.fontWeight != null ? { fontWeight: cap.fontWeight } : {},
     ...cap?.color ? { color: cap.color } : {},
     ...cap?.plate ? { plate: cap.plate } : {},
     ...cap?.emphasisFontFamily ? { emphasisFontFamily: cap.emphasisFontFamily } : {},
@@ -984,18 +1917,37 @@ function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUr
   };
 }
 function assembleRenderInput(composition, resolved) {
+  const resolveSource = resolved.componentSources ? sceneSourceResolverForPinnedRows(resolved.componentSources) : null;
+  if (resolveSource) {
+    assertSceneClipShapes(composition, {
+      fps: compositionFormatDimensions(composition.format).fps,
+      resolveSource
+    });
+  }
   const renderInput = compositionToRenderInput(
     composition,
     resolved.srcUrls,
     resolved.trajectoryUrls ?? {},
     resolved.coViewUrls ?? {},
-    resolved.alphaUrls ?? {}
+    resolved.alphaUrls ?? {},
+    void 0,
+    resolved.trajectories,
+    // The same manifest-backed answer the shape rules used, so projection cannot floor a scene
+    // clip's boundary into a length the rules above would have refused.
+    resolveSource ? { isSceneClip: (clip) => isSceneShotClip(clip, resolveSource) } : void 0
   );
   if (renderInput.brandKit && resolved.fontAssets && resolved.fontAssets.length > 0) {
     renderInput.brandKit.fontAssets = resolved.fontAssets;
   }
+  if (resolved.componentSources && Object.keys(resolved.componentSources).length > 0) {
+    return structuredClone({ ...renderInput, componentSources: resolved.componentSources });
+  }
   return renderInput;
 }
+async function assemblePreparedRenderInput(composition, resolved, dependencies) {
+  const input = assembleRenderInput(composition, resolved);
+  return prepareSceneShotRenderInput(input, dependencies);
+}
 
 // ../execution/core/src/render/exportSettings.ts
 var DEFAULT_FPS = 30;
@@ -1965,6 +2917,29 @@ function mapFaceIdToPersonId(faceTrack, personTrack, faceId) {
 }
 
 export {
+  SCENE_CAPTURE_IDENTITY_FIELDS,
+  SceneCaptureIdentityRefusal,
+  canonicalSceneJsonV1,
+  parseSceneComponentCaptureIntentV1,
+  parseSceneComponentCaptureIdentityV1,
+  completeSceneComponentCaptureIdentityV1,
+  canonicalSceneComponentCaptureIdentityV1,
+  SCENE_SLAB_CONTENT_OFFSET_V1,
+  sceneSlabBuilderDescriptorV1,
+  createSceneSlabDescriptorRegistryV1,
+  createSceneBuilderDescriptorRegistryV1,
+  ScenePlanRefusal,
+  prepareSceneShotPreflightV1,
+  assertScenePlanOutputV1,
+  realizeSceneShotPlanV1,
+  SCENE_SHOT_PREPARATION_STAGE,
+  SCENE_SHOT_PARAM,
+  SCENE_SHOT_IMAGE_MIME_TYPES,
+  readSceneShotManifest,
+  sceneSourceResolverForPinnedRows,
+  assertSceneClipShapes,
+  resolvePinnedSceneFactsV1,
+  prepareSceneShotRenderInput,
   buildEmphasisSet,
   isEmphasized,
   sliceTranscriptWords,
@@ -1976,11 +2951,12 @@ export {
   resolveBookendTimeline,
   validateComposition,
   assertBehindSubjectCaptionCoverage,
-  compositionFormatDimensions,
   playableSpans,
+  compositionFormatDimensions,
   referencedMediaIds,
   compositionToRenderInput,
   assembleRenderInput,
+  assemblePreparedRenderInput,
   DEFAULT_FPS,
   DEFAULT_WIDTH,
   DEFAULT_HEIGHT,