@cueframe/kernel 0.0.1

package/dist/render-harness.js

@@ -0,0 +1,1019 @@
+import {
+  cacheDir,
+  componentDir,
+  listComponents
+} from "./chunk-WB2VFDQZ.js";
+import {
+  GLOBALS_MODULE,
+  SANDBOX_GLOBAL_SPECS
+} from "./chunk-GBRNYH7W.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 { createWriteStream, existsSync as existsSync4 } from "fs";
+import { fileURLToPath } from "url";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// ../execution/render-harness/src/mediaServer.ts
+import { createServer } from "http";
+import { createReadStream, statSync, existsSync } from "fs";
+import { join, extname } from "path";
+var MIME_TYPES = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".ogg": "audio/ogg",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".json": "application/json",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf"
+};
+function startMediaServer(directory) {
+  const server = createServer((req, res) => {
+    const filename = decodeURIComponent((req.url ?? "/").slice(1));
+    const filePath = join(directory, filename);
+    if (!existsSync(filePath)) {
+      res.writeHead(404, { "Access-Control-Allow-Origin": "*" });
+      res.end("Not found");
+      return;
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
+        "Access-Control-Allow-Headers": "Range"
+      });
+      res.end();
+      return;
+    }
+    const size = statSync(filePath).size;
+    const contentType = MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+    const range = req.headers.range;
+    if (range) {
+      const parts = range.replace(/bytes=/, "").split("-");
+      const start = parseInt(parts[0], 10);
+      const end = parts[1] ? parseInt(parts[1], 10) : size - 1;
+      res.writeHead(206, {
+        "Content-Range": `bytes ${start}-${end}/${size}`,
+        "Accept-Ranges": "bytes",
+        "Content-Length": end - start + 1,
+        "Content-Type": contentType,
+        "Access-Control-Allow-Origin": "*"
+      });
+      createReadStream(filePath, { start, end }).pipe(res);
+    } else {
+      res.writeHead(200, {
+        "Content-Length": size,
+        "Content-Type": contentType,
+        "Accept-Ranges": "bytes",
+        "Access-Control-Allow-Origin": "*"
+      });
+      createReadStream(filePath).pipe(res);
+    }
+  });
+  server.listen(0);
+  const port = server.address().port;
+  return {
+    baseUrl: `http://localhost:${port}`,
+    close: () => server.close()
+  };
+}
+
+// ../execution/render-harness/src/extractSegments.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { mkdtempSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+import { rm } from "fs/promises";
+var exec = promisify(execFile);
+async function extractSegments(clips, sourceFiles, opts) {
+  const padding = opts?.padding ?? 1;
+  const dir = mkdtempSync(join2(tmpdir(), "cueframe-segments-"));
+  const segments = {};
+  const origins = {};
+  const clipsBySource = /* @__PURE__ */ new Map();
+  for (const clip of clips) {
+    if (!sourceFiles[clip.poolItemId]) continue;
+    const list = clipsBySource.get(clip.poolItemId) ?? [];
+    list.push(clip);
+    clipsBySource.set(clip.poolItemId, list);
+  }
+  for (const [poolItemId, sourceClips] of clipsBySource) {
+    const sourcePath = sourceFiles[poolItemId];
+    const remote = /^https?:\/\//i.test(sourcePath);
+    if (!remote && !existsSync2(sourcePath)) {
+      console.warn(`[extractSegments] Source not found: ${sourcePath}`);
+      continue;
+    }
+    const minStart = Math.max(0, Math.min(...sourceClips.map((c) => c.sourceIn)) - padding);
+    const maxEnd = Math.max(...sourceClips.map((c) => c.sourceOut)) + padding;
+    const segmentPath = join2(dir, `${poolItemId}.mp4`);
+    try {
+      await exec("ffmpeg", [
+        "-y",
+        // Reconnect on transient HTTP drops when range-reading a remote source.
+        ...remote ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : [],
+        "-ss",
+        minStart.toFixed(3),
+        "-to",
+        maxEnd.toFixed(3),
+        "-i",
+        sourcePath,
+        "-c",
+        "copy",
+        "-movflags",
+        "+faststart",
+        segmentPath
+      ], { timeout: remote ? 12e4 : 6e4 });
+      segments[poolItemId] = segmentPath;
+      origins[poolItemId] = minStart;
+      console.log(`[extractSegments] ${poolItemId}: ${minStart.toFixed(1)}s-${maxEnd.toFixed(1)}s \u2192 ${segmentPath}`);
+    } catch (err) {
+      console.error(`[extractSegments] Failed for ${poolItemId}:`, err);
+      if (!remote) {
+        segments[poolItemId] = sourcePath;
+        origins[poolItemId] = 0;
+      }
+    }
+  }
+  return {
+    segments,
+    origins,
+    dir,
+    cleanup: async () => {
+      await rm(dir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  };
+}
+
+// ../execution/render-harness/src/resolveAssets.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, extname as extname2 } from "path";
+import { createHash } from "crypto";
+
+// ../execution/render-harness/src/renderInputAssets.ts
+function isRemoteUrl(u) {
+  return typeof u === "string" && /^https?:\/\//i.test(u) && !/^https?:\/\/(127\.0\.0\.1|localhost)(:|\/|$)/i.test(u);
+}
+function assetUrlKey(url) {
+  return url.split("?")[0];
+}
+function* assetSlots(input) {
+  for (const clip of input.clips ?? []) {
+    yield { role: "source", get: () => clip.src, set: (u) => {
+      clip.src = u;
+    } };
+    yield { role: "matte", get: () => clip.packedUrl, set: (u) => {
+      clip.packedUrl = u;
+    } };
+    yield {
+      role: "trajectory",
+      get: () => clip.cropTrajectoryUrl,
+      set: (u) => {
+        clip.cropTrajectoryUrl = u;
+      }
+    };
+  }
+  for (const track of input.audioTracks ?? []) {
+    yield { role: "audio", get: () => track.src, set: (u) => {
+      track.src = u;
+    } };
+  }
+  for (const overlay of input.overlays ?? []) {
+    const params = overlay.params;
+    if (params) {
+      yield { role: "overlayAsset", get: () => params.src, set: (u) => {
+        params.src = u;
+      } };
+    }
+  }
+  for (const font of input.brandKit?.fontAssets ?? []) {
+    yield { role: "font", get: () => font.url, set: (u) => {
+      font.url = u;
+    } };
+  }
+  const bk = input.brandKit;
+  if (bk) {
+    if (bk.logo) {
+      yield { role: "brandMedia", get: () => bk.logo.src, set: (u) => {
+        bk.logo.src = u;
+      } };
+    }
+    if (bk.intro) {
+      yield { role: "brandMedia", get: () => bk.intro.src, set: (u) => {
+        bk.intro.src = u;
+      } };
+    }
+    if (bk.outro) {
+      yield { role: "brandMedia", get: () => bk.outro.src, set: (u) => {
+        bk.outro.src = u;
+      } };
+    }
+    if (bk.watermark) {
+      yield { role: "brandMedia", get: () => bk.watermark.src, set: (u) => {
+        bk.watermark.src = u;
+      } };
+    }
+  }
+}
+function extFor(url, role) {
+  const path = assetUrlKey(url);
+  const m = path.match(/\.([a-z0-9]{2,5})$/i);
+  if (m) return m[1].toLowerCase();
+  return role === "trajectory" ? "json" : role === "audio" ? "m4a" : role === "font" ? "woff2" : "mp4";
+}
+function shortHash(s) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(36);
+}
+function filenameFor(url, role) {
+  return `${role}-${shortHash(assetUrlKey(url))}.${extFor(url, role)}`;
+}
+function renderInputAssets(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  for (const slot of assetSlots(input)) {
+    const url = slot.get();
+    if (!isRemoteUrl(url)) continue;
+    const key = assetUrlKey(url);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    refs.push({ role: slot.role, url, filename: filenameFor(url, slot.role) });
+  }
+  return refs;
+}
+function assertNoRemoteRefs(input) {
+  const leftover = [];
+  for (const slot of assetSlots(input)) {
+    const url = slot.get();
+    if (isRemoteUrl(url)) leftover.push(`${slot.role}: ${assetUrlKey(url)}`);
+  }
+  if (leftover.length > 0) {
+    throw new Error(
+      `RenderInput still references ${leftover.length} un-localized remote asset(s) after staging \u2014 the render environment is incomplete and would block/hang in a no-egress sandbox:
+  ` + leftover.join("\n  ")
+    );
+  }
+}
+
+// ../execution/render-harness/src/resolveAssets.ts
+async function resolveAssets(renderInput, tempDir, mediaServerUrl, download) {
+  const urlMap = {};
+  const seen = /* @__PURE__ */ new Set();
+  async function resolve2(url) {
+    if (!url) return url;
+    if (!isRemoteUrl(url)) 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 filename = `asset_${hash}${ext}`;
+    const localPath = join3(tempDir, filename);
+    if (!existsSync3(localPath)) {
+      try {
+        await download(url, localPath);
+      } catch (err) {
+        console.warn(`[resolveAssets] Failed to download ${url}:`, err);
+        return url;
+      }
+    }
+    const localUrl = `${mediaServerUrl}/${filename}`;
+    urlMap[url] = localUrl;
+    return localUrl;
+  }
+  if (renderInput.audioTracks) {
+    for (const track of renderInput.audioTracks) {
+      if ("src" in track && typeof track.src === "string") {
+        track.src = await resolve2(track.src);
+      }
+    }
+  }
+  if (renderInput.overlays) {
+    for (const overlay of renderInput.overlays) {
+      if (overlay.params) {
+        for (const [key, value] of Object.entries(overlay.params)) {
+          if (typeof value === "string" && isRemoteUrl(value)) {
+            const resolved = await resolve2(value);
+            if (resolved) overlay.params[key] = resolved;
+          }
+        }
+      }
+    }
+  }
+  return {
+    urlMap,
+    count: Object.keys(urlMap).length
+  };
+}
+
+// ../execution/render-harness/src/materializeSources.ts
+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);
+  else if (u.startsWith("/")) p = u;
+  else return null;
+  return existsSync4(p) ? p : null;
+}
+function hasLocalFileRefs(input) {
+  for (const slot of assetSlots(input)) {
+    if (localFilePath(slot.get())) return true;
+  }
+  return false;
+}
+async function httpDownload(url, destPath) {
+  const r = await fetch(url);
+  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)
+  );
+}
+async function materializeSources(renderInput, workDir, log = () => {
+}) {
+  if (renderInputAssets(renderInput).length === 0 && !hasLocalFileRefs(renderInput)) {
+    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 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]}`;
+    }
+  }
+  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}`);
+    }
+    for (const slot of assetSlots(renderInput)) {
+      const url = slot.get();
+      if (!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 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);
+    }
+    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(() => {
+      });
+    }
+  };
+}
+
+// ../execution/render-harness/src/localRender.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join5, relative, resolve, dirname } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var LOCAL_REGISTRY_FILENAME = "registry.local.tsx";
+var LOCAL_ROOT_FILENAME = "Root.local.tsx";
+var LOCAL_ENTRY_FILENAME = "entry.local.tsx";
+var LOCAL_COMPOSITION_ID = "CueFrameLocalStill";
+function toImportSpecifier(fromDir, toFile) {
+  const rel = relative(fromDir, toFile).split("\\").join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function generateLocalRegistry(ws) {
+  const dir = cacheDir(ws);
+  mkdirSync(dir, { recursive: true });
+  const ids = listComponents(ws);
+  const imports = [];
+  const registrations = [];
+  ids.forEach((id, i) => {
+    const configFile = join5(componentDir(ws, id), "config");
+    const spec = toImportSpecifier(dir, configFile);
+    const local = `config${i}`;
+    imports.push(`import { config as ${local} } from '${spec}'; // ${id}`);
+    registrations.push(`registerPrimitiveOverride(${local} as LocalPrimitiveConfig, OWNER);`);
+  });
+  const source = `// GENERATED by @cueframe/render-harness generateLocalRegistry \u2014 DO NOT EDIT.
+// Side-imports each OWNED component's config and registers it as a local
+// override so resolvePrimitive(id) returns the customer's local code. Lives in
+// the gitignored .cueframe/ cache; regenerated on every local render.
+import { registerPrimitiveOverride, resetPrimitiveOverrides } from '@cueframe/compose';
+${imports.join("\n")}
+
+// The 2.2-generated config.ts is a structural subset of PrimitiveMeta (it omits
+// the agent-surface + playback + preview fields). The renderer only needs
+// id/component/paramsSchema, so we register through this loose shape \u2014 the one
+// named, narrow widening, instead of a per-call cast.
+type LocalPrimitiveConfig = Parameters<typeof registerPrimitiveOverride>[0];
+
+// OWNER = this workspace's identity (the override registry's single-tenant guard,
+// Phase-5 security gate). reset first so a reused render context starts clean;
+// every register is tagged with OWNER so a SECOND tenant registering into a shared
+// process fails loud instead of leaking overrides across tenants.
+const OWNER = ${JSON.stringify(ws.root)};
+resetPrimitiveOverrides();
+${registrations.join("\n")}
+`;
+  const outPath = join5(dir, LOCAL_REGISTRY_FILENAME);
+  writeFileSync(outPath, source);
+  return outPath;
+}
+function generateLocalRoot(ws, opts) {
+  const dir = cacheDir(ws);
+  mkdirSync(dir, { recursive: true });
+  const root = `// GENERATED by @cueframe/render-harness \u2014 DO NOT EDIT.
+import React from 'react';
+import { Composition, getInputProps } from 'remotion';
+import { resolvePrimitive } from '@cueframe/compose';
+import './${LOCAL_REGISTRY_FILENAME}';
+
+const Resolved: React.FC = () => {
+  const params = getInputProps() as Record<string, unknown>;
+  const meta = resolvePrimitive(${JSON.stringify(opts.id)});
+  if (!meta) throw new Error('local primitive did not resolve: ' + ${JSON.stringify(opts.id)});
+  const C = meta.component as React.FC<Record<string, unknown>>;
+  // Canonical agent component contract: ({ durationInFrames, params }) \u2014 matches
+  // director.md's Component Contract AND the desktop DynamicOverlay mount
+  // (<C durationInFrames params={params}/>). NOT a {...params} spread: that left a
+  // contract-conformant component's \`params\` undefined \u2192 crash on params.<x>.
+  return <C durationInFrames={${opts.durationInFrames}} params={params} />;
+};
+
+export const RemotionRoot: React.FC = () => (
+  <Composition
+    id=${JSON.stringify(LOCAL_COMPOSITION_ID)}
+    component={Resolved}
+    durationInFrames={${opts.durationInFrames}}
+    fps={${opts.fps}}
+    width={${opts.width}}
+    height={${opts.height}}
+    defaultProps={{}}
+  />
+);
+`;
+  writeFileSync(join5(dir, LOCAL_ROOT_FILENAME), root);
+  const entry = `// GENERATED by @cueframe/render-harness \u2014 DO NOT EDIT.
+import { registerRoot } from 'remotion';
+import { RemotionRoot } from './${LOCAL_ROOT_FILENAME}';
+registerRoot(RemotionRoot);
+`;
+  const entryPath = join5(dir, LOCAL_ENTRY_FILENAME);
+  writeFileSync(entryPath, entry);
+  return entryPath;
+}
+function buildBoxGlobalsProvideMap(args) {
+  const { renderEntryRoot, specs, animateNames } = args;
+  const globalsModule = join5(renderEntryRoot, "src", "sandbox-globals");
+  const map = {};
+  for (const [name, spec] of Object.entries(specs)) {
+    if (spec.exportName === "default") {
+      map[name] = spec.module;
+      continue;
+    }
+    let mod;
+    if (spec.module === GLOBALS_MODULE) {
+      mod = globalsModule;
+    } else if (spec.module.startsWith(".")) {
+      mod = join5(renderEntryRoot, "src", spec.module.replace(/^\.\//, ""));
+    } else {
+      mod = spec.module;
+    }
+    map[name] = [mod, spec.exportName];
+  }
+  for (const key of animateNames) {
+    map[key] = ["@cueframe/animate", key];
+  }
+  return map;
+}
+function buildLocalWebpackOverride(renderEntryRoot, globals) {
+  const tauriShim = join5(renderEntryRoot, "scripts", "tauri-shim.mjs");
+  const animateAlias = join5(renderEntryRoot, "src", "animateStub.ts");
+  class TauriShimPlugin {
+    shimPath;
+    constructor(shimPath) {
+      this.shimPath = shimPath;
+    }
+    apply(resolver) {
+      const shimPath = this.shimPath;
+      resolver.getHook("resolve").tapAsync("TauriShimPlugin", ((request, ctx, cb) => {
+        if (request.request && /^@tauri-apps\//.test(request.request)) {
+          resolver.doResolve(
+            resolver.getHook("resolve"),
+            { ...request, request: shimPath },
+            null,
+            ctx,
+            cb
+          );
+          return;
+        }
+        cb();
+      }));
+    }
+  }
+  const provideMap = buildBoxGlobalsProvideMap({
+    renderEntryRoot,
+    specs: globals.specs,
+    animateNames: globals.animateNames
+  });
+  const webpack = globals.webpack;
+  if (!webpack || typeof webpack.ProvidePlugin !== "function") {
+    throw new Error(
+      "buildLocalWebpackOverride: webpack.ProvidePlugin unavailable \u2014 the box bundle cannot inject the Remotion sandbox globals (no-import components would fail)."
+    );
+  }
+  return (config) => ({
+    ...config,
+    // Inject the Remotion globals as free identifiers (no-import parity with the
+    // desktop sandbox). ProvidePlugin only fills FREE identifiers, so importing
+    // components are untouched. This sits in the TOP-LEVEL plugins (a compilation
+    // plugin), distinct from resolve.plugins (the TauriShim resolver hook).
+    plugins: [...config.plugins ?? [], new webpack.ProvidePlugin(provideMap)],
+    resolve: {
+      ...config.resolve,
+      // The generated entry/registry/Root + the component live in the workspace's
+      // `.cueframe/` cache and `<componentsDir>/`, which have NO node_modules of
+      // their own — a customer workspace won't install Remotion or the
+      // @cueframe/* packages. They are owned by the render env (`renderEntryRoot`), so
+      // anchor the module search there: every bundled bare specifier (`remotion`,
+      // `react`, `@cueframe/compose`, `zod`) resolves from renderEntryRoot/node_modules.
+      // Transitive deps then resolve from each package's realpath (webpack follows
+      // pnpm symlinks), identical to the in-tree spike bundle.
+      modules: [join5(renderEntryRoot, "node_modules"), ...config.resolve?.modules ?? ["node_modules"]],
+      alias: {
+        ...config.resolve?.alias,
+        "@cueframe/animate": animateAlias,
+        "@": join5(renderEntryRoot, "src")
+      },
+      plugins: [...config.resolve?.plugins ?? [], new TauriShimPlugin(tauriShim)]
+    }
+  });
+}
+async function importFromRenderEntry(renderEntryRoot, spec) {
+  const { createRequire } = await import("module");
+  const { pathToFileURL } = await import("url");
+  const requireFromRenderEntry = createRequire(join5(renderEntryRoot, "package.json"));
+  return await import(pathToFileURL(requireFromRenderEntry.resolve(spec)).href);
+}
+function resolveRenderEntryRoot(override) {
+  if (override) return override;
+  if (process.env.RENDER_ENTRY_ROOT) return process.env.RENDER_ENTRY_ROOT;
+  const here = dirname(fileURLToPath2(import.meta.url));
+  return join5(resolve(here, "..", ".."), "render-entry");
+}
+async function loadSandboxGlobals(renderEntryRoot) {
+  const { pathToFileURL } = await import("url");
+  const { createRequire } = await import("module");
+  let animateNames;
+  if (typeof __BOX_ANIMATE_NAMES_JSON__ !== "undefined") {
+    animateNames = JSON.parse(__BOX_ANIMATE_NAMES_JSON__);
+  } else {
+    const animateStub = join5(renderEntryRoot, "src", "animateStub.ts");
+    const animateMod = await import(pathToFileURL(animateStub).href);
+    animateNames = animateMod.sandboxScopeNames;
+  }
+  const requireFromRenderEntry = createRequire(join5(renderEntryRoot, "package.json"));
+  const bundlerPkg = requireFromRenderEntry.resolve("@remotion/bundler/package.json");
+  const requireFromBundler = createRequire(bundlerPkg);
+  const webpackEntry = requireFromBundler.resolve("webpack");
+  const webpackMod = await import(pathToFileURL(webpackEntry).href);
+  const webpack = webpackMod.default ?? webpackMod;
+  return {
+    // STATICALLY imported SSOT — esbuild inlines it (no runtime .ts spec import).
+    specs: SANDBOX_GLOBAL_SPECS,
+    animateNames,
+    webpack
+  };
+}
+async function prepareLocalBundle(opts) {
+  const renderEntryRoot = resolveRenderEntryRoot(opts.renderEntryRoot);
+  const browserExecutable = process.env.REMOTION_CHROME_EXECUTABLE || void 0;
+  generateLocalRegistry(opts.ws);
+  const entryPoint = generateLocalRoot(opts.ws, {
+    id: opts.id,
+    width: opts.width,
+    height: opts.height,
+    fps: opts.fps,
+    durationInFrames: opts.durationInFrames
+  });
+  const { bundle } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/bundler"
+  );
+  const { specs, animateNames, webpack } = await loadSandboxGlobals(renderEntryRoot);
+  const serveUrl = await bundle({
+    entryPoint,
+    webpackOverride: buildLocalWebpackOverride(renderEntryRoot, { specs, animateNames, webpack })
+  });
+  return { serveUrl, browserExecutable, inputProps: opts.params, renderEntryRoot };
+}
+async function renderComponentStill(opts) {
+  const width = opts.width ?? 1920;
+  const height = opts.height ?? 1080;
+  const fps = opts.fps ?? 30;
+  const durationInFrames = opts.durationInFrames ?? 1;
+  const frame = opts.frame ?? 0;
+  const { serveUrl, browserExecutable, inputProps, renderEntryRoot } = await prepareLocalBundle({
+    ws: opts.ws,
+    id: opts.id,
+    width,
+    height,
+    fps,
+    durationInFrames,
+    params: opts.params,
+    renderEntryRoot: opts.renderEntryRoot
+  });
+  const { selectComposition, renderStill } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/renderer"
+  );
+  const composition = await selectComposition({
+    serveUrl,
+    id: LOCAL_COMPOSITION_ID,
+    inputProps,
+    browserExecutable
+  });
+  const pngPath = join5(cacheDir(opts.ws), `still-${opts.id}.png`);
+  await renderStill({
+    composition,
+    serveUrl,
+    inputProps,
+    output: pngPath,
+    frame,
+    browserExecutable,
+    chromiumOptions: { gl: "swiftshader" },
+    timeoutInMilliseconds: 12e4
+  });
+  return { pngPath };
+}
+function alphaRenderConfig(codec) {
+  return codec === "prores" ? { codec: "prores", proResProfile: "4444", pixelFormat: "yuva444p10le", imageFormat: "png" } : { codec: "vp9", pixelFormat: "yuva420p", imageFormat: "png" };
+}
+function alphaExt(codec) {
+  return codec === "prores" ? "mov" : "webm";
+}
+async function renderComponentAlpha(opts) {
+  const width = opts.width ?? 1920;
+  const height = opts.height ?? 1080;
+  const fps = opts.fps ?? 30;
+  const durationInFrames = opts.durationInFrames ?? fps * 3;
+  const codec = opts.codec ?? "prores";
+  const { serveUrl, browserExecutable, inputProps, renderEntryRoot } = await prepareLocalBundle({
+    ws: opts.ws,
+    id: opts.id,
+    width,
+    height,
+    fps,
+    durationInFrames,
+    params: opts.params,
+    renderEntryRoot: opts.renderEntryRoot
+  });
+  const { selectComposition, renderMedia } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/renderer"
+  );
+  const composition = await selectComposition({
+    serveUrl,
+    id: LOCAL_COMPOSITION_ID,
+    inputProps,
+    browserExecutable
+  });
+  const videoPath = join5(cacheDir(opts.ws), `alpha-${opts.id}.${alphaExt(codec)}`);
+  await renderMedia({
+    composition,
+    serveUrl,
+    inputProps,
+    browserExecutable,
+    outputLocation: videoPath,
+    ...alphaRenderConfig(codec),
+    chromiumOptions: { gl: "swiftshader" },
+    concurrency: 1
+  });
+  return { videoPath };
+}
+
+// ../execution/render-harness/src/cardRender.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+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";
+function generateCardRootSource(opts) {
+  return `// GENERATED by @cueframe/render-harness generateCardRootSource \u2014 DO NOT EDIT.
+import React from 'react';
+import { Composition, AbsoluteFill, getInputProps } from 'remotion';
+
+const Card: React.FC = () => {
+  const { html, cssVars } = getInputProps() as { html: string; cssVars?: Record<string, string> };
+  return (
+    <AbsoluteFill>
+      <div
+        style={{ width: '100%', height: '100%', ...(cssVars ?? {}) }}
+        dangerouslySetInnerHTML={{ __html: html }}
+      />
+    </AbsoluteFill>
+  );
+};
+
+export const RemotionRoot: React.FC = () => (
+  <Composition
+    id=${JSON.stringify(CARD_COMPOSITION_ID)}
+    component={Card}
+    durationInFrames={1}
+    fps={${opts.fps}}
+    width={${opts.width}}
+    height={${opts.height}}
+    defaultProps={{}}
+  />
+);
+`;
+}
+function generateCardEntrySource() {
+  return `// GENERATED by @cueframe/render-harness \u2014 DO NOT EDIT.
+import { registerRoot } from 'remotion';
+import { RemotionRoot } from './${CARD_ROOT_FILENAME}';
+registerRoot(RemotionRoot);
+`;
+}
+function buildCardWebpackOverride(renderEntryRoot) {
+  return (config) => ({
+    ...config,
+    resolve: {
+      ...config.resolve,
+      modules: [join6(renderEntryRoot, "node_modules"), ...config.resolve?.modules ?? ["node_modules"]]
+    }
+  });
+}
+async function renderCardStill(opts) {
+  const width = opts.width ?? 1080;
+  const height = opts.height ?? 1920;
+  const fps = opts.fps ?? 30;
+  const frame = opts.frame ?? 0;
+  const renderEntryRoot = resolveRenderEntryRoot(opts.renderEntryRoot);
+  const browserExecutable = process.env.REMOTION_CHROME_EXECUTABLE || void 0;
+  mkdirSync2(opts.outDir, { recursive: true });
+  writeFileSync2(join6(opts.outDir, CARD_ROOT_FILENAME), generateCardRootSource({ width, height, fps }));
+  const entryPoint = join6(opts.outDir, CARD_ENTRY_FILENAME);
+  writeFileSync2(entryPoint, generateCardEntrySource());
+  const { bundle } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/bundler"
+  );
+  const serveUrl = await bundle({ entryPoint, webpackOverride: buildCardWebpackOverride(renderEntryRoot) });
+  const { selectComposition, renderStill } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/renderer"
+  );
+  const inputProps = { html: opts.html, cssVars: opts.cssVars ?? {} };
+  const composition = await selectComposition({ serveUrl, id: CARD_COMPOSITION_ID, inputProps, browserExecutable });
+  const pngPath = join6(opts.outDir, "card-still.png");
+  await renderStill({
+    composition,
+    serveUrl,
+    inputProps,
+    output: pngPath,
+    frame,
+    browserExecutable,
+    chromiumOptions: { gl: "swiftshader" },
+    timeoutInMilliseconds: 12e4
+  });
+  return { pngPath };
+}
+
+// ../execution/render-harness/src/contractRender.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+var CONTRACT_COMPOSITION_ID = "CueFrameContractFrames";
+var CONTRACT_ROOT_FILENAME = "contract.Root.local.tsx";
+var CONTRACT_ENTRY_FILENAME = "contract.entry.local.tsx";
+function generateContractRootSource(opts) {
+  if (!opts.jsxSource.includes("export default")) {
+    throw new Error(
+      "generateContractRootSource: jsxSource is not contract-shaped \u2014 expected an 'export default function ({ durationInFrames, params })'"
+    );
+  }
+  const transformed = opts.jsxSource.replace(/export\s+default\s+/, "return ");
+  return `// GENERATED by @cueframe/render-harness generateContractRootSource \u2014 DO NOT EDIT.
+import React from 'react';
+import {
+  Composition,
+  AbsoluteFill,
+  getInputProps,
+  useCurrentFrame,
+  useVideoConfig,
+  interpolate,
+  Easing,
+} from 'remotion';
+
+// The contract component, evaluated with the ambient scope above in module
+// scope \u2014 the same identifiers the cloud sandbox injects.
+const ContractComponent = (() => {
+${transformed}
+})();
+
+const Frame: React.FC = () => {
+  const { params, cssVars } = getInputProps() as {
+    params?: Record<string, unknown>;
+    cssVars?: Record<string, string>;
+  };
+  return (
+    <AbsoluteFill>
+      <div style={{ width: '100%', height: '100%', ...(cssVars ?? {}) }}>
+        <ContractComponent durationInFrames={${opts.durationInFrames}} params={params ?? {}} />
+      </div>
+    </AbsoluteFill>
+  );
+};
+
+export const RemotionRoot: React.FC = () => (
+  <Composition
+    id=${JSON.stringify(CONTRACT_COMPOSITION_ID)}
+    component={Frame}
+    durationInFrames={${opts.durationInFrames}}
+    fps={${opts.fps}}
+    width={${opts.width}}
+    height={${opts.height}}
+    defaultProps={{}}
+  />
+);
+`;
+}
+function generateContractEntrySource() {
+  return `// GENERATED by @cueframe/render-harness \u2014 DO NOT EDIT.
+import { registerRoot } from 'remotion';
+import { RemotionRoot } from './${CONTRACT_ROOT_FILENAME}';
+registerRoot(RemotionRoot);
+`;
+}
+async function renderContractFrames(opts) {
+  const width = opts.width ?? 1080;
+  const height = opts.height ?? 1920;
+  const fps = opts.fps ?? 30;
+  const renderEntryRoot = resolveRenderEntryRoot(opts.renderEntryRoot);
+  const browserExecutable = process.env.REMOTION_CHROME_EXECUTABLE || void 0;
+  mkdirSync3(opts.outDir, { recursive: true });
+  writeFileSync3(
+    join7(opts.outDir, CONTRACT_ROOT_FILENAME),
+    generateContractRootSource({
+      jsxSource: opts.jsxSource,
+      width,
+      height,
+      fps,
+      durationInFrames: opts.durationInFrames
+    })
+  );
+  const entryPoint = join7(opts.outDir, CONTRACT_ENTRY_FILENAME);
+  writeFileSync3(entryPoint, generateContractEntrySource());
+  const { bundle } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/bundler"
+  );
+  const serveUrl = await bundle({ entryPoint, webpackOverride: buildCardWebpackOverride(renderEntryRoot) });
+  const { selectComposition, renderStill } = await importFromRenderEntry(
+    renderEntryRoot,
+    "@remotion/renderer"
+  );
+  const inputProps = { params: opts.params ?? {}, cssVars: opts.cssVars ?? {} };
+  const composition = await selectComposition({
+    serveUrl,
+    id: CONTRACT_COMPOSITION_ID,
+    inputProps,
+    browserExecutable
+  });
+  const pngPaths = [];
+  for (const frame of opts.frames) {
+    const pngPath = join7(opts.outDir, `frame-${String(frame).padStart(4, "0")}.png`);
+    await renderStill({
+      composition,
+      serveUrl,
+      inputProps,
+      output: pngPath,
+      frame,
+      browserExecutable,
+      chromiumOptions: { gl: "swiftshader" },
+      timeoutInMilliseconds: 12e4
+    });
+    pngPaths.push(pngPath);
+  }
+  return { pngPaths };
+}
+export {
+  CARD_COMPOSITION_ID,
+  CARD_ENTRY_FILENAME,
+  CARD_ROOT_FILENAME,
+  CONTRACT_COMPOSITION_ID,
+  CONTRACT_ENTRY_FILENAME,
+  CONTRACT_ROOT_FILENAME,
+  LOCAL_COMPOSITION_ID,
+  LOCAL_ENTRY_FILENAME,
+  LOCAL_REGISTRY_FILENAME,
+  LOCAL_ROOT_FILENAME,
+  alphaExt,
+  alphaRenderConfig,
+  assertNoRemoteRefs,
+  assetSlots,
+  assetUrlKey,
+  buildBoxGlobalsProvideMap,
+  buildCardWebpackOverride,
+  buildLocalWebpackOverride,
+  extractSegments,
+  generateCardEntrySource,
+  generateCardRootSource,
+  generateContractEntrySource,
+  generateContractRootSource,
+  generateLocalRegistry,
+  importFromRenderEntry,
+  isRemoteUrl,
+  materializeSources,
+  renderCardStill,
+  renderComponentAlpha,
+  renderComponentStill,
+  renderContractFrames,
+  renderInputAssets,
+  resolveAssets,
+  resolveRenderEntryRoot,
+  startMediaServer
+};