@cueframe/kernel 0.2.1 → 0.2.3

package/dist/render-harness.js

@@ -1,36 +1,74 @@
-import {
-  assertCardHtmlAssetFree
-} from "./chunk-IJ7PVJTK.js";
 import {
   assertNoRemoteRefs,
   assetSlots,
   assetUrlKey,
   isRemoteUrl,
   renderInputAssets
-} from "./chunk-RFXR7ATW.js";
-import "./chunk-KU376ELE.js";
+} from "./chunk-NUKDEOK6.js";
 import {
+  assertCardHtmlAssetFree
+} from "./chunk-ODUWCQI3.js";
+import "./chunk-UY77TMKD.js";
+import "./chunk-BVA3537Z.js";
+import {
+  COMPONENT_STILL_RUNTIME_IDENTITY,
+  componentStillDependencyIdentity,
+  componentStillRasterAffectingFlags,
+  createComponentStillSession,
   importFromRenderEntry,
-  resolveRenderEntryRoot
-} from "./chunk-5OTQ7M43.js";
+  readMaterializedComponentSource,
+  resolveRenderEntryRoot,
+  verifyLocalStagedBrowser
+} from "./chunk-DQLYWNLC.js";
 import "./chunk-WB2VFDQZ.js";
 import {
-  COMPONENT_CHROMIUM_OPTIONS
-} from "./chunk-CGHTMZNC.js";
-import "./chunk-M2TLRXEO.js";
-import "./chunk-DHKQ47Q6.js";
-import "./chunk-2PGLNTB7.js";
-import "./chunk-LQUWKBST.js";
-import "./chunk-C5SEPOWD.js";
+  sourceVersionId
+} from "./chunk-EXY4JJPH.js";
+import "./chunk-DAARYRNT.js";
+import "./chunk-A74FZCPY.js";
+import {
+  componentBrowserBackend
+} from "./chunk-WIHXXF3X.js";
+import "./chunk-ZVG446DJ.js";
+import {
+  generatedStudioPreparationFactsV1,
+  scenePresetBuilderDescriptorV1
+} from "./chunk-VKATKWWR.js";
+import "./chunk-AS5EXBNS.js";
+import {
+  SCENE_SHOT_PREPARATION_STAGE,
+  createSceneBuilderDescriptorRegistryV1,
+  parseSceneComponentCaptureIntentV1,
+  prepareSceneShotRenderInput,
+  readSceneShotManifest
+} from "./chunk-YFSBFCXO.js";
+import "./chunk-QH3YI3ND.js";
+import "./chunk-QISFYLBB.js";
+import "./chunk-L2AHS3AW.js";
+import "./chunk-VZ7TYX6Z.js";
+import "./chunk-DENF4TPI.js";
+import "./chunk-KYRDKK2D.js";
+import "./chunk-WREYUH2E.js";
 import "./chunk-7PA7FGLD.js";
-import "./chunk-4FOOBSEE.js";
+import {
+  CueframeError
+} from "./chunk-J3DIUG24.js";
+import "./chunk-TARKDVP6.js";
+import {
+  evaluateScene,
+  parseSceneShotSpecV2,
+  photographicSceneRigFactsV1,
+  sceneCameraPlanesV2
+} from "./chunk-MH3UPKWR.js";
+import "./chunk-2L7PYYJK.js";
 import "./chunk-2ESYSVXG.js";
 
 // ../execution/render-harness/src/materializeSources.ts
-import { join as join4, basename } from "path";
-import { mkdir, copyFile } from "fs/promises";
+import { join as join5, basename } from "path";
+import { createHash as createHash4 } from "crypto";
+import { mkdir, copyFile, readFile as readFile3 } from "fs/promises";
 import { createWriteStream, existsSync as existsSync4 } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 
@@ -117,6 +155,7 @@ import { tmpdir } from "os";
 import { rm } from "fs/promises";
 var exec = promisify(execFile);
 async function extractSegments(clips, sourceFiles, opts) {
+  opts?.signal?.throwIfAborted();
   const padding = opts?.padding ?? 1;
   const dir = mkdtempSync(join2(tmpdir(), "cueframe-segments-"));
   const segments = {};
@@ -129,6 +168,10 @@ async function extractSegments(clips, sourceFiles, opts) {
     clipsBySource.set(clip.poolItemId, list);
   }
   for (const [poolItemId, sourceClips] of clipsBySource) {
+    if (opts?.signal?.aborted) {
+      await rm(dir, { recursive: true, force: true });
+      opts.signal.throwIfAborted();
+    }
     const sourcePath = sourceFiles[poolItemId];
     const remote = /^https?:\/\//i.test(sourcePath);
     if (!remote && !existsSync2(sourcePath)) {
@@ -153,11 +196,15 @@ async function extractSegments(clips, sourceFiles, opts) {
         "-movflags",
         "+faststart",
         segmentPath
-      ], { timeout: remote ? 12e4 : 6e4 });
+      ], { timeout: remote ? 12e4 : 6e4, signal: opts?.signal });
       segments[poolItemId] = segmentPath;
       origins[poolItemId] = minStart;
       console.log(`[extractSegments] ${poolItemId}: ${minStart.toFixed(1)}s-${maxEnd.toFixed(1)}s \u2192 ${segmentPath}`);
     } catch (err) {
+      if (opts?.signal?.aborted) {
+        await rm(dir, { recursive: true, force: true });
+        throw err;
+      }
       console.error(`[extractSegments] Failed for ${poolItemId}:`, err);
       if (!remote) {
         segments[poolItemId] = sourcePath;
@@ -180,26 +227,37 @@ async function extractSegments(clips, sourceFiles, opts) {
 import { existsSync as existsSync3 } from "fs";
 import { join as join3, extname as extname2 } from "path";
 import { createHash } from "crypto";
-async function resolveAssets(renderInput, tempDir, mediaServerUrl, download) {
+async function resolveAssets(renderInput, tempDir, mediaServerUrl, download, signal) {
   const urlMap = {};
   const seen = /* @__PURE__ */ new Set();
   async function resolve(url) {
+    signal?.throwIfAborted();
     if (!url) return url;
-    if (!isRemoteUrl(url)) return url;
+    const embedded = /^data:([^;,]+);base64,/.exec(url);
+    if (!isRemoteUrl(url) && !embedded) return url;
     if (seen.has(url)) return urlMap[url] ?? url;
     seen.add(url);
     const hash = createHash("md5").update(url).digest("hex").slice(0, 12);
-    const ext = extname2(new URL(url).pathname) || ".bin";
+    const embeddedExtension = {
+      "audio/mp4": ".m4a",
+      "audio/mpeg": ".mp3",
+      "audio/wav": ".wav",
+      "image/png": ".png",
+      "image/jpeg": ".jpg",
+      "image/webp": ".webp",
+      "image/svg+xml": ".svg"
+    };
+    const ext = embedded ? embeddedExtension[embedded[1]] : extname2(new URL(url).pathname);
+    if (!ext) throw new Error(`Unsupported embedded render asset MIME '${embedded?.[1] ?? "unknown"}'.`);
     const filename = `asset_${hash}${ext}`;
-    const localPath = join3(tempDir, filename);
-    if (!existsSync3(localPath)) {
+    const localPath2 = join3(tempDir, filename);
+    if (!existsSync3(localPath2)) {
       try {
-        await download(url, localPath);
+        await download(url, localPath2, signal);
       } catch (err) {
-        throw new Error(
-          `Failed to materialize required render asset ${new URL(url).origin}${new URL(url).pathname}`,
-          { cause: err }
-        );
+        if (signal?.aborted) throw err;
+        const label = embedded ? `embedded ${embedded[1]} asset` : `${new URL(url).origin}${new URL(url).pathname}`;
+        throw new Error(`Failed to materialize required render asset ${label}`, { cause: err });
       }
     }
     const localUrl = `${mediaServerUrl}/${filename}`;
@@ -232,11 +290,616 @@ async function resolveAssets(renderInput, tempDir, mediaServerUrl, download) {
 }
 
 // ../execution/render-harness/src/materializeSources.ts
+import sharp2 from "sharp";
+
+// ../execution/render-harness/src/sceneShotAssets.ts
+import { readFile } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+import { join as join4 } from "path";
+import { fileURLToPath } from "url";
+
+// ../execution/render-harness/src/imageHeader.ts
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function ascii(bytes, offset, length) {
+  let out = "";
+  for (let i = 0; i < length; i++) out += String.fromCharCode(bytes[offset + i]);
+  return out;
+}
+function u16be(bytes, offset) {
+  return bytes[offset] << 8 | bytes[offset + 1];
+}
+function u32be(bytes, offset) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function u16le(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8;
+}
+function u24le(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16;
+}
+function u32le(bytes, offset) {
+  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function png(bytes) {
+  if (bytes.length < 24) return null;
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) if (bytes[i] !== PNG_SIGNATURE[i]) return null;
+  if (u32be(bytes, 8) !== 13 || ascii(bytes, 12, 4) !== "IHDR") return null;
+  const width = u32be(bytes, 16);
+  const height = u32be(bytes, 20);
+  if (width === 0 || height === 0) return null;
+  return { mimeType: "image/png", width, height };
+}
+function isStartOfFrame(code) {
+  return code >= 192 && code <= 195 || code >= 197 && code <= 199 || code >= 201 && code <= 203 || code >= 205 && code <= 207;
+}
+function jpeg(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) return null;
+  let offset = 2;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) return null;
+    let code = bytes[offset + 1];
+    while (code === 255 && offset + 2 < bytes.length) {
+      offset += 1;
+      code = bytes[offset + 1];
+    }
+    offset += 2;
+    if (code === 216 || code >= 208 && code <= 215 || code === 1) continue;
+    if (code === 217 || code === 218) return null;
+    if (offset + 2 > bytes.length) return null;
+    const length = u16be(bytes, offset);
+    if (length < 2) return null;
+    if (isStartOfFrame(code)) {
+      if (offset + 7 > bytes.length) return null;
+      const height = u16be(bytes, offset + 3);
+      const width = u16be(bytes, offset + 5);
+      if (width === 0 || height === 0) return null;
+      return { mimeType: "image/jpeg", width, height };
+    }
+    offset += length;
+  }
+  return null;
+}
+function webp(bytes) {
+  if (bytes.length < 30 || ascii(bytes, 0, 4) !== "RIFF" || ascii(bytes, 8, 4) !== "WEBP") return null;
+  const chunk = ascii(bytes, 12, 4);
+  const size = u32le(bytes, 16);
+  const data = 20;
+  if (chunk === "VP8 ") {
+    if (size < 10 || data + 10 > bytes.length) return null;
+    if (bytes[data + 3] !== 157 || bytes[data + 4] !== 1 || bytes[data + 5] !== 42) return null;
+    const width = u16le(bytes, data + 6) & 16383;
+    const height = u16le(bytes, data + 8) & 16383;
+    if (width === 0 || height === 0) return null;
+    return { mimeType: "image/webp", width, height };
+  }
+  if (chunk === "VP8L") {
+    if (size < 5 || data + 5 > bytes.length || bytes[data] !== 47) return null;
+    const bits = u32le(bytes, data + 1);
+    return { mimeType: "image/webp", width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+  }
+  if (chunk === "VP8X") {
+    if (size < 10 || data + 10 > bytes.length) return null;
+    return { mimeType: "image/webp", width: u24le(bytes, data + 4) + 1, height: u24le(bytes, data + 7) + 1 };
+  }
+  return null;
+}
+function readImageHeader(bytes) {
+  return png(bytes) ?? jpeg(bytes) ?? webp(bytes);
+}
+
+// ../execution/render-harness/src/sceneShotAssets.ts
+function localHandleReader(opts) {
+  return async (handle) => {
+    if (opts.baseUrl && opts.workDir && handle.startsWith(`${opts.baseUrl}/`)) {
+      const name = decodeURIComponent(handle.slice(opts.baseUrl.length + 1).split("?")[0]);
+      return readFile(join4(opts.workDir, name));
+    }
+    if (handle.startsWith("file://")) return readFile(fileURLToPath(handle));
+    if (handle.startsWith("/")) return readFile(handle);
+    let url;
+    try {
+      url = new URL(handle);
+    } catch {
+      throw new Error(`handle "${handle}" is not a readable local asset`);
+    }
+    if ((url.protocol === "http:" || url.protocol === "https:") && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)) {
+      const response = await fetch(handle);
+      if (!response.ok) throw new Error(`loopback fetch ${response.status} for ${handle}`);
+      return new Uint8Array(await response.arrayBuffer());
+    }
+    throw new Error(`handle "${handle}" is not a readable local asset`);
+  };
+}
+async function verifySceneShotAssetBytes(renderInput, read) {
+  for (const overlay of renderInput.overlays ?? []) {
+    if (overlay.template !== "component" || !overlay.sceneShot) continue;
+    const context = { stage: SCENE_SHOT_PREPARATION_STAGE, clipId: overlay.id, componentId: overlay.componentId };
+    for (const surface of overlay.sceneShot.plan.surfaces) {
+      if (surface.realized.source === "color") continue;
+      const slot = surface.slot;
+      const binding = surface.realized.source === "video" ? surface.realized.video : surface.realized.image;
+      const path = surface.path;
+      const handle = binding.handle;
+      if (typeof handle !== "string" || handle.length === 0) {
+        throw new CueframeError(
+          "component_asset_unavailable",
+          `Scene-shot preparation refused for clip '${overlay.id}': slot "${slot}" (at ${path}) has no bound screenshot handle after materialization.`,
+          void 0,
+          { ...context, path, slot }
+        );
+      }
+      let bytes;
+      try {
+        bytes = await read(handle);
+      } catch (error) {
+        throw new CueframeError(
+          "component_asset_unavailable",
+          `Scene-shot preparation refused for clip '${overlay.id}': slot "${slot}" (at ${path}) could not be read for verification: ${error instanceof Error ? error.message : String(error)}.`,
+          void 0,
+          { ...context, path, slot }
+        );
+      }
+      if (surface.realized.source === "video") {
+        const digest2 = createHash2("sha256").update(bytes).digest("hex");
+        if (bytes.byteLength !== surface.realized.video.byteLength || digest2 !== surface.realized.video.encodedSha256) throw new CueframeError("component_asset_integrity_failed", `Scene-shot preparation refused for clip '${overlay.id}': video slot "${slot}" (at ${path}) changed after PTS admission.`, void 0, { ...context, path, slot });
+        continue;
+      }
+      const header = readImageHeader(bytes);
+      if (!header) {
+        throw new CueframeError(
+          "component_asset_integrity_failed",
+          `Scene-shot preparation refused for clip '${overlay.id}': slot "${slot}" (at ${path}) is not an admitted image format; the bytes are not PNG, JPEG or WebP. GIF, SVG and video need an explicit conversion.`,
+          void 0,
+          { ...context, path, slot }
+        );
+      }
+      if (header.mimeType !== binding.mimeType) {
+        throw new CueframeError(
+          "component_asset_integrity_failed",
+          `Scene-shot preparation refused for clip '${overlay.id}': slot "${slot}" (at ${path}) was admitted as ${binding.mimeType} but its bytes are ${header.mimeType}.`,
+          void 0,
+          { ...context, path, slot, admitted: binding.mimeType, actual: header.mimeType }
+        );
+      }
+      if (header.width !== binding.width || header.height !== binding.height) {
+        throw new CueframeError(
+          "component_asset_integrity_failed",
+          `Scene-shot preparation refused for clip '${overlay.id}': slot "${slot}" (at ${path}) was admitted at ${binding.width}x${binding.height} but decodes to ${header.width}x${header.height}.`,
+          void 0,
+          { ...context, path, slot, admitted: `${binding.width}x${binding.height}`, actual: `${header.width}x${header.height}` }
+        );
+      }
+    }
+  }
+}
+
+// ../execution/render-harness/src/nodeScenePreparation.ts
+import { createHash as createHash3 } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { readFile as readFile2 } from "fs/promises";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import sharp from "sharp";
+function localPath(handle) {
+  if (handle.startsWith("file://")) return fileURLToPath2(handle);
+  if (handle.startsWith("/")) return handle;
+  throw new Error(`scene_component_asset_not_localized: ${handle}`);
+}
+async function digest(handle) {
+  let bytes;
+  if (/^http:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?\//.test(handle)) {
+    const response = await fetch(handle);
+    if (!response.ok) throw new Error(`scene_component_asset_not_localized: loopback handle returned ${response.status}.`);
+    bytes = Buffer.from(await response.arrayBuffer());
+  } else {
+    bytes = await readFile2(localPath(handle));
+  }
+  return { bytes, sha256: createHash3("sha256").update(bytes).digest("hex") };
+}
+function matchingRow(input, componentId, sourceVersionId2) {
+  const rows = Object.values(input.componentSources ?? {}).filter(
+    (row) => row.source.componentId === componentId && row.sourceVersionId === sourceVersionId2
+  );
+  if (rows.length === 0) throw new Error(`scene_component_facts_missing: expected a pinned row for ${componentId}@${sourceVersionId2}.`);
+  const canonical = (row) => JSON.stringify({ source: row.source, assets: row.assets });
+  if (rows.some((row) => canonical(row) !== canonical(rows[0]))) {
+    throw new Error(`scene_component_facts_conflict: conflicting pinned rows for ${componentId}@${sourceVersionId2}.`);
+  }
+  return rows[0];
+}
+function selectNestedComponentRowV1(input, overlayId, path, componentId, sourceVersionId2, selections) {
+  const selectedKey = selections?.[overlayId]?.[path];
+  if (selectedKey) {
+    const selected = input.componentSources?.[selectedKey];
+    if (!selected || selected.source.componentId !== componentId || selected.sourceVersionId !== sourceVersionId2) throw new Error(`scene_component_facts_missing: selected row ${selectedKey} does not pin ${componentId}@${sourceVersionId2} for ${overlayId}:${path}.`);
+    return selected;
+  }
+  const candidates = Object.values(input.componentSources ?? {}).filter((row) => row.source.componentId === componentId && row.sourceVersionId === sourceVersionId2);
+  if (!candidates.length) throw new Error(`scene_component_facts_missing: no pinned row for ${componentId}@${sourceVersionId2} at ${overlayId}:${path}.`);
+  const assetless = candidates.every((row) => Object.keys(row.assets).length === 0 && Object.keys(row.source.manifest?.assets ?? {}).length === 0);
+  if (!assetless) throw new Error(`scene_component_asset_binding_required: ${overlayId}:${path} requires an explicit nested component row selection.`);
+  return matchingRow(input, componentId, sourceVersionId2);
+}
+async function stableAssetFacts(row) {
+  return Object.fromEntries(await Promise.all(Object.entries(row.assets).sort(([a], [b]) => a.localeCompare(b)).map(async ([slot, asset]) => {
+    const content = await digest(asset.handle);
+    if (asset.kind === "image") {
+      const metadata = await sharp(content.bytes).metadata();
+      const mime = metadata.format === "png" ? "image/png" : metadata.format === "jpeg" ? "image/jpeg" : metadata.format === "webp" ? "image/webp" : null;
+      if (mime !== asset.mimeType || metadata.width !== asset.width || metadata.height !== asset.height) {
+        throw new Error(`scene_component_asset_integrity_failed: pinned image ${slot} disagrees with decoded bytes.`);
+      }
+    }
+    return [slot, {
+      kind: asset.kind,
+      mimeType: asset.mimeType,
+      width: asset.width ?? null,
+      height: asset.height ?? null,
+      durationSec: asset.durationSec ?? null,
+      byteLength: content.bytes.byteLength,
+      encodedSha256: content.sha256
+    }];
+  })));
+}
+function componentBindings(objects, prefix = "layers") {
+  const found = [];
+  objects.forEach((object, index) => {
+    const path = `${prefix}.${index}`;
+    if (object.kind === "group") found.push(...componentBindings(object.children, `${path}.children`));
+    for (const [slot, binding] of Object.entries("surfaces" in object ? object.surfaces ?? {} : {})) {
+      if (binding.source === "component") found.push({ path: `${path}.surfaces.${slot}`, binding });
+    }
+  });
+  return found;
+}
+var execFileAsync = promisify2(execFile2);
+async function nodeVideoPresentationFactsV1(handle, ffprobeExecutable = "ffprobe", signal) {
+  let raw;
+  try {
+    const source = /^http:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?\//.test(handle) ? handle : localPath(handle);
+    raw = (await execFileAsync(ffprobeExecutable, ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,time_base:frame=best_effort_timestamp", "-show_frames", "-of", "json", source], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, timeout: 3e4, signal })).stdout;
+  } catch (error) {
+    throw new Error(`video_presentation_index_missing: ffprobe could not verify presentation timestamps. Render or transcode this asset to CFR with the existing media tools, then prepare the scene again.`, { cause: error });
+  }
+  const probe = JSON.parse(raw);
+  const stream = probe.streams?.[0];
+  const parts = stream?.time_base?.split("/").map(Number);
+  const pts = probe.frames?.map((frame) => Number(frame.best_effort_timestamp));
+  if (!stream || !parts || parts.length !== 2 || !pts || pts.some((value) => !Number.isSafeInteger(value))) throw new Error("video_presentation_index_missing: ffprobe returned no exact presentation-frame index. Render or transcode this asset to CFR with the existing media tools, then prepare the scene again.");
+  return { pts, timeBase: { num: parts[0], den: parts[1] }, width: stream.width, height: stream.height };
+}
+function nodePhotographicRigFactsV1(scene, width, height) {
+  if (scene.environment.kind !== "photographic-studio-v1") return null;
+  const facts = photographicSceneRigFactsV1(height / scene.referenceSize.height, width, height);
+  return { identity: JSON.parse(JSON.stringify(facts.identity)), allocations: facts.allocations.map((row) => ({ ...row })) };
+}
+function nodeCameraClipPlanesV1(scene, frame, durationInFrames, outputHeight) {
+  const scale = outputHeight / scene.referenceSize.height;
+  return sceneCameraPlanesV2(scene.referenceSize.height, evaluateScene(scene, frame, durationInFrames).camera.fov, scale);
+}
+function createNodeScenePreparationV1(options) {
+  const canonical = (value) => JSON.parse(JSON.stringify(value ?? {}));
+  const provider = createMaterializedSceneCaptureProvider({
+    workspace: options.workspace,
+    workspaceForSource: options.workspaceForSource,
+    renderEntryRoot: options.renderEntryRoot,
+    allowedAssetOrigins: options.allowedAssetOrigins,
+    publishVerifiedPng: options.publishVerifiedPng,
+    async resolveAssets(intent) {
+      const candidates = Object.values(options.input.componentSources ?? {}).filter((row2) => row2.source.componentId === intent.componentId && row2.sourceVersionId === intent.sourceVersionId);
+      const matching = [];
+      for (const candidate of candidates) if (JSON.stringify(await stableAssetFacts(candidate)) === JSON.stringify(intent.assetBindings)) matching.push(candidate);
+      if (!matching.length) throw new Error(`scene_component_asset_integrity_failed: no localized row matches the sealed asset facts for ${intent.componentId}@${intent.sourceVersionId}.`);
+      const row = matching[0];
+      return Object.fromEntries(Object.entries(row.assets).map(([slot, asset]) => [slot, asset.handle]));
+    }
+  });
+  const outputHeight = options.input.outputHeight ?? options.input.height;
+  const descriptors = createSceneBuilderDescriptorRegistryV1((object, context) => {
+    if (object.kind === "group" || object.kind === "text" && object.space === "screen") return null;
+    return scenePresetBuilderDescriptorV1(object, context);
+  });
+  const dependencies = {
+    descriptors,
+    async resolveComponentFacts(scene, { overlay }) {
+      const facts = {};
+      for (const { path, binding } of componentBindings(scene.layers)) {
+        const row = selectNestedComponentRowV1(options.input, overlay.id, path, binding.component.componentId, binding.component.sourceVersionId, options.nestedComponentRowKeys);
+        const execution = await provider.resolveExecutionFacts(binding.component);
+        const assets = await stableAssetFacts(row);
+        facts[path] = {
+          durationInFrames: overlay.durationInFrames,
+          seed: `${binding.component.componentId}:${binding.component.sourceVersionId}`,
+          params: binding.params ?? {},
+          assetBindings: assets,
+          brandFacts: canonical(options.input.brandKit),
+          fontFacts: canonical(options.input.brandKit?.fontAssets ?? []),
+          mediaFacts: assets,
+          ...execution
+        };
+      }
+      return facts;
+    },
+    resolveRigFacts(scene, bounds) {
+      const width = options.input.outputWidth ?? options.input.width;
+      if (scene.environment.kind !== "photographic-studio-v1") return generatedStudioPreparationFactsV1(scene.environment, outputHeight / scene.referenceSize.height, bounds, width, outputHeight);
+      return nodePhotographicRigFactsV1(scene, width, outputHeight);
+    },
+    resolveCameraClipPlanes(scene, frame, durationInFrames) {
+      return nodeCameraClipPlanesV1(scene, frame, durationInFrames, outputHeight);
+    },
+    realization: {
+      capture: provider,
+      async sha256(value) {
+        return createHash3("sha256").update(value).digest("hex");
+      },
+      async resolveImage() {
+        return null;
+      },
+      async resolveVideo() {
+        return null;
+      },
+      signal: options.signal
+    },
+    realizationForOverlay({ input, overlay }) {
+      const row = input.componentSources?.[overlay.id];
+      if (!row) throw new Error(`scene_component_facts_missing: no pinned row for clip ${overlay.id}.`);
+      return {
+        capture: provider,
+        async sha256(value) {
+          return createHash3("sha256").update(value).digest("hex");
+        },
+        async resolveImage(binding) {
+          const asset = row.assets[binding.assetSlot];
+          if (!asset || !["image/png", "image/jpeg", "image/webp"].includes(asset.mimeType)) return null;
+          const encoded = await digest(asset.handle);
+          const image = sharp(encoded.bytes);
+          const metadata = await image.metadata();
+          const actualMime = metadata.format === "png" ? "image/png" : metadata.format === "jpeg" ? "image/jpeg" : metadata.format === "webp" ? "image/webp" : null;
+          if (actualMime !== asset.mimeType || metadata.width !== asset.width || metadata.height !== asset.height) {
+            throw new Error(`scene_image_facts_missing: clip ${overlay.id} slot ${binding.assetSlot} disagrees with decoded bytes.`);
+          }
+          const decoded = await image.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+          return { image: {
+            handle: asset.handle,
+            mimeType: actualMime,
+            byteLength: encoded.bytes.byteLength,
+            width: decoded.info.width,
+            height: decoded.info.height,
+            decodedSha256: createHash3("sha256").update(decoded.data).digest("hex")
+          }, release: async () => {
+          } };
+        },
+        signal: options.signal,
+        async resolveVideo(binding, _path, signal) {
+          const asset = row.assets[binding.mediaId];
+          if (!asset || asset.kind !== "video" || !["video/mp4", "video/webm"].includes(asset.mimeType)) return null;
+          const encoded = await digest(asset.handle);
+          const probe = await nodeVideoPresentationFactsV1(asset.handle, options.ffprobeExecutable, signal);
+          if (probe.width !== asset.width || probe.height !== asset.height) throw new Error(`scene_video_facts_missing: clip ${overlay.id} media ${binding.mediaId} disagrees with decoded dimensions.`);
+          return { video: { handle: asset.handle, mimeType: asset.mimeType, byteLength: encoded.bytes.byteLength, width: probe.width, height: probe.height, encodedSha256: encoded.sha256, presentationIndex: { pts: probe.pts, timeBase: probe.timeBase } }, release: async () => {
+          } };
+        }
+      };
+    }
+  };
+  return { dependencies, close: () => provider.close() };
+}
+
+// ../execution/render-harness/src/materializeSources.ts
+function materializedCaptureFilename(png2, encoded) {
+  const encodedSha256 = createHash4("sha256").update(encoded).digest("hex");
+  return `scene-capture-${png2.decodedSha256}-${encodedSha256}.png`;
+}
+async function verifyDecodedComponentStill(png2, expected) {
+  const bytes = await localHandleReader({})(png2.handle);
+  const encodedSha256 = createHash4("sha256").update(bytes).digest("hex");
+  if (bytes.byteLength !== png2.byteLength || encodedSha256 !== png2.encodedSha256) {
+    throw new Error("scene_component_capture_integrity_failed: captured PNG bytes changed before decode.");
+  }
+  let decoded;
+  try {
+    decoded = await sharp2(bytes).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  } catch (error) {
+    throw new Error(
+      `scene_component_capture_decode_failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const { width, height } = decoded.info;
+  if (width !== png2.width || height !== png2.height || width !== expected.width || height !== expected.height) {
+    throw new Error(
+      `scene_component_capture_dimensions_mismatch: expected ${expected.width}x${expected.height}, runtime reported ${png2.width}x${png2.height}, decoded ${width}x${height}.`
+    );
+  }
+  return {
+    handle: png2.handle,
+    mimeType: "image/png",
+    byteLength: bytes.byteLength,
+    width,
+    height,
+    decodedSha256: createHash4("sha256").update(decoded.data).digest("hex")
+  };
+}
+function abortError() {
+  const error = new Error("scene_component_capture_cancelled");
+  error.name = "AbortError";
+  return error;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortError();
+}
+function captureSessionKey(intent) {
+  return JSON.stringify({
+    componentId: intent.componentId,
+    sourceVersionId: intent.sourceVersionId,
+    layoutWidth: intent.layoutWidth,
+    layoutHeight: intent.layoutHeight,
+    bakeScale: intent.bakeScale,
+    durationInFrames: intent.durationInFrames,
+    fps: intent.fps,
+    requestedGlBackend: intent.requestedGlBackend,
+    runtimeIdentity: intent.runtimeIdentity,
+    dependencyIdentity: intent.dependencyIdentity,
+    rasterAffectingFlags: intent.rasterAffectingFlags
+  });
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function createMaterializedSceneCaptureProvider(options) {
+  const sessions = /* @__PURE__ */ new Map();
+  const captures = /* @__PURE__ */ new Map();
+  const createSession = options.createSession ?? createComponentStillSession;
+  const resolveDependencyIdentity = options.resolveDependencyIdentity ?? componentStillDependencyIdentity;
+  let closed = false;
+  let closePromise = null;
+  const source = (componentId, expectedSourceVersionId) => {
+    const workspace = options.workspaceForSource?.(componentId, expectedSourceVersionId) ?? options.workspace;
+    const materialized = readMaterializedComponentSource(workspace, componentId);
+    if (!materialized) throw new Error(`scene_component_source_unavailable: ${componentId}`);
+    const actualSourceVersionId = sourceVersionId(materialized);
+    if (expectedSourceVersionId !== actualSourceVersionId) {
+      throw new Error(
+        `scene_component_source_pin_mismatch: ${componentId} expected ${expectedSourceVersionId}, actual ${actualSourceVersionId}`
+      );
+    }
+    return { materialized, actualSourceVersionId, workspace };
+  };
+  const resolveExecutionFacts = async (request, signal) => {
+    throwIfAborted(signal);
+    const { materialized } = source(request.componentId, request.sourceVersionId);
+    const graphics = materialized.manifest.graphics;
+    const renderEntryRoot = resolveRenderEntryRoot(options.renderEntryRoot);
+    const dependencyIdentity = await resolveDependencyIdentity(
+      renderEntryRoot
+    );
+    throwIfAborted(signal);
+    return {
+      runtimeIdentity: COMPONENT_STILL_RUNTIME_IDENTITY,
+      dependencyIdentity,
+      requestedGlBackend: componentBrowserBackend(graphics).chromiumOptions.gl,
+      rasterAffectingFlags: componentStillRasterAffectingFlags(graphics)
+    };
+  };
+  const provider = {
+    resolveExecutionFacts,
+    async openSession(rawIntent, signal) {
+      if (closed) throw new Error("scene_component_capture_provider_closed");
+      throwIfAborted(signal);
+      const intent = parseSceneComponentCaptureIntentV1(rawIntent);
+      if (intent.params === null || Array.isArray(intent.params) || typeof intent.params !== "object") {
+        throw new Error("scene_component_params_invalid: params must be an object.");
+      }
+      const execution = await resolveExecutionFacts(intent, signal);
+      if (closed) throw new Error("scene_component_capture_provider_closed");
+      for (const field of ["runtimeIdentity", "dependencyIdentity", "requestedGlBackend", "rasterAffectingFlags"]) {
+        if (stableJson(intent[field]) !== stableJson(execution[field])) {
+          throw new Error(`scene_component_execution_fact_mismatch: ${field}`);
+        }
+      }
+      const { materialized, workspace } = source(intent.componentId, intent.sourceVersionId);
+      const key = captureSessionKey(intent);
+      let opened = sessions.get(key);
+      if (!opened) {
+        opened = (async () => {
+          const session = await createSession({
+            ws: workspace,
+            id: intent.componentId,
+            params: intent.params,
+            assets: await options.resolveAssets(intent),
+            seed: intent.seed,
+            graphics: materialized.manifest.graphics,
+            width: intent.layoutWidth,
+            height: intent.layoutHeight,
+            scale: intent.bakeScale,
+            fps: intent.fps.num / intent.fps.den,
+            durationInFrames: intent.durationInFrames,
+            revision: intent.sourceVersionId,
+            renderEntryRoot: options.renderEntryRoot,
+            allowedAssetOrigins: options.allowedAssetOrigins,
+            captureAttestation: true
+          });
+          return session;
+        })();
+        sessions.set(key, opened);
+        void opened.catch(() => sessions.delete(key));
+      }
+      const runtimeSession = await opened;
+      throwIfAborted(signal);
+      return {
+        async capture(nextRaw, captureSignal) {
+          if (closed) throw new Error("scene_component_capture_provider_closed");
+          throwIfAborted(captureSignal);
+          const next = parseSceneComponentCaptureIntentV1(nextRaw);
+          if (captureSessionKey(next) !== key) {
+            throw new Error("scene_component_capture_session_mismatch");
+          }
+          const captureKey = stableJson(next);
+          let pending = captures.get(captureKey);
+          if (!pending) {
+            pending = (async () => {
+              const rendered = await runtimeSession.renderVerifiedFrame({
+                frame: next.captureFrame,
+                params: next.params,
+                assets: await options.resolveAssets(next),
+                seed: next.seed,
+                expectedRevision: next.sourceVersionId
+              });
+              let png2 = await verifyDecodedComponentStill(rendered.png, {
+                width: next.rasterWidth,
+                height: next.rasterHeight
+              });
+              if (options.publishVerifiedPng) png2 = await options.publishVerifiedPng(png2);
+              return { attestation: rendered.attestation, png: png2, cacheScope: "session" };
+            })();
+            captures.set(captureKey, pending);
+            void pending.catch(() => captures.delete(captureKey));
+          }
+          const result = await pending;
+          throwIfAborted(captureSignal);
+          return result;
+        },
+        // The provider owns this shared browser across preparation leases. Consumer cleanup calls
+        // provider.close after every plan using its retained handles has finished.
+        async close() {
+        }
+      };
+    },
+    async close() {
+      if (closePromise) return closePromise;
+      closed = true;
+      closePromise = (async () => {
+        const opened = await Promise.allSettled(sessions.values());
+        const cancellation = Promise.allSettled(
+          opened.flatMap((result) => result.status === "fulfilled" ? [result.value.cancel()] : [])
+        );
+        const [completedCaptures, cleanup] = await Promise.all([
+          Promise.allSettled(captures.values()),
+          cancellation
+        ]);
+        sessions.clear();
+        captures.clear();
+        const failures = [
+          ...completedCaptures.flatMap((result) => result.status === "rejected" ? [result.reason] : []),
+          ...opened.flatMap((result) => result.status === "rejected" ? [result.reason] : []),
+          ...cleanup.flatMap((result) => result.status === "rejected" && result.reason?.code !== "ENOENT" ? [result.reason] : [])
+        ];
+        if (failures.length) throw new AggregateError(failures, "scene_component_capture_cleanup_failed");
+      })();
+      return closePromise;
+    }
+  };
+  return provider;
+}
 function localFilePath(u) {
   if (typeof u !== "string" || u.length === 0) return null;
   if (/^https?:\/\//i.test(u)) return null;
   let p;
-  if (u.startsWith("file://")) p = fileURLToPath(u);
+  if (u.startsWith("file://")) p = fileURLToPath3(u);
   else if (u.startsWith("/")) p = u;
   else return null;
   return existsSync4(p) ? p : null;
@@ -247,122 +910,200 @@ function hasLocalFileRefs(input) {
   }
   return false;
 }
-async function httpDownload(url, destPath) {
-  const r = await fetch(url);
+async function httpDownload(url, destPath, signal) {
+  const r = await fetch(url, { signal });
   if (!r.ok) throw new Error(`download ${r.status} for ${assetUrlKey(url)}`);
   if (!r.body) throw new Error(`download empty body for ${assetUrlKey(url)}`);
   await pipeline(
     Readable.fromWeb(r.body),
-    createWriteStream(destPath)
+    createWriteStream(destPath),
+    { signal }
   );
 }
+function admitSceneMaterializationInput(renderInput) {
+  let found = false;
+  for (const overlay of renderInput.overlays ?? []) {
+    const row = renderInput.componentSources?.[overlay.id];
+    const authoredVersion = overlay.params?.scene?.version;
+    const declaredVersion = row?.source.manifest?.sceneShot?.version;
+    if (authoredVersion !== 2 && declaredVersion === void 0) continue;
+    found = true;
+    if (!overlay.componentId || !overlay.sourceVersionId || !row || row.source.componentId !== overlay.componentId || row.sourceVersionId !== overlay.sourceVersionId) {
+      throw new Error(`scene_component_facts_missing: pinned source facts do not match scene candidate ${overlay.id}.`);
+    }
+    if (!readSceneShotManifest(row.source.manifest, { clipId: overlay.id, componentId: overlay.componentId })) {
+      throw new Error(`scene_component_facts_missing: ${overlay.id} does not declare a scene source.`);
+    }
+    parseSceneShotSpecV2(overlay.params.scene);
+  }
+  return found;
+}
 async function materializeSources(renderInput, workDir, log = () => {
-}) {
+}, options = {}) {
+  throwIfAborted(options.signal);
   assertCardHtmlAssetFree(renderInput);
-  if (renderInputAssets(renderInput).length === 0 && !hasLocalFileRefs(renderInput)) {
+  const needsScenePreparation = admitSceneMaterializationInput(renderInput);
+  if (!needsScenePreparation && renderInputAssets(renderInput).length === 0 && !hasLocalFileRefs(renderInput)) {
+    await verifySceneShotAssetBytes(renderInput, localHandleReader({}));
     return { renderInput, close: async () => {
     } };
   }
   await mkdir(workDir, { recursive: true });
   const server = startMediaServer(workDir);
   const fps = Number(renderInput.fps) || 30;
-  const cleanups = [];
-  const clips = renderInput.clips ?? [];
-  const remoteClips = clips.filter(
-    (c) => isRemoteUrl(c.src) && (c.mediaType === void 0 || c.mediaType === "video")
-  );
-  if (remoteClips.length > 0) {
-    const PADDING = 1;
-    const sourceUrls = {};
-    const idByKey = /* @__PURE__ */ new Map();
-    let i = 0;
-    for (const clip of remoteClips) {
-      const key = assetUrlKey(clip.src);
-      if (idByKey.has(key)) continue;
-      const id = `src${i++}`;
-      sourceUrls[id] = clip.src;
-      idByKey.set(key, id);
-    }
-    const ranges = remoteClips.map((c) => {
-      const id = idByKey.get(assetUrlKey(c.src));
-      const sourceInSec = (Number(c.sourceInFrames) || 0) / fps;
-      const durSec = (Number(c.durationInFrames) || 0) / fps;
-      return { poolItemId: id, sourceIn: sourceInSec, sourceOut: sourceInSec + durSec };
-    });
-    const { segments, origins, cleanup } = await extractSegments(ranges, sourceUrls, {
-      padding: PADDING
-    });
-    cleanups.push(cleanup);
-    log(`[materialize] range-read-trimmed ${Object.keys(segments).length} source(s)`);
-    const servedById = {};
-    for (const [id, segPath] of Object.entries(segments)) {
-      const fname = `${id}.seg.mp4`;
-      await copyFile(segPath, join4(workDir, fname));
-      servedById[id] = fname;
-    }
-    for (const clip of remoteClips) {
-      const id = idByKey.get(assetUrlKey(clip.src));
-      if (!id || !servedById[id]) {
-        throw new Error(
-          `source trim failed for ${assetUrlKey(clip.src)} \u2014 video source not range-readable`
-        );
+  const cleanups = [async () => {
+    server.close();
+  }];
+  let closePromise = null;
+  const cleanupAll = () => closePromise ??= Promise.allSettled([...cleanups].reverse().map((cleanup) => cleanup())).then((results) => {
+    const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length) throw new AggregateError(failures, "materialize_sources_cleanup_failed");
+  });
+  try {
+    const clips = renderInput.clips ?? [];
+    const remoteClips = clips.filter(
+      (c) => isRemoteUrl(c.src) && (c.mediaType === void 0 || c.mediaType === "video")
+    );
+    if (remoteClips.length > 0) {
+      const PADDING = 1;
+      const sourceUrls = {};
+      const idByKey = /* @__PURE__ */ new Map();
+      let i = 0;
+      for (const clip of remoteClips) {
+        const key = assetUrlKey(clip.src);
+        if (idByKey.has(key)) continue;
+        const id = `src${i++}`;
+        sourceUrls[id] = clip.src;
+        idByKey.set(key, id);
       }
-      const shiftFrames = Math.round((origins[id] ?? 0) * fps);
-      if (shiftFrames !== 0) {
-        clip.sourceInFrames = (Number(clip.sourceInFrames) || 0) - shiftFrames;
-        clip.trimStartFrames = (Number(clip.trimStartFrames) || 0) - shiftFrames;
-        if (typeof clip.sourceOutFrames === "number") {
-          clip.sourceOutFrames -= shiftFrames;
+      const ranges = remoteClips.map((c) => {
+        const id = idByKey.get(assetUrlKey(c.src));
+        const sourceInSec = (Number(c.sourceInFrames) || 0) / fps;
+        const durSec = (Number(c.durationInFrames) || 0) / fps;
+        return { poolItemId: id, sourceIn: sourceInSec, sourceOut: sourceInSec + durSec };
+      });
+      const { segments, origins, cleanup } = await extractSegments(ranges, sourceUrls, {
+        padding: PADDING,
+        signal: options.signal
+      });
+      cleanups.push(cleanup);
+      log(`[materialize] range-read-trimmed ${Object.keys(segments).length} source(s)`);
+      const servedById = {};
+      for (const [id, segPath] of Object.entries(segments)) {
+        throwIfAborted(options.signal);
+        const fname = `${id}.seg.mp4`;
+        await copyFile(segPath, join5(workDir, fname));
+        throwIfAborted(options.signal);
+        servedById[id] = fname;
+      }
+      for (const clip of remoteClips) {
+        const id = idByKey.get(assetUrlKey(clip.src));
+        if (!id || !servedById[id]) {
+          throw new Error(
+            `source trim failed for ${assetUrlKey(clip.src)} \u2014 video source not range-readable`
+          );
+        }
+        const shiftFrames = Math.round((origins[id] ?? 0) * fps);
+        if (shiftFrames !== 0) {
+          clip.sourceInFrames = (Number(clip.sourceInFrames) || 0) - shiftFrames;
+          clip.trimStartFrames = (Number(clip.trimStartFrames) || 0) - shiftFrames;
+          if (typeof clip.sourceOutFrames === "number") {
+            clip.sourceOutFrames -= shiftFrames;
+          }
         }
+        clip.src = `${server.baseUrl}/${servedById[id]}`;
       }
-      clip.src = `${server.baseUrl}/${servedById[id]}`;
     }
-  }
-  const assets = await resolveAssets(renderInput, workDir, server.baseUrl, httpDownload);
-  if (assets.count > 0) log(`[materialize] resolved ${assets.count} overlay/audio asset(s)`);
-  const remaining = renderInputAssets(renderInput);
-  if (remaining.length > 0) {
-    const localByKey = /* @__PURE__ */ new Map();
-    for (const ref of remaining) {
-      await httpDownload(ref.url, join4(workDir, ref.filename));
-      localByKey.set(assetUrlKey(ref.url), `${server.baseUrl}/${ref.filename}`);
+    const assets = await resolveAssets(renderInput, workDir, server.baseUrl, httpDownload, options.signal);
+    if (assets.count > 0) log(`[materialize] resolved ${assets.count} overlay/audio asset(s)`);
+    const remaining = renderInputAssets(renderInput);
+    if (remaining.length > 0) {
+      const localByKey = /* @__PURE__ */ new Map();
+      for (const ref of remaining) {
+        await httpDownload(ref.url, join5(workDir, ref.filename), options.signal);
+        localByKey.set(assetUrlKey(ref.url), `${server.baseUrl}/${ref.filename}`);
+      }
+      for (const slot of assetSlots(renderInput)) {
+        const url = slot.get();
+        if (typeof url !== "string" || !isRemoteUrl(url)) continue;
+        const local = localByKey.get(assetUrlKey(url));
+        if (local) slot.set(local);
+      }
+      log(`[materialize] downloaded ${remaining.length} matte/trajectory/other asset(s)`);
     }
+    const bundledFonts = {
+      "/fonts/zodiak.woff2": "81bf124d17416df8fb656393c46fb34bb74e5d472f07cec9ab295269f372098a",
+      "/fonts/dm-sans.woff2": "468d56b6b25b05b70190b6c233d773f6f1770e8579827ce022a57f03fa8002fb"
+    };
+    const admittedRenderEntryRoot = options.renderEntryRoot ?? process.env.RENDER_ENTRY_ROOT;
+    const renderEntryPublic = admittedRenderEntryRoot ? join5(admittedRenderEntryRoot, "public") : null;
     for (const slot of assetSlots(renderInput)) {
       const url = slot.get();
-      if (typeof url !== "string" || !isRemoteUrl(url)) continue;
-      const local = localByKey.get(assetUrlKey(url));
-      if (local) slot.set(local);
+      if (slot.role !== "font" || typeof url !== "string" || !(url in bundledFonts)) continue;
+      if (!renderEntryPublic) throw new Error(`font_not_reproducible: App font '${url}' has no packaged render-entry root.`);
+      const source = join5(renderEntryPublic, url.slice(1));
+      const bytes = await readFile3(source);
+      const observed = createHash4("sha256").update(bytes).digest("hex");
+      if (observed !== bundledFonts[url]) {
+        throw new Error(`font_not_reproducible: App font '${url}' digest mismatch (${observed}).`);
+      }
+      const filename = `app-font-${basename(url)}`;
+      await copyFile(source, join5(workDir, filename));
+      throwIfAborted(options.signal);
+      slot.set(`${server.baseUrl}/${filename}`);
     }
-    log(`[materialize] downloaded ${remaining.length} matte/trajectory/other asset(s)`);
-  }
-  const localByPath = /* @__PURE__ */ new Map();
-  for (const slot of assetSlots(renderInput)) {
-    const p = localFilePath(slot.get());
-    if (!p) continue;
-    let served = localByPath.get(p);
-    if (!served) {
-      const fname = `local-${localByPath.size}-${basename(p)}`;
-      await copyFile(p, join4(workDir, fname));
-      served = `${server.baseUrl}/${fname}`;
-      localByPath.set(p, served);
+    const localByPath = /* @__PURE__ */ new Map();
+    for (const slot of assetSlots(renderInput)) {
+      throwIfAborted(options.signal);
+      const p = localFilePath(slot.get());
+      if (!p) continue;
+      let served = localByPath.get(p);
+      if (!served) {
+        const fname = `local-${localByPath.size}-${basename(p)}`;
+        await copyFile(p, join5(workDir, fname));
+        throwIfAborted(options.signal);
+        served = `${server.baseUrl}/${fname}`;
+        localByPath.set(p, served);
+      }
+      slot.set(served);
     }
-    slot.set(served);
-  }
-  if (localByPath.size > 0) log(`[materialize] served ${localByPath.size} local-file asset(s) over loopback`);
-  assertNoRemoteRefs(renderInput);
-  return {
-    renderInput,
-    close: async () => {
-      server.close();
-      for (const c of cleanups) await c().catch(() => {
+    if (localByPath.size > 0) log(`[materialize] served ${localByPath.size} local-file asset(s) over loopback`);
+    if (needsScenePreparation) {
+      throwIfAborted(options.signal);
+      if (!options.workspace) throw new Error("scene_prepared_plan_required: a workspace is required for V2 scene materialization.");
+      const host = createNodeScenePreparationV1({
+        ...options,
+        input: renderInput,
+        workspace: options.workspace,
+        async publishVerifiedPng(png2) {
+          throwIfAborted(options.signal);
+          const encoded = await readFile3(png2.handle);
+          throwIfAborted(options.signal);
+          const filename = materializedCaptureFilename(png2, encoded);
+          await copyFile(png2.handle, join5(workDir, filename));
+          throwIfAborted(options.signal);
+          return { ...png2, handle: `${server.baseUrl}/${filename}` };
+        }
       });
+      cleanups.push(host.close);
+      const prepared = await prepareSceneShotRenderInput(renderInput, host.dependencies);
+      cleanups.push(prepared.cleanup);
+      renderInput = prepared.input;
     }
-  };
+    await verifySceneShotAssetBytes(renderInput, localHandleReader({ workDir, baseUrl: server.baseUrl }));
+    assertNoRemoteRefs(renderInput);
+    return { renderInput, close: cleanupAll };
+  } catch (error) {
+    await cleanupAll().catch((cleanupError) => {
+      if (error instanceof Error && error.cause === void 0) error.cause = cleanupError;
+    });
+    throw error;
+  }
 }
 
 // ../execution/render-harness/src/cardRender.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var CARD_COMPOSITION_ID = "CueFrameCardStill";
 var CARD_ROOT_FILENAME = "card.Root.local.tsx";
 var CARD_ENTRY_FILENAME = "card.entry.local.tsx";
@@ -408,7 +1149,7 @@ function buildCardWebpackOverride(renderEntryRoot) {
     ...config,
     resolve: {
       ...config.resolve,
-      modules: [join5(renderEntryRoot, "node_modules"), ...config.resolve?.modules ?? ["node_modules"]]
+      modules: [join6(renderEntryRoot, "node_modules"), ...config.resolve?.modules ?? ["node_modules"]]
     }
   });
 }
@@ -418,29 +1159,34 @@ async function renderCardStill(opts) {
   const fps = opts.fps ?? 30;
   const frame = opts.frame ?? 0;
   const renderEntryRoot = resolveRenderEntryRoot(opts.renderEntryRoot);
-  const browserExecutable = process.env.REMOTION_CHROME_EXECUTABLE || void 0;
+  const browserExecutable = (await verifyLocalStagedBrowser(renderEntryRoot)).path;
   mkdirSync(opts.outDir, { recursive: true });
-  writeFileSync(join5(opts.outDir, CARD_ROOT_FILENAME), generateCardRootSource({ width, height, fps }));
-  const entryPoint = join5(opts.outDir, CARD_ENTRY_FILENAME);
+  writeFileSync(join6(opts.outDir, CARD_ROOT_FILENAME), generateCardRootSource({ width, height, fps }));
+  const entryPoint = join6(opts.outDir, CARD_ENTRY_FILENAME);
   writeFileSync(entryPoint, generateCardEntrySource());
   const { bundle } = await importFromRenderEntry(
     renderEntryRoot,
     "@remotion/bundler"
   );
-  const serveUrl = await bundle({ entryPoint, webpackOverride: buildCardWebpackOverride(renderEntryRoot) });
+  const serveUrl = await bundle({
+    entryPoint,
+    outDir: join6(opts.outDir, "remotion-bundle"),
+    webpackOverride: buildCardWebpackOverride(renderEntryRoot)
+  });
   const { selectComposition, renderStill } = await importFromRenderEntry(
     renderEntryRoot,
     "@remotion/renderer"
   );
   const inputProps = { html: opts.html, cssVars: opts.cssVars ?? {} };
+  const { chromiumOptions } = componentBrowserBackend({ api: "canvas2d", required: true, accelerationPreference: "software-allowed" });
   const composition = await selectComposition({
     serveUrl,
     id: CARD_COMPOSITION_ID,
     inputProps,
     browserExecutable,
-    chromiumOptions: COMPONENT_CHROMIUM_OPTIONS
+    chromiumOptions
   });
-  const pngPath = join5(opts.outDir, "card-still.png");
+  const pngPath = join6(opts.outDir, "card-still.png");
   await renderStill({
     composition,
     serveUrl,
@@ -448,7 +1194,7 @@ async function renderCardStill(opts) {
     output: pngPath,
     frame,
     browserExecutable,
-    chromiumOptions: COMPONENT_CHROMIUM_OPTIONS,
+    chromiumOptions,
     timeoutInMilliseconds: 12e4
   });
   return { pngPath };
@@ -462,13 +1208,17 @@ export {
   assetSlots,
   assetUrlKey,
   buildCardWebpackOverride,
+  createNodeScenePreparationV1,
   extractSegments,
   generateCardEntrySource,
   generateCardRootSource,
   isRemoteUrl,
+  localHandleReader,
   materializeSources,
+  readImageHeader,
   renderCardStill,
   renderInputAssets,
   resolveAssets,
-  startMediaServer
+  startMediaServer,
+  verifySceneShotAssetBytes
 };