@cueframe/kernel 0.0.1

package/dist/chunk-6CMVBTTP.js

@@ -0,0 +1,1933 @@
+import {
+  CAPTION_BAND_RESERVE,
+  buildEasedZooms,
+  buildPannedCenters
+} from "./chunk-QH3YI3ND.js";
+import {
+  flattenCompoundClips,
+  hasCompoundClips
+} from "./chunk-TWQOKKAF.js";
+import {
+  DOMINANCE_WEIGHTS,
+  ENTER_SEC,
+  LEAVE_SEC,
+  MAX_SUBJECTS,
+  MIN_ZOOM_SHOT_FRAMES,
+  P_MIN,
+  REGION_MEDIAN_SEC,
+  REGION_PAD,
+  SIZE_DOMINANT,
+  SIZE_MIN,
+  ZOOM_MAX,
+  ZOOM_MIN,
+  cameraPath,
+  scoreAndRank,
+  segmentShots,
+  stabilizeSelectionHysteresis
+} from "./chunk-JRQVPFLF.js";
+import {
+  compositionHasVo,
+  roleDefaultGainDb
+} from "./chunk-JMURQODM.js";
+import {
+  SHOT_SCALE_TARGET,
+  shotScaleZoom
+} from "./chunk-WREYUH2E.js";
+import {
+  CueframeError,
+  encodeError
+} from "./chunk-37NJ27UU.js";
+
+// ../execution/core/src/render/emphasis.ts
+function buildEmphasisSet(emphasisWords) {
+  const set = /* @__PURE__ */ new Set();
+  for (const w of emphasisWords) {
+    set.add(`${w.poolItemId}:${w.sourceStart.toFixed(3)}`);
+  }
+  return set;
+}
+function isEmphasized(set, poolItemId, sourceStart) {
+  return set.has(`${poolItemId}:${sourceStart.toFixed(3)}`);
+}
+
+// ../execution/core/src/render/captions.ts
+function sliceTranscriptWords(utterances, fromSec, toSec) {
+  const out = [];
+  for (const utt of utterances) {
+    if (!utt.words || utt.words.length === 0) continue;
+    for (const w of utt.words) {
+      if (w.end <= fromSec) continue;
+      if (w.start >= toSec) continue;
+      const start = Math.max(w.start, fromSec);
+      const end = Math.min(w.end, toSec);
+      const text = (w.text ?? "").trim();
+      if (!text) continue;
+      out.push({
+        text,
+        startMs: Math.round((start - fromSec) * 1e3),
+        endMs: Math.round((end - fromSec) * 1e3)
+      });
+    }
+  }
+  return out;
+}
+function extractCaptionWordsFromDoc(doc, emphasisWords) {
+  const captions = [];
+  const emphasisSet = buildEmphasisSet(emphasisWords);
+  function walk(node) {
+    if (node.type === "timedWord" && node.attrs && !node.attrs.deleted) {
+      const start = node.attrs.start;
+      const end = node.attrs.end;
+      const text = node.content?.[0]?.text ?? "";
+      if (!text.trim()) return;
+      captions.push({
+        text,
+        startMs: start * 1e3,
+        endMs: end * 1e3,
+        emphasis: isEmphasized(emphasisSet, node.attrs.mediaId, node.attrs.sourceStart) || void 0
+      });
+    }
+    if (node.content) {
+      for (const child of node.content) walk(child);
+    }
+  }
+  walk(doc);
+  return captions;
+}
+var SENTENCE_ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "mr",
+  "mrs",
+  "ms",
+  "dr",
+  "prof",
+  "sr",
+  "jr",
+  "st",
+  "rev",
+  "gen",
+  "sen",
+  "gov",
+  "rep",
+  "capt",
+  "sgt",
+  "lt",
+  "col",
+  "vs",
+  "etc",
+  "inc",
+  "ltd",
+  "co",
+  "corp",
+  "mt",
+  "no",
+  "vol",
+  "dept",
+  "fig",
+  "al",
+  "approx"
+]);
+function isSentenceEnd(text) {
+  const t = text.trim();
+  if (/[!?]$/.test(t)) return true;
+  if (!t.endsWith(".")) return false;
+  if (/^(\p{L}\.)+$/u.test(t)) return false;
+  if (SENTENCE_ABBREVIATIONS.has(t.slice(0, -1).toLowerCase())) return false;
+  return true;
+}
+function splitIntoSentences(words) {
+  const segments = [];
+  let current = [];
+  for (const word of words) {
+    current.push(word);
+    if (isSentenceEnd(word.text)) {
+      segments.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+
+// ../execution/core/src/render/bookends.ts
+var CARD_BOOKEND_DEFAULT_MS = 1500;
+var VIDEO_BOOKEND_DEFAULT_MS = 3e3;
+function bookendFrames(bumper, fps) {
+  if (!bumper) return 0;
+  if (bumper.kind !== "card" && bumper.kind !== "video") return 0;
+  if (!Number.isFinite(fps) || fps <= 0) return 0;
+  if (bumper.kind === "video" && (typeof bumper.src !== "string" || bumper.src.length === 0)) {
+    return 0;
+  }
+  const fallbackMs = bumper.kind === "card" ? CARD_BOOKEND_DEFAULT_MS : VIDEO_BOOKEND_DEFAULT_MS;
+  const ms = typeof bumper.durationMs === "number" && Number.isFinite(bumper.durationMs) && bumper.durationMs > 0 ? bumper.durationMs : fallbackMs;
+  const frames2 = Math.round(ms / 1e3 * fps);
+  return frames2 > 0 ? frames2 : 0;
+}
+function resolveBookendTimeline(brandKit, bodyFrames, fps) {
+  const introFrames = bookendFrames(brandKit?.intro, fps);
+  const outroFrames = bookendFrames(brandKit?.outro, fps);
+  const safeBody = Number.isFinite(bodyFrames) && bodyFrames > 0 ? bodyFrames : 0;
+  return {
+    introFrames,
+    outroFrames,
+    bodyStartFrames: introFrames,
+    bodyFrames: safeBody,
+    outroStartFrames: introFrames + safeBody,
+    totalFrames: introFrames + safeBody + outroFrames
+  };
+}
+
+// ../execution/core/src/render/compositionRender.ts
+function projectClipEffects(clip, renderClipId) {
+  const effects = clip.effects;
+  if (!effects || effects.length === 0) return [];
+  return effects.map((e, idx) => ({
+    // Deterministic, unique within the RenderInput: derives from the render-clip
+    // id + the effect's index on the clip (so React keys / clipFrames don't collide).
+    id: `${renderClipId}::effect:${idx}`,
+    primitiveId: e.primitiveId,
+    params: e.params ?? {},
+    target: { kind: "clip", clipId: renderClipId }
+  }));
+}
+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 validateComposition(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("composition: expected object, got " + typeof raw);
+  }
+  const obj = raw;
+  if (obj.v !== 1) {
+    throw new Error("composition.v: expected literal 1");
+  }
+  const fmt = obj.format;
+  if (!fmt || typeof fmt.aspectRatio !== "string") {
+    throw new Error("composition.format.aspectRatio: required string");
+  }
+  if (!Array.isArray(obj.tracks)) {
+    throw new Error("composition.tracks: expected array");
+  }
+  for (let i = 0; i < obj.tracks.length; i++) {
+    const t = obj.tracks[i];
+    if (!t || typeof t !== "object") {
+      throw new Error(`composition.tracks[${i}]: expected object`);
+    }
+    if (typeof t.id !== "string") {
+      throw new Error(`composition.tracks[${i}].id: expected string`);
+    }
+    if (!["video", "audio", "image", "overlay", "effect"].includes(t.kind)) {
+      throw new Error(`composition.tracks[${i}].kind: invalid value`);
+    }
+    if (!Array.isArray(t.contents)) {
+      throw new Error(`composition.tracks[${i}].contents: expected array`);
+    }
+  }
+  if (obj.markers !== void 0 && !Array.isArray(obj.markers)) {
+    throw new Error("composition.markers: expected array when present");
+  }
+  if (obj.captions !== void 0) {
+    const c = obj.captions;
+    if (!c || typeof c !== "object") {
+      throw new Error("composition.captions: expected object when present");
+    }
+    if (!Array.isArray(c.segments)) {
+      throw new Error("composition.captions.segments: expected array");
+    }
+    if (c.style !== void 0 && (typeof c.style !== "object" || c.style === null)) {
+      throw new Error("composition.captions.style: expected object when present");
+    }
+    if (c.style !== void 0) {
+      const fs = c.style.fontSize;
+      if (fs !== void 0 && (typeof fs !== "number" || fs < 1 || fs > 15)) {
+        throw new Error(
+          `composition.captions.style.fontSize: PERCENT of composition height (1-15, default 5) \u2014 got ${String(fs)}. px values are not accepted; a px-intent value renders giant band-overflowing captions. Re-author the style with a percent value.`
+        );
+      }
+    }
+  }
+  return obj;
+}
+function frames(seconds, fps) {
+  return Math.max(0, Math.round(seconds * fps));
+}
+function timelineSpanFrames(startSec, endSec, fps) {
+  const startFrame = frames(startSec, fps);
+  return { startFrame, durationInFrames: Math.max(0, frames(endSec, fps) - startFrame) };
+}
+function mapTransitionType(type) {
+  switch (type) {
+    case "fade":
+    case "dissolve":
+    case "wipe":
+    case "none":
+      return type;
+    case "cut":
+      return "none";
+    default:
+      return "fade";
+  }
+}
+function overlayTransitionFields(c, fps) {
+  return c.transitionIn ? {
+    transitionIn: mapTransitionType(c.transitionIn.type),
+    transitionDurationFrames: Math.max(1, Math.round(c.transitionIn.duration * fps))
+  } : {};
+}
+function rendersNoFrames(c) {
+  return !(c.duration > 0);
+}
+function resolveSrcUrl(mediaId, srcUrls) {
+  const url = srcUrls[mediaId];
+  if (!url) {
+    throw new Error(
+      `Composition references mediaId '${mediaId}' but no presigned URL was supplied. Pre-sign every unique mediaId before calling compositionToRenderInput.`
+    );
+  }
+  return url;
+}
+function playableSpans(trimStart, trimEnd, excluded) {
+  if (!excluded || excluded.length === 0) {
+    return [{ start: trimStart, end: trimEnd }];
+  }
+  const out = [];
+  let cursor = trimStart;
+  for (const r of excluded) {
+    if (r.start > cursor) out.push({ start: cursor, end: r.start });
+    cursor = r.end;
+  }
+  if (cursor < trimEnd) out.push({ start: cursor, end: trimEnd });
+  return out;
+}
+function projectMediaTrack(track, fps, srcUrls, trajectoryUrls, coViewUrls) {
+  const clips = [];
+  const audio = [];
+  const effects = [];
+  for (let i = 0; i < track.contents.length; i++) {
+    const c = track.contents[i];
+    if (!("source" in c) || !c.source) continue;
+    if (c.source.kind !== "media") {
+      throw new Error(
+        `composition.tracks[${track.id}].contents[${i}]: kind=${c.source.kind} is invalid on a ${track.kind} track (expected 'media')`
+      );
+    }
+    if (rendersNoFrames(c)) continue;
+    const src = resolveSrcUrl(c.source.mediaId, srcUrls);
+    if (coViewUrls?.[c.source.mediaId] !== void 0 && c.region !== void 0 && !(c.region.x === 0 && c.region.y === 0 && c.region.w === 1 && c.region.h === 1)) {
+      throw new Error(
+        `composition.tracks[${track.id}].contents[${i}] (clip ${c.id}): a co-view clip (captions-behind-subject) cannot also carry a sub-frame region \u2014 the co-view render path does not honor region. Use one or the other.`
+      );
+    }
+    if (track.kind === "audio") {
+      const trimStart2 = c.source.trim?.start ?? 0;
+      const trimEnd2 = c.source.trim?.end ?? trimStart2 + c.duration;
+      const spans2 = playableSpans(trimStart2, trimEnd2, c.source.excludedRanges);
+      const resolvedVolume = (c.source.volumeDb !== void 0 ? Math.pow(10, c.source.volumeDb / 20) : c.source.volume ?? 1) * (track.volume ?? 1);
+      const fadeInFrames = c.source.fadeInMs !== void 0 ? Math.max(0, Math.round(c.source.fadeInMs / 1e3 * fps)) : void 0;
+      const fadeOutFrames = c.source.fadeOutMs !== void 0 ? Math.max(0, Math.round(c.source.fadeOutMs / 1e3 * fps)) : void 0;
+      let playedSec2 = 0;
+      for (let s = 0; s < spans2.length; s++) {
+        const span = spans2[s];
+        const spanStartSec = c.startTime + playedSec2;
+        playedSec2 += span.end - span.start;
+        const { startFrame, durationInFrames: subDurationFrames } = timelineSpanFrames(
+          spanStartSec,
+          c.startTime + playedSec2,
+          fps
+        );
+        if (subDurationFrames === 0) continue;
+        const sourceInFrames = frames(span.start, fps);
+        audio.push({
+          id: spans2.length === 1 ? c.id : `${c.id}#${s}`,
+          src,
+          sourceInFrames,
+          sourceOutFrames: sourceInFrames + subDurationFrames,
+          startFrame,
+          durationInFrames: subDurationFrames,
+          volume: resolvedVolume,
+          ...fadeInFrames !== void 0 ? { fadeInFrames } : {},
+          ...fadeOutFrames !== void 0 ? { fadeOutFrames } : {},
+          ...c.source.loop !== void 0 ? { loop: c.source.loop } : {}
+        });
+      }
+      continue;
+    }
+    const trimStart = c.source.trim?.start ?? 0;
+    const trimEnd = c.source.trim?.end ?? trimStart + c.duration;
+    const spans = playableSpans(trimStart, trimEnd, c.source.excludedRanges);
+    let firstEmittedSubId;
+    let playedSec = 0;
+    for (let s = 0; s < spans.length; s++) {
+      const span = spans[s];
+      const spanStartSec = c.startTime + playedSec;
+      playedSec += span.end - span.start;
+      const { startFrame: timelineCursorFrames, durationInFrames: subDurationFrames } = timelineSpanFrames(spanStartSec, c.startTime + playedSec, fps);
+      if (subDurationFrames === 0) continue;
+      const sourceInFrames = frames(span.start, fps);
+      const subId = spans.length === 1 ? c.id : `${c.id}#${s}`;
+      if (firstEmittedSubId === void 0) firstEmittedSubId = subId;
+      clips.push({
+        id: subId,
+        src,
+        sourceInFrames,
+        sourceOutFrames: sourceInFrames + subDurationFrames,
+        timelineStartFrames: timelineCursorFrames,
+        durationInFrames: subDurationFrames,
+        // Clip-relative trajectory origin: every sub-span of this clip shares the
+        // clip's trim.start, so the crop can rebase source-absolute span frames
+        // to the clip-relative (trajectory) frame across the excludedRanges gaps.
+        trimStartFrames: frames(trimStart, fps),
+        ...c.source.playbackRate !== void 0 ? { playbackRate: c.source.playbackRate } : {},
+        ...c.source.volume !== void 0 ? { volume: c.source.volume } : {},
+        ...c.source.muted !== void 0 ? { muted: c.source.muted } : {},
+        ...c.source.loop !== void 0 ? { loop: c.source.loop } : {},
+        ...c.opacity !== void 0 ? { opacity: c.opacity } : {},
+        ...c.scale !== void 0 ? { scale: c.scale } : {},
+        ...c.rotation !== void 0 ? { rotation: c.rotation } : {},
+        ...c.animate !== void 0 ? { animate: c.animate } : {},
+        // Output-space placement. A sub-frame `region` makes the clip occupy
+        // only that rect of the output (PiP / split-screen / inset) — lower
+        // tracks show through the uncovered area. Carried per-clip (shared by
+        // every sub-span split from one wire clip). `fit` selects cover/contain.
+        ...c.region !== void 0 ? { region: c.region } : {},
+        ...c.fit !== void 0 ? { fit: c.fit } : {},
+        // Clip transition-in. Attached only to the FIRST span of a clip
+        // (transitions apply between original clips, not split sub-clips).
+        // The canonical `{type,duration}` maps to the render-input string enum
+        // + a frame count; without this the authored transition was dropped
+        // and rendered as a dead hard cut (mirror of tracksToRenderInput.ts).
+        ...s === 0 && c.transitionIn ? {
+          transitionIn: mapTransitionType(c.transitionIn.type),
+          transitionDurationFrames: Math.max(1, Math.round(c.transitionIn.duration * fps))
+        } : {},
+        // Per-frame crop trajectory URL. When present, the renderer
+        // applies the trajectory's per-frame normalized centers as a
+        // CSS transform over the raw video to produce the cropped
+        // output. Keyed by the PARENT wire-clip id `c.id` (NOT the
+        // sub-span `subId`): the trajectory map is per-clip (Phase 2), and
+        // every sub-span split from a clip shares that clip's trajectory.
+        // Resolved at the caller layer (Temporal activity), which looks up
+        // mediaItems.variants[intentHash][aspect].trajectoryR2Key per clip
+        // and presigns it.
+        ...trajectoryUrls?.[c.id] !== void 0 ? { cropTrajectoryUrl: trajectoryUrls[c.id] } : {},
+        // Captions-behind CO-VIEW. Content-driven (Phase 6): the matte gate baked
+        // a crop-independent frame-packed co-view (scene over matte, one opaque
+        // H.264) for any clip whose timeline range overlaps a behind-subject
+        // caption window, surfaced here as coViewUrls[mediaId]. MATTE PRESENCE is
+        // the gate — no per-clip enable flag. The renderer splits the packed
+        // decode into the scene background + the subject cut-out foreground, and
+        // the global caption layer's behind tokens render between them (the
+        // output-space z-split in MainComposition).
+        ...coViewUrls?.[c.source.mediaId] !== void 0 ? { packedUrl: coViewUrls[c.source.mediaId] } : {}
+      });
+    }
+    if (firstEmittedSubId !== void 0) {
+      effects.push(...projectClipEffects(c, firstEmittedSubId));
+    }
+  }
+  for (let i = 1; i < clips.length; i++) {
+    const prev = clips[i - 1];
+    const cur = clips[i];
+    if (prev.src !== cur.src) continue;
+    if ((prev.playbackRate ?? 1) !== (cur.playbackRate ?? 1)) continue;
+    if (JSON.stringify(prev.region) !== JSON.stringify(cur.region)) continue;
+    if ((prev.fit ?? "cover") !== (cur.fit ?? "cover")) continue;
+    if (prev.cropTrajectoryUrl !== cur.cropTrajectoryUrl) continue;
+    if ((prev.trimStartFrames ?? 0) !== (cur.trimStartFrames ?? 0)) continue;
+    const prevEnd = prev.timelineStartFrames + prev.durationInFrames;
+    if (Math.abs(prevEnd - cur.timelineStartFrames) > 1) continue;
+    const parent = prev.parentId ?? prev.id;
+    cur.parentId = parent;
+    if (prev.parentId === void 0) prev.parentId = parent;
+  }
+  return { clips, audio, effects };
+}
+function projectImageTrack(track, fps, srcUrls) {
+  const clips = [];
+  const effects = [];
+  for (let i = 0; i < track.contents.length; i++) {
+    const c = track.contents[i];
+    if (!("source" in c) || !c.source) continue;
+    if (c.source.kind !== "media") {
+      throw new Error(
+        `composition.tracks[${track.id}].contents[${i}]: kind=${c.source.kind} is invalid on an image track (expected 'media')`
+      );
+    }
+    if (rendersNoFrames(c)) continue;
+    const src = resolveSrcUrl(c.source.mediaId, srcUrls);
+    const { startFrame: timelineStartFrames, durationInFrames } = timelineSpanFrames(
+      c.startTime,
+      c.startTime + c.duration,
+      fps
+    );
+    if (durationInFrames === 0) continue;
+    clips.push({
+      id: c.id,
+      src,
+      // Stills have no source timeline — sourceIn/Out are zero. The
+      // renderer keys on mediaType==='image' to skip source-relative
+      // seeking entirely.
+      sourceInFrames: 0,
+      sourceOutFrames: 0,
+      timelineStartFrames,
+      durationInFrames,
+      mediaType: "image",
+      kenBurns: c.source.kenBurns ?? "in",
+      // The agent's authored camera channel for the still. When present it
+      // DRIVES the point-zoom (StillCrop derives the still trajectory from it);
+      // `kenBurns` is the fallback when no reframe was authored. This is how an
+      // image gets an arbitrary point-zoom (zoom into a UI element), not just
+      // the centered kenBurns presets.
+      ...c.source.reframe !== void 0 && c.source.reframe.segments.length > 0 ? { reframe: c.source.reframe } : {},
+      ...c.opacity !== void 0 ? { opacity: c.opacity } : {},
+      ...c.scale !== void 0 ? { scale: c.scale } : {},
+      ...c.rotation !== void 0 ? { rotation: c.rotation } : {},
+      ...c.animate !== void 0 ? { animate: c.animate } : {},
+      // Output-space placement (PiP / inset still). See projectMediaTrack.
+      ...c.region !== void 0 ? { region: c.region } : {},
+      ...c.fit !== void 0 ? { fit: c.fit } : {}
+    });
+    effects.push(...projectClipEffects(c, c.id));
+  }
+  return { clips, effects };
+}
+function clipTransformChannel(c) {
+  if (!("source" in c)) return {};
+  return {
+    ...c.position !== void 0 ? { position: c.position } : {},
+    ...c.opacity !== void 0 ? { opacity: c.opacity } : {},
+    ...c.scale !== void 0 ? { scale: c.scale } : {},
+    ...c.rotation !== void 0 ? { rotation: c.rotation } : {},
+    ...c.animate !== void 0 ? { animate: c.animate } : {}
+  };
+}
+function projectOverlayTrack(track, fps, alphaUrls = {}, jsSourceByClipId = {}) {
+  const overlays = [];
+  for (let i = 0; i < track.contents.length; i++) {
+    const c = track.contents[i];
+    if (!("source" in c) || !c.source) continue;
+    if (c.source.kind === "alpha-layer") {
+      const { startFrame: startFrame2, durationInFrames: durationInFrames2 } = timelineSpanFrames(
+        c.startTime,
+        c.startTime + c.duration,
+        fps
+      );
+      if (durationInFrames2 === 0) continue;
+      const src = alphaUrls[c.id];
+      if (!src) {
+        throw new Error(
+          `composition.tracks[${track.id}].contents[${i}]: alpha-layer clip ${c.id} has no baked alpha (alphaUrls[${c.id}] missing) \u2014 bake before render`
+        );
+      }
+      overlays.push({
+        id: c.id,
+        template: "alpha-layer",
+        startFrame: startFrame2,
+        durationInFrames: durationInFrames2,
+        params: { src },
+        ...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),
+        ...clipTransformChannel(c)
+      });
+      continue;
+    }
+    if (c.source.kind === "card") {
+      const { startFrame: startFrame2, durationInFrames: durationInFrames2 } = timelineSpanFrames(
+        c.startTime,
+        c.startTime + c.duration,
+        fps
+      );
+      if (durationInFrames2 === 0) continue;
+      overlays.push({
+        id: c.id,
+        template: "card",
+        startFrame: startFrame2,
+        durationInFrames: durationInFrames2,
+        params: {
+          html: c.source.html,
+          ...c.source.tokens ? { cssTokens: c.source.tokens } : {}
+        },
+        ...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),
+        ...clipTransformChannel(c)
+      });
+      continue;
+    }
+    if (c.source.kind !== "overlay") {
+      throw new Error(
+        `composition.tracks[${track.id}].contents[${i}]: kind=${c.source.kind} is invalid on an overlay track (expected 'overlay', 'alpha-layer', or 'card')`
+      );
+    }
+    const { startFrame, durationInFrames } = timelineSpanFrames(
+      c.startTime,
+      c.startTime + c.duration,
+      fps
+    );
+    if (durationInFrames === 0) continue;
+    let overlayParams = c.source.params ?? {};
+    if (c.source.primitiveId === "custom") {
+      const fresh = jsSourceByClipId[c.id];
+      const sc = typeof fresh === "string" && fresh.length > 0 ? fresh : overlayParams.sourceCode;
+      if (typeof sc !== "string" || sc.length === 0) {
+        throw new Error(
+          `composition.tracks[${track.id}].contents[${i}].source: custom overlay has no sourceCode (no fresh jsSource for clip '${c.id}' and no inline params.sourceCode) \u2014 mirror code 'custom_missing_sourcecode'`
+        );
+      }
+      const { componentId: _cid, sourceCode: _sc, ...props } = overlayParams;
+      void _cid;
+      void _sc;
+      overlayParams = { sourceCode: sc, ...props };
+    }
+    overlays.push({
+      id: c.id,
+      template: c.source.primitiveId,
+      startFrame,
+      durationInFrames,
+      params: overlayParams,
+      ...c.source.zPlane !== void 0 ? { zPlane: c.source.zPlane } : {},
+      ...c.source.anchor !== void 0 ? { anchor: c.source.anchor } : {},
+      ...c.source.parallax !== void 0 ? { parallax: c.source.parallax } : {},
+      // Output-space placement (clip-level, like media/image): the overlay
+      // primitive occupies only this sub-rect of the output (PiP / inset card).
+      // MainComposition wraps it in the same RegionBox; absent = full frame.
+      ...c.region !== void 0 ? { region: c.region } : {},
+      ...c.fit !== void 0 ? { fit: c.fit } : {},
+      ...overlayTransitionFields(c, fps),
+      ...clipTransformChannel(c)
+    });
+  }
+  return overlays;
+}
+function projectEffectTrack(track, fps) {
+  const effects = [];
+  for (let i = 0; i < track.contents.length; i++) {
+    const c = track.contents[i];
+    if (!("source" in c) || !c.source) continue;
+    if (c.source.kind !== "effect") {
+      throw new Error(
+        `composition.tracks[${track.id}].contents[${i}]: kind=${c.source.kind} is invalid on an effect track (expected 'effect')`
+      );
+    }
+    const { startFrame, durationInFrames } = timelineSpanFrames(
+      c.startTime,
+      c.startTime + c.duration,
+      fps
+    );
+    if (durationInFrames === 0) continue;
+    effects.push({
+      id: c.id,
+      primitiveId: c.source.primitiveId,
+      params: c.source.params ?? {},
+      target: { kind: "global" },
+      startFrame,
+      durationInFrames
+    });
+  }
+  return effects;
+}
+function buildCaptionSpeechSpans(composition, fps) {
+  const words = (composition.captions?.segments ?? []).flatMap((seg) => seg.words).filter((w) => w.endMs > w.startMs).sort((a, b) => a.startMs - b.startMs);
+  if (words.length === 0) return [];
+  const MERGE_GAP_MS = 300;
+  const MIN_SPAN_MS = 200;
+  const spans = [];
+  let cur = { startMs: words[0].startMs, endMs: words[0].endMs };
+  for (let i = 1; i < words.length; i++) {
+    const w = words[i];
+    if (w.startMs - cur.endMs < MERGE_GAP_MS) {
+      if (w.endMs > cur.endMs) cur.endMs = w.endMs;
+    } else {
+      spans.push(cur);
+      cur = { startMs: w.startMs, endMs: w.endMs };
+    }
+  }
+  spans.push(cur);
+  return spans.filter((s) => s.endMs - s.startMs >= MIN_SPAN_MS).map((s) => ({
+    startFrame: Math.round(s.startMs / 1e3 * fps),
+    endFrame: Math.round(s.endMs / 1e3 * fps)
+  }));
+}
+function applyRoleDefaultGains(audioTracks, composition) {
+  let voPresent;
+  for (const track of composition.tracks) {
+    if (track.kind !== "audio" || track.enabled === false) continue;
+    for (const c of track.contents) {
+      if (!("source" in c)) continue;
+      const src = c.source;
+      if (src.kind !== "media") continue;
+      const role = src.audioRole;
+      if (!role) continue;
+      if (src.volumeDb !== void 0 || src.volume !== void 0) continue;
+      if (voPresent === void 0) voPresent = compositionHasVo(composition);
+      const gain = Math.pow(10, roleDefaultGainDb(role, voPresent) / 20);
+      for (const t of audioTracks) {
+        if (t.id === c.id || t.id.startsWith(`${c.id}#`)) t.volume = gain;
+      }
+    }
+  }
+}
+function applyDuckEnvelopes(audioTracks, composition, fps) {
+  const captionSpansFrames = buildCaptionSpeechSpans(composition, fps);
+  for (const track of composition.tracks) {
+    if (track.kind !== "audio" || track.enabled === false) continue;
+    for (const c of track.contents) {
+      if (!("source" in c)) continue;
+      const src = c.source;
+      if (src.kind !== "media") continue;
+      const duck = src.duck;
+      const role = src.audioRole;
+      if (!duck || role !== "music" && role !== "vo") continue;
+      const absWindows = duck.windows && duck.windows.length > 0 ? duck.windows.map((w) => ({
+        startFrame: Math.round(w.startMs / 1e3 * fps),
+        endFrame: Math.round(w.endMs / 1e3 * fps)
+      })) : captionSpansFrames;
+      if (absWindows.length === 0) continue;
+      const duckVolume = Math.pow(10, duck.duckDb / 20);
+      const attackFrames = Math.max(0, Math.round(duck.attackMs / 1e3 * fps));
+      const releaseFrames = Math.max(0, Math.round(duck.releaseMs / 1e3 * fps));
+      for (const t of audioTracks) {
+        if (t.id !== c.id && !t.id.startsWith(`${c.id}#`)) continue;
+        const rel = [];
+        for (const w of absWindows) {
+          const s = Math.max(0, w.startFrame - t.startFrame);
+          const e = Math.min(t.durationInFrames, w.endFrame - t.startFrame);
+          if (e > s) rel.push({ startFrame: s, endFrame: e });
+        }
+        if (rel.length === 0) continue;
+        t.duckWindows = rel;
+        t.duckVolume = duckVolume;
+        t.duckAttackFrames = attackFrames;
+        t.duckReleaseFrames = releaseFrames;
+      }
+    }
+  }
+}
+function referencedMediaIds(composition) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const track of composition.tracks) {
+    for (const c of track.contents) {
+      if (!("source" in c) || !c.source) continue;
+      if (c.source.kind === "media" && typeof c.source.mediaId === "string") {
+        ids.add(c.source.mediaId);
+      }
+    }
+  }
+  return [...ids];
+}
+function componentRefsByClipId(composition) {
+  const refs = {};
+  for (const track of composition.tracks) {
+    if (track.kind !== "overlay") continue;
+    for (const c of track.contents) {
+      if (!("source" in c) || !c.source) continue;
+      const src = c.source;
+      if (src.kind !== "overlay" || src.primitiveId !== "custom") continue;
+      const params = src.params ?? {};
+      if (typeof params.sourceCode === "string" && params.sourceCode.length > 0) continue;
+      if (typeof params.componentId === "string" && params.componentId.length > 0) {
+        refs[c.id] = params.componentId;
+      }
+    }
+  }
+  return refs;
+}
+function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUrls, alphaUrls, jsSourceByClipId, subCompositions) {
+  const flattened = hasCompoundClips(composition) ? flattenCompoundClips(composition, (id) => subCompositions?.[id]) : composition;
+  composition = flattened;
+  const { width, height, fps } = compositionFormatDimensions(composition.format);
+  const clips = [];
+  const overlays = [];
+  const audioTracks = [];
+  const effects = [];
+  for (const track of composition.tracks) {
+    if (track.enabled === false) continue;
+    if (track.kind === "video" || track.kind === "audio") {
+      const { clips: c, audio, effects: clipEffects } = projectMediaTrack(track, fps, srcUrls, trajectoryUrls, coViewUrls);
+      clips.push(...c);
+      audioTracks.push(...audio);
+      effects.push(...clipEffects);
+    } else if (track.kind === "image") {
+      const { clips: c, effects: clipEffects } = projectImageTrack(track, fps, srcUrls);
+      clips.push(...c);
+      effects.push(...clipEffects);
+    } else if (track.kind === "overlay") {
+      overlays.push(...projectOverlayTrack(track, fps, alphaUrls ?? {}, jsSourceByClipId ?? {}));
+    } else if (track.kind === "effect") {
+      effects.push(...projectEffectTrack(track, fps));
+    }
+  }
+  if (audioTracks.length > 0) {
+    applyRoleDefaultGains(audioTracks, composition);
+  }
+  if (audioTracks.length > 0) {
+    applyDuckEnvelopes(audioTracks, composition, fps);
+  }
+  let maxEndFrames = 0;
+  const consider = (start, dur) => {
+    const end = start + dur;
+    if (end > maxEndFrames) maxEndFrames = end;
+  };
+  for (const c of clips) consider(c.timelineStartFrames, c.durationInFrames);
+  for (const o of overlays) consider(o.startFrame, o.durationInFrames);
+  for (const a of audioTracks) consider(a.startFrame, a.durationInFrames);
+  for (const e of effects) {
+    consider(e.startFrame ?? 0, e.durationInFrames ?? 0);
+  }
+  const SCENE_OVERLAY_TEMPLATES = /* @__PURE__ */ new Set(["alpha-layer", "custom", "card"]);
+  let maxBackgroundEndFrames = 0;
+  for (const c of clips) {
+    const end = c.timelineStartFrames + c.durationInFrames;
+    if (end > maxBackgroundEndFrames) maxBackgroundEndFrames = end;
+  }
+  for (const o of overlays) {
+    if (!SCENE_OVERLAY_TEMPLATES.has(o.template)) continue;
+    const end = o.startFrame + o.durationInFrames;
+    if (end > maxBackgroundEndFrames) maxBackgroundEndFrames = end;
+  }
+  const bodyDurationInFrames = maxBackgroundEndFrames > 0 ? Math.min(maxEndFrames, maxBackgroundEndFrames) : maxEndFrames;
+  const captionSegments = composition.captions?.segments.map((seg) => seg.words).filter((words) => words.length > 0);
+  const brandKit = composition.brandKit;
+  const { totalFrames: durationInFrames } = resolveBookendTimeline(
+    brandKit,
+    bodyDurationInFrames,
+    fps
+  );
+  const cap = brandKit?.caption;
+  const brandAccent = cap?.fg ?? brandKit?.colors?.accent;
+  const mot = brandKit?.motion;
+  const ANIMATED_CAPTION_ENTRANCES = ["fade", "word-pop", "stagger-up"];
+  const captionEntrance = ANIMATED_CAPTION_ENTRANCES.includes(
+    mot?.entrance
+  ) ? mot.entrance : void 0;
+  const captionMotion = captionEntrance ? {
+    entrance: captionEntrance,
+    ...mot.duration != null ? { entranceMs: mot.duration } : {},
+    ...mot.staggerMs != null ? { entranceStaggerMs: mot.staggerMs } : {},
+    ...mot.exitMs != null ? { exitMs: mot.exitMs } : {}
+  } : void 0;
+  const baseStyle = composition.captions?.style;
+  const hasCaptions = captionSegments != null && captionSegments.length > 0;
+  const captionStyle = hasCaptions && (cap || baseStyle || captionMotion) ? {
+    ...baseStyle ?? {},
+    ...cap?.fontFamily ? { fontFamily: cap.fontFamily } : {},
+    ...cap?.color ? { color: cap.color } : {},
+    ...cap?.plate ? { plate: cap.plate } : {},
+    ...cap?.emphasisFontFamily ? { emphasisFontFamily: cap.emphasisFontFamily } : {},
+    ...cap?.emphasisScale != null ? { emphasisScale: cap.emphasisScale } : {},
+    ...cap?.emphasisFontWeight != null ? { emphasisFontWeight: cap.emphasisFontWeight } : {},
+    ...cap?.emphasisFontStyle ? { emphasisFontStyle: cap.emphasisFontStyle } : {},
+    ...cap?.emphasisTextTransform ? { emphasisTextTransform: cap.emphasisTextTransform } : {},
+    ...cap?.emphasisLetterSpacing != null ? { emphasisLetterSpacing: cap.emphasisLetterSpacing } : {},
+    ...cap?.emphasisPlate != null ? { emphasisPlate: cap.emphasisPlate } : {},
+    ...cap?.emphasisPlateColor ? { emphasisPlateColor: cap.emphasisPlateColor } : {},
+    ...cap?.emphasisPlateTextColor ? { emphasisPlateTextColor: cap.emphasisPlateTextColor } : {},
+    // Brand accent → active/emphasis word color (today's behavior); a
+    // creator-set caption highlightColor is caption-specific identity and
+    // WINS over the generic accent.
+    ...brandAccent ? { highlightColor: brandAccent, emphasisColor: brandAccent } : {},
+    ...cap?.highlightColor ? { highlightColor: cap.highlightColor } : {},
+    // Brand-motion-derived caption entrance is the generic fallback; a
+    // caption-specific entrance (cap.*) is identity and WINS, so it spreads
+    // AFTER captionMotion.
+    ...captionMotion ?? {},
+    ...cap?.entrance ? { entrance: cap.entrance } : {},
+    ...cap?.entranceMs != null ? { entranceMs: cap.entranceMs } : {},
+    ...cap?.entranceStaggerMs != null ? { entranceStaggerMs: cap.entranceStaggerMs } : {},
+    ...cap?.exitMs != null ? { exitMs: cap.exitMs } : {}
+  } : void 0;
+  return {
+    clips,
+    overlays,
+    width,
+    height,
+    fps,
+    durationInFrames,
+    // Target platform (from the wire `Format`) frozen onto the render input so the
+    // composition floor's safe-zone placement clears that surface's UI chrome.
+    // Absent ⇒ the floor's 'unknown' (broadcast) default. Output-determining, so
+    // it's part of the render cache key (RENDER_CACHE_VERSION bumped alongside).
+    ...composition.format.platform !== void 0 ? { platform: composition.format.platform } : {},
+    ...audioTracks.length > 0 ? { audioTracks } : {},
+    ...effects.length > 0 ? { effects } : {},
+    ...hasCaptions ? { captionSegments } : {},
+    ...captionStyle ? { captionStyle } : {},
+    ...brandKit ? { brandKit } : {}
+    // (fitMode deleted 2026-05-25 — baked variants replace render-time fit
+    // decisions; the chosen variant URL IS the framing.)
+  };
+}
+function assembleRenderInput(composition, resolved) {
+  const renderInput = compositionToRenderInput(
+    composition,
+    resolved.srcUrls,
+    resolved.trajectoryUrls ?? {},
+    resolved.coViewUrls ?? {},
+    resolved.alphaUrls ?? {},
+    resolved.jsSourceByClipId ?? {}
+  );
+  if (renderInput.brandKit && resolved.fontAssets && resolved.fontAssets.length > 0) {
+    renderInput.brandKit.fontAssets = resolved.fontAssets;
+  }
+  return renderInput;
+}
+
+// ../execution/core/src/render/exportSettings.ts
+var DEFAULT_FPS = 30;
+var DEFAULT_WIDTH = 1920;
+var DEFAULT_HEIGHT = 1080;
+var DEFAULT_RENDER_SETTINGS = {
+  format: "source",
+  quality: "source",
+  resolution: "source",
+  watermark: false,
+  captionsEnabled: true
+};
+var FORMAT_PRESETS = {
+  "16:9": { label: "Landscape", aspectWidth: 16, aspectHeight: 9 },
+  "9:16": { label: "TikTok / Reels", aspectWidth: 9, aspectHeight: 16 },
+  "4:5": { label: "Instagram Portrait", aspectWidth: 4, aspectHeight: 5 },
+  "1:1": { label: "Square", aspectWidth: 1, aspectHeight: 1 }
+};
+var RESOLUTION_PRESETS = {
+  "1080p": { label: "1080p (Full HD)", height: 1080 },
+  "1440p": { label: "1440p (2K)", height: 1440 },
+  "4k": { label: "4K (Ultra HD)", height: 2160 }
+};
+var BPP = {
+  maximum: 0.3,
+  social: 0.15,
+  web: 0.08,
+  potato: 0.04
+};
+function bppToCrf(bpp) {
+  return Math.max(15, Math.min(36, Math.round(51 - bpp * 120)));
+}
+function computeExportDimensions(sourceWidth, sourceHeight, format, quality) {
+  let w;
+  let h;
+  if (format === "source") {
+    w = sourceWidth;
+    h = sourceHeight;
+  } else {
+    const preset = FORMAT_PRESETS[format];
+    const shortEdge = Math.min(sourceWidth, sourceHeight);
+    const minAspect = Math.min(preset.aspectWidth, preset.aspectHeight);
+    w = Math.round(shortEdge * (preset.aspectWidth / minAspect));
+    h = Math.round(shortEdge * (preset.aspectHeight / minAspect));
+  }
+  w = w % 2 === 0 ? w : w + 1;
+  h = h % 2 === 0 ? h : h + 1;
+  if (quality === "source") {
+    return { width: w, height: h, crf: void 0 };
+  }
+  const bpp = BPP[quality];
+  if (bpp === void 0) return { width: w, height: h, crf: void 0 };
+  return { width: w, height: h, crf: bppToCrf(bpp) };
+}
+function ensureEven(n) {
+  return n % 2 === 0 ? n : n + 1;
+}
+
+// ../execution/core/src/render/vcam/subjectSet.ts
+function median(xs, fallback = 0) {
+  if (xs.length === 0) return fallback;
+  const s = [...xs].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+}
+function shotStats(perFrameTracked, srcW, srcH, perKeyframeSpeaker, shot) {
+  const shotLen = shot.end - shot.start;
+  const heights = /* @__PURE__ */ new Map();
+  const centralities = /* @__PURE__ */ new Map();
+  const present = /* @__PURE__ */ new Map();
+  for (let i = shot.start; i < shot.end; i++) {
+    const tracked = i < perFrameTracked.length ? perFrameTracked[i] : {};
+    for (const [fid, b] of Object.entries(tracked)) {
+      if (!b || b.length < 4) continue;
+      const [x1, y1, x2, y2] = b;
+      const hFrac = Math.max(0, y2 - y1) / srcH;
+      const cx = (x1 + x2) / 2 / srcW;
+      const cy = (y1 + y2) / 2 / srcH;
+      const dist = Math.hypot(cx - 0.5, cy - 0.5);
+      const centrality = Math.max(0, 1 - dist);
+      if (!heights.has(fid)) {
+        heights.set(fid, []);
+        centralities.set(fid, []);
+        present.set(fid, 0);
+      }
+      heights.get(fid).push(hFrac);
+      centralities.get(fid).push(centrality);
+      present.set(fid, present.get(fid) + 1);
+    }
+  }
+  const shotPicks = [];
+  for (const [kf, fid] of perKeyframeSpeaker) {
+    if (kf >= shot.start && kf < shot.end) shotPicks.push(fid);
+  }
+  const speakCount = /* @__PURE__ */ new Map();
+  for (const fid of shotPicks) speakCount.set(fid, (speakCount.get(fid) ?? 0) + 1);
+  const out = /* @__PURE__ */ new Map();
+  for (const fid of heights.keys()) {
+    out.set(fid, {
+      persistence: shotLen > 0 ? present.get(fid) / shotLen : 0,
+      sizeMed: median(heights.get(fid)),
+      centralityMed: median(centralities.get(fid)),
+      speaking: shotPicks.length > 0 ? (speakCount.get(fid) ?? 0) / shotPicks.length : 0
+    });
+  }
+  return out;
+}
+function passesGate(s) {
+  if (s.sizeMed < SIZE_MIN) return false;
+  if (s.persistence < P_MIN && s.sizeMed < SIZE_DOMINANT) return false;
+  return true;
+}
+function statsToSignals(s) {
+  return {
+    size: { value: s.sizeMed },
+    centrality: { value: s.centralityMed },
+    persistence: { value: s.persistence },
+    speaking: { value: s.speaking }
+  };
+}
+function segStats(perFrameTracked, srcW, srcH, perKeyframeSpeaker, ids) {
+  const n = perFrameTracked.length;
+  const heights = /* @__PURE__ */ new Map();
+  const widths = /* @__PURE__ */ new Map();
+  const cxs = /* @__PURE__ */ new Map();
+  const cys = /* @__PURE__ */ new Map();
+  const centralities = /* @__PURE__ */ new Map();
+  const present = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const tracked = perFrameTracked[i] ?? {};
+    for (const [fid, b] of Object.entries(tracked)) {
+      if (!ids.has(fid) || !b || b.length < 4) continue;
+      const [x1, y1, x2, y2] = b;
+      const hFrac = Math.max(0, y2 - y1) / srcH;
+      const wFrac = Math.max(0, x2 - x1) / srcW;
+      const cx = (x1 + x2) / 2 / srcW;
+      const cy = (y1 + y2) / 2 / srcH;
+      const centrality = Math.max(0, 1 - Math.hypot(cx - 0.5, cy - 0.5));
+      if (!heights.has(fid)) {
+        heights.set(fid, []);
+        widths.set(fid, []);
+        cxs.set(fid, []);
+        cys.set(fid, []);
+        centralities.set(fid, []);
+        present.set(fid, 0);
+      }
+      heights.get(fid).push(hFrac);
+      widths.get(fid).push(wFrac);
+      cxs.get(fid).push(cx);
+      cys.get(fid).push(cy);
+      centralities.get(fid).push(centrality);
+      present.set(fid, present.get(fid) + 1);
+    }
+  }
+  const speakCount = /* @__PURE__ */ new Map();
+  let totalPicks = 0;
+  for (const fid of perKeyframeSpeaker.values()) {
+    if (!ids.has(fid)) continue;
+    speakCount.set(fid, (speakCount.get(fid) ?? 0) + 1);
+  }
+  totalPicks += perKeyframeSpeaker.size;
+  const out = /* @__PURE__ */ new Map();
+  for (const fid of heights.keys()) {
+    const wMed = median(widths.get(fid));
+    const hMed = median(heights.get(fid));
+    out.set(fid, {
+      sizeMed: hMed,
+      centralityMed: median(centralities.get(fid)),
+      persistence: n > 0 ? present.get(fid) / n : 0,
+      speaking: totalPicks > 0 ? (speakCount.get(fid) ?? 0) / totalPicks : 0,
+      reprCx: median(cxs.get(fid), 0.5),
+      reprCy: median(cys.get(fid), 0.5),
+      reprArea: Math.max(1e-6, wMed * hMed)
+    });
+  }
+  return out;
+}
+function selectSubjectSet(perFrameTracked, srcW, srcH, fps, perKeyframeSpeaker, interiorCuts) {
+  const n = perFrameTracked.length;
+  const centerHold = () => ({
+    centers: Array.from({ length: n }, () => [0.5, 0.5]),
+    perFrameBoxes: Array.from({ length: n }, () => null),
+    framedIds: [],
+    resolvedFrames: 0
+  });
+  if (n === 0 || srcW <= 0 || srcH <= 0) return centerHold();
+  const shots = segmentShots(interiorCuts, n);
+  const pool = /* @__PURE__ */ new Set();
+  for (const shot of shots) {
+    const stats = shotStats(perFrameTracked, srcW, srcH, perKeyframeSpeaker, shot);
+    for (const [fid, s] of stats) {
+      if (passesGate(s)) pool.add(fid);
+    }
+  }
+  if (pool.size === 0) return centerHold();
+  const seg = segStats(perFrameTracked, srcW, srcH, perKeyframeSpeaker, pool);
+  const ranked = scoreAndRank(
+    [...pool].map((id) => ({ id, signals: statsToSignals(seg.get(id)) })),
+    DOMINANCE_WEIGHTS
+  ).map((s) => s.candidateId);
+  const framedIds = ranked.slice(0, MAX_SUBJECTS);
+  const enterFrames = Math.max(1, Math.round(ENTER_SEC * fps));
+  const leaveFrames = Math.max(1, Math.round(LEAVE_SEC * fps));
+  const { inThisFrame, everIn, usedFallback } = stabilizeSelectionHysteresis(
+    framedIds,
+    (id, i) => !!(perFrameTracked[i] ?? {})[id],
+    n,
+    { enterFrames, leaveFrames }
+  );
+  let resolvedFrames = 0;
+  for (let i = 0; i < n; i++) if (inThisFrame[i].length > 0) resolvedFrames++;
+  const groupIds = everIn.size > 0 ? [...everIn] : framedIds;
+  const perFrameBoxes = new Array(n).fill(null);
+  const rawCenters = new Array(n).fill(null);
+  for (let i = 0; i < n; i++) {
+    const tracked = perFrameTracked[i] ?? {};
+    const ids = usedFallback ? framedIds.filter((id) => tracked[id]) : inThisFrame[i];
+    if (ids.length === 0) continue;
+    let x1 = Infinity;
+    let y1 = Infinity;
+    let x2 = -Infinity;
+    let y2 = -Infinity;
+    let area = 0;
+    let cxAcc = 0;
+    let cyAcc = 0;
+    for (const id of ids) {
+      const b = tracked[id];
+      const [bx1, by1, bx2, by2] = b;
+      const nx1 = bx1 / srcW;
+      const ny1 = by1 / srcH;
+      const nx2 = bx2 / srcW;
+      const ny2 = by2 / srcH;
+      if (nx1 < x1) x1 = nx1;
+      if (ny1 < y1) y1 = ny1;
+      if (nx2 > x2) x2 = nx2;
+      if (ny2 > y2) y2 = ny2;
+      const w = Math.max(0, nx2 - nx1);
+      const h = Math.max(0, ny2 - ny1);
+      const a = Math.max(1e-6, w * h);
+      cxAcc += (nx1 + nx2) / 2 * a;
+      cyAcc += (ny1 + ny2) / 2 * a;
+      area += a;
+    }
+    perFrameBoxes[i] = [x1, y1, x2, y2];
+    rawCenters[i] = area > 0 ? [cxAcc / area, cyAcc / area] : null;
+  }
+  const firstKnown = rawCenters.find((c) => c !== null) ?? null;
+  let fallback = [0.5, 0.5];
+  if (firstKnown === null) {
+    let totalArea = 0;
+    let reprCxAcc = 0;
+    let reprCyAcc = 0;
+    for (const id of groupIds) {
+      const s = seg.get(id);
+      reprCxAcc += s.reprCx * s.reprArea;
+      reprCyAcc += s.reprCy * s.reprArea;
+      totalArea += s.reprArea;
+    }
+    if (totalArea > 0) fallback = [reprCxAcc / totalArea, reprCyAcc / totalArea];
+  }
+  const centers = new Array(n);
+  let last = firstKnown ?? fallback;
+  for (let i = 0; i < n; i++) {
+    if (rawCenters[i] !== null) last = rawCenters[i];
+    centers[i] = [last[0], last[1]];
+  }
+  return {
+    centers,
+    perFrameBoxes,
+    framedIds: groupIds,
+    resolvedFrames: resolvedFrames > 0 ? resolvedFrames : n
+  };
+}
+function largestFaceId(tracked) {
+  let bestArea = -1;
+  let bestId = null;
+  for (const [id, b] of Object.entries(tracked)) {
+    if (!b || b.length < 4) continue;
+    const area = Math.max(0, b[2] - b[0]) * Math.max(0, b[3] - b[1]);
+    if (area > bestArea) {
+      bestArea = area;
+      bestId = id;
+    }
+  }
+  return bestId;
+}
+function selectSingleSubjectBoxes(perFrameTracked, srcW, srcH, perKeyframeSpeaker, pick, nearestSpeaker) {
+  const n = perFrameTracked.length;
+  const perFrameBoxes = new Array(n).fill(null);
+  if (srcW <= 0 || srcH <= 0) return { perFrameBoxes, resolvedFrames: 0 };
+  const authoredFaceId = pick.kind === "face" && pick.authoredFaceId.startsWith("face-") ? pick.authoredFaceId : null;
+  let resolvedFrames = 0;
+  for (let i = 0; i < n; i++) {
+    const tracked = perFrameTracked[i] ?? {};
+    if (Object.keys(tracked).length === 0) continue;
+    let chosenId = null;
+    if (pick.kind === "active-speaker" && perKeyframeSpeaker.size > 0) {
+      const sp = nearestSpeaker(i);
+      if (sp && tracked[sp]) chosenId = sp;
+    }
+    if (chosenId === null) {
+      chosenId = authoredFaceId !== null ? tracked[authoredFaceId] ? authoredFaceId : null : largestFaceId(tracked);
+    }
+    if (chosenId === null) continue;
+    const b = tracked[chosenId];
+    if (!b || b.length < 4) continue;
+    const [x1, y1, x2, y2] = b;
+    perFrameBoxes[i] = [x1 / srcW, y1 / srcH, x2 / srcW, y2 / srcH];
+    resolvedFrames++;
+  }
+  return { perFrameBoxes, resolvedFrames };
+}
+
+// ../execution/core/src/render/vcam/requiredRegion.ts
+function padBox(box, pad = REGION_PAD) {
+  const [x1, y1, x2, y2] = box;
+  const px1 = Math.max(0, Math.min(1, x1 - pad));
+  const py1 = Math.max(0, Math.min(1, y1 - pad));
+  const px2 = Math.max(0, Math.min(1, x2 + pad));
+  const py2 = Math.max(0, Math.min(1, y2 + pad));
+  return {
+    cx: (px1 + px2) / 2,
+    cy: (py1 + py2) / 2,
+    w: Math.max(0, px2 - px1),
+    h: Math.max(0, py2 - py1)
+  };
+}
+function regionsFromBoxes(boxes, pad = REGION_PAD) {
+  return boxes.map((b) => b === null ? null : padBox(b, pad));
+}
+function med(xs) {
+  const s = [...xs].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+}
+function medianFilterRegions(regions, r, shotStart, shotEnd) {
+  const out = [...regions];
+  if (r < 1) return out;
+  for (let i = shotStart; i < shotEnd; i++) {
+    if (regions[i] === null) continue;
+    const lo = Math.max(shotStart, i - r);
+    const hi = Math.min(shotEnd - 1, i + r);
+    const cx = [];
+    const cy = [];
+    const w = [];
+    const h = [];
+    for (let j = lo; j <= hi; j++) {
+      const rj = regions[j];
+      if (rj === null) continue;
+      cx.push(rj.cx);
+      cy.push(rj.cy);
+      w.push(rj.w);
+      h.push(rj.h);
+    }
+    if (cx.length === 0) continue;
+    out[i] = { cx: med(cx), cy: med(cy), w: med(w), h: med(h) };
+  }
+  return out;
+}
+function buildRequiredRegions(boxes, fps, interiorCuts, pad = REGION_PAD) {
+  const padded = regionsFromBoxes(boxes, pad);
+  const r = Math.round(REGION_MEDIAN_SEC * fps);
+  if (r < 1) return padded;
+  let out = padded;
+  for (const shot of segmentShots(interiorCuts, padded.length)) {
+    out = medianFilterRegions(out, r, shot.start, shot.end);
+  }
+  return out;
+}
+
+// ../execution/core/src/render/vcam/framing.ts
+function shotUnionExtent(boxes, start, end, pad = REGION_PAD) {
+  let x1 = Infinity;
+  let y1 = Infinity;
+  let x2 = -Infinity;
+  let y2 = -Infinity;
+  let any = false;
+  for (let i = start; i < end; i++) {
+    const b = i >= 0 && i < boxes.length ? boxes[i] : null;
+    if (!b) continue;
+    any = true;
+    if (b[0] < x1) x1 = b[0];
+    if (b[1] < y1) y1 = b[1];
+    if (b[2] > x2) x2 = b[2];
+    if (b[3] > y2) y2 = b[3];
+  }
+  if (!any) return null;
+  const px1 = Math.max(0, x1 - pad);
+  const py1 = Math.max(0, y1 - pad);
+  const px2 = Math.min(1, x2 + pad);
+  const py2 = Math.min(1, y2 + pad);
+  return { w: Math.max(0, px2 - px1), h: Math.max(0, py2 - py1) };
+}
+function fitZoom(extent, srcW, srcH, aspect) {
+  if (extent === null || extent.w <= 0 || extent.h <= 0) {
+    return { zoom: ZOOM_MAX, overframed: false };
+  }
+  const base = cropWindowSizeFor(srcW, srcH, ZOOM_MAX, aspect);
+  if (base.w <= 0 || base.h <= 0) return { zoom: ZOOM_MAX, overframed: false };
+  const needed = Math.max(extent.w / base.w, extent.h / base.h);
+  if (needed > ZOOM_MAX) {
+    return { zoom: ZOOM_MAX, overframed: true };
+  }
+  return { zoom: Math.max(ZOOM_MIN, needed), overframed: false };
+}
+function fitZoomPerShot(boxes, interiorCuts, srcW, srcH, aspect, fps, segLen, pad = REGION_PAD) {
+  const shots = segmentShots(interiorCuts, segLen);
+  const minLen = Math.max(1, Math.round(MIN_ZOOM_SHOT_FRAMES * fps));
+  const out = [];
+  let prev = null;
+  for (const shot of shots) {
+    const shotLen = shot.end - shot.start;
+    if (prev !== null && shotLen < minLen) {
+      out.push({ zoom: prev.zoom, overframed: prev.overframed });
+      continue;
+    }
+    const extent = shotUnionExtent(boxes, shot.start, shot.end, pad);
+    const fit = fitZoom(extent, srcW, srcH, aspect);
+    out.push(fit);
+    prev = fit;
+  }
+  return out;
+}
+
+// ../execution/core/src/render/deriveTrajectory.ts
+function faceArea(face) {
+  return Math.max(0, face.width) * Math.max(0, face.height);
+}
+function resolveSubjectFaces(faces, subject) {
+  if (faces.length === 0) return faces;
+  if (subject.kind === "all-faces") return faces;
+  if (subject.kind === "frame-center") return [];
+  if (subject.kind === "point") return [];
+  if (subject.kind === "face") {
+    const faceId = subject.faceId;
+    if (typeof faceId !== "string" || faceId === "" || !faceId.startsWith("face-")) {
+      const ranked = [...faces].sort((a, b) => faceArea(b) - faceArea(a));
+      return ranked.slice(0, 1);
+    }
+    const match = faces.find((f) => f.faceId === faceId);
+    return match ? [match] : [];
+  }
+  throw new Error(`unknown_subject_kind: ${subject.kind}`);
+}
+function selectedFaceCenter(faces, subject) {
+  if (subject.kind === "frame-center") return null;
+  if (subject.kind === "point") return [subject.x, subject.y];
+  if (faces.length === 0) return null;
+  const selected = resolveSubjectFaces(faces, subject);
+  if (selected.length === 0) return null;
+  let totalArea = 0;
+  let cxAcc = 0;
+  let cyAcc = 0;
+  for (const f of selected) {
+    const area = faceArea(f) || 1e-6;
+    cxAcc += (f.x + f.width / 2) * area;
+    cyAcc += (f.y + f.height / 2) * area;
+    totalArea += area;
+  }
+  return [cxAcc / totalArea, cyAcc / totalArea];
+}
+var JUMP_THRESHOLD = 0.15;
+var MIN_SUBJECT_RESOLUTION = 0.4;
+function isJump(a, b) {
+  return Math.abs(a[0] - b[0]) > JUMP_THRESHOLD || Math.abs(a[1] - b[1]) > JUMP_THRESHOLD;
+}
+function emaSmooth(centers, alpha = 0.4, cutFrames) {
+  const n = centers.length;
+  if (n === 0) return [];
+  const isCut = (i2) => cutFrames?.has(i2) ?? false;
+  const fillFirst = centers.find((c) => c !== null) ?? [0.5, 0.5];
+  const filled = new Array(n);
+  let lastVal = fillFirst;
+  let i = 0;
+  while (i < n) {
+    if (centers[i] !== null) {
+      lastVal = centers[i];
+      filled[i] = lastVal;
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < n && centers[j] === null) j++;
+    const nextVal = j < n ? centers[j] : lastVal;
+    let cut = -1;
+    if (cutFrames) {
+      for (let k = i; k <= j; k++) {
+        if (isCut(k)) {
+          cut = k;
+          break;
+        }
+      }
+    }
+    if (cut >= 0) {
+      for (let k = i; k < j; k++) filled[k] = k < cut ? lastVal : nextVal;
+    } else {
+      for (let k = i; k < j; k++) filled[k] = lastVal;
+    }
+    i = j;
+  }
+  const forward = [filled[0]];
+  for (let i2 = 1; i2 < n; i2++) {
+    const prev = forward[i2 - 1];
+    const curr = filled[i2];
+    if (isCut(i2)) {
+      forward.push(curr);
+    } else {
+      forward.push([
+        alpha * curr[0] + (1 - alpha) * prev[0],
+        alpha * curr[1] + (1 - alpha) * prev[1]
+      ]);
+    }
+  }
+  const final = new Array(n);
+  final[n - 1] = forward[n - 1];
+  for (let i2 = n - 2; i2 >= 0; i2--) {
+    const nxt = final[i2 + 1];
+    const curr = forward[i2];
+    if (isCut(i2 + 1)) {
+      final[i2] = curr;
+    } else {
+      final[i2] = [
+        alpha * curr[0] + (1 - alpha) * nxt[0],
+        alpha * curr[1] + (1 - alpha) * nxt[1]
+      ];
+    }
+  }
+  return final;
+}
+function clip01(v) {
+  return Math.max(0, Math.min(1, v));
+}
+function captionBandReserve(aspect) {
+  return CAPTION_BAND_RESERVE[aspect] ?? 0;
+}
+function aspectWhRatio(aspect) {
+  const parts = aspect.split(":");
+  const w = Number(parts[0]);
+  const h = Number(parts[1]);
+  if (parts.length !== 2 || !Number.isFinite(w) || !Number.isFinite(h) || w <= 0 || h === 0) {
+    throw new Error(`aspectWhRatio: invalid aspect ratio '${aspect}' (expected 'W:H')`);
+  }
+  return w / h;
+}
+function cropWindowSizeFor(srcW, srcH, zoomScale, aspect) {
+  if (srcW <= 0 || srcH <= 0) return { w: 1, h: 1 };
+  const outAR = aspectWhRatio(aspect);
+  const srcAR = srcW / srcH;
+  let cropW;
+  let cropH;
+  if (srcAR > outAR) {
+    cropH = srcH;
+    cropW = srcH * outAR;
+  } else {
+    cropW = srcW;
+    cropH = srcW / outAR;
+  }
+  const bakedZoom = Math.max(0.4, Math.min(1, zoomScale));
+  cropW *= bakedZoom;
+  cropH *= bakedZoom;
+  return { w: cropW / srcW, h: cropH / srcH };
+}
+function nearestKpValue(d, key) {
+  if (d.size === 0) return null;
+  const keys = [...d.keys()];
+  const preceding = keys.filter((k) => k <= key);
+  if (preceding.length > 0) return d.get(Math.max(...preceding)) ?? null;
+  return d.get(Math.min(...keys)) ?? null;
+}
+function activeWindowsFor(faceId, perKeyframeSpeaker, frameCount) {
+  if (perKeyframeSpeaker.size === 0) return [];
+  const kfs = [...perKeyframeSpeaker.keys()].sort((a, b) => a - b);
+  const windows = [];
+  for (let j = 0; j < kfs.length; j++) {
+    const kf = kfs[j];
+    if (perKeyframeSpeaker.get(kf) !== faceId) continue;
+    const start = kf;
+    const end = j + 1 < kfs.length ? kfs[j + 1] : frameCount;
+    const last = windows[windows.length - 1];
+    if (last && last[1] === start) last[1] = end;
+    else windows.push([start, end]);
+  }
+  return windows;
+}
+function perSubjectSeries(perFrameTracked, srcW, srcH, perKeyframeSpeaker, frameCount, cutFrames) {
+  if (srcW <= 0 || srcH <= 0) return [];
+  const faceIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tracked of perFrameTracked) {
+    for (const fid of Object.keys(tracked)) {
+      if (!seen.has(fid)) {
+        seen.add(fid);
+        faceIds.push(fid);
+      }
+    }
+  }
+  const subjects = [];
+  for (const fid of faceIds) {
+    const centers = new Array(frameCount).fill(null);
+    const sizes = new Array(frameCount).fill(null);
+    for (let i = 0; i < frameCount; i++) {
+      const tracked = i < perFrameTracked.length ? perFrameTracked[i] : {};
+      const bbox = tracked[fid];
+      if (!bbox || bbox.length < 4) continue;
+      const [x1, y1, x2, y2] = bbox;
+      centers[i] = [(x1 + x2) / 2 / srcW, (y1 + y2) / 2 / srcH];
+      sizes[i] = [Math.max(0, x2 - x1) / srcW, Math.max(0, y2 - y1) / srcH];
+    }
+    const smCenters = emaSmooth(centers, 0.35, cutFrames);
+    const smSizes = emaSmooth(sizes, 0.35, cutFrames);
+    const boxSeries = [];
+    for (let i = 0; i < frameCount; i++) {
+      if (centers[i] === null) {
+        boxSeries.push(null);
+        continue;
+      }
+      const [cx, cy] = smCenters[i];
+      const [w, h] = smSizes[i];
+      boxSeries.push([clip01(cx - w / 2), clip01(cy - h / 2), clip01(w), clip01(h)]);
+    }
+    subjects.push({
+      face_id: fid,
+      face_box_series: boxSeries,
+      active_windows: activeWindowsFor(fid, perKeyframeSpeaker, frameCount)
+    });
+  }
+  return subjects;
+}
+function calibrateShotScale(shotScale, subjects, srcW, srcH, aspect, fallbackZoom, fallbackVbias, authoredSubject) {
+  const target = shotScale ? SHOT_SCALE_TARGET[shotScale] : void 0;
+  if (target === void 0 || srcH <= 0) return [fallbackZoom ?? 1, fallbackVbias ?? 0];
+  const outAr = aspectWhRatio(aspect);
+  const srcAr = srcW / srcH;
+  const fitH = srcAr > outAr ? srcH : srcW / outAr;
+  if (fitH <= 0) return [fallbackZoom ?? 1, fallbackVbias ?? 0];
+  const authoredPool = authoredSubject?.kind === "face" && authoredSubject.faceId.startsWith("face-") ? subjects.filter((s) => s.face_id === authoredSubject.faceId) : subjects;
+  const pool = authoredPool.some((s) => (s.face_box_series ?? []).some((b) => b !== null)) ? authoredPool : subjects;
+  const heights = [];
+  for (const s of pool) {
+    for (const b of s.face_box_series ?? []) {
+      if (b !== null && b.length >= 4) heights.push(b[3] * srcH);
+    }
+  }
+  if (heights.length === 0) return [fallbackZoom ?? 1, fallbackVbias ?? 0];
+  heights.sort((a, b) => a - b);
+  const medianH = heights[Math.floor(heights.length / 2)];
+  const baseFaceFrac = medianH / fitH;
+  if (baseFaceFrac <= 0) return [fallbackZoom ?? 1, fallbackVbias ?? 0];
+  const zoom = shotScaleZoom(baseFaceFrac, shotScale);
+  return [zoom, fallbackVbias ?? 0];
+}
+function deriveSegment(perFrameTracked, srcW, srcH, perKeyframeSpeaker, subject, cutFrames, fps, aspect, zoomScale) {
+  const frameCount = perFrameTracked.length;
+  if (subject.kind === "point") {
+    const centers2 = new Array(frameCount).fill(null).map(() => [subject.x, subject.y]);
+    return { centers: centers2, subjects: [], resolvedFrames: frameCount };
+  }
+  if (subject.kind === "all-faces") {
+    const sel = selectSubjectSet(
+      perFrameTracked,
+      srcW,
+      srcH,
+      fps ?? 30,
+      perKeyframeSpeaker,
+      cutFrames ?? /* @__PURE__ */ new Set()
+    );
+    const regions = buildRequiredRegions(
+      sel.perFrameBoxes,
+      fps ?? 30,
+      cutFrames ?? /* @__PURE__ */ new Set()
+    );
+    const effAspect = aspect ?? "9:16";
+    const shotFits = fitZoomPerShot(
+      sel.perFrameBoxes,
+      cutFrames ?? /* @__PURE__ */ new Set(),
+      srcW,
+      srcH,
+      effAspect,
+      fps ?? 30,
+      frameCount
+    );
+    const shotRanges = segmentShots(cutFrames ?? /* @__PURE__ */ new Set(), frameCount);
+    const winByFrame = new Array(frameCount);
+    const fallbackWin = cropWindowSizeFor(srcW, srcH, zoomScale ?? 1, effAspect);
+    for (let s = 0; s < shotRanges.length; s++) {
+      const fit = shotFits[s];
+      const win = fit ? cropWindowSizeFor(srcW, srcH, fit.zoom, effAspect) : fallbackWin;
+      for (let i = shotRanges[s].start; i < shotRanges[s].end; i++) winByFrame[i] = win;
+    }
+    const cropFor = (frame) => winByFrame[frame] ?? fallbackWin;
+    const centers2 = cameraPath(
+      regions,
+      cropFor,
+      fps ?? 30,
+      cutFrames ?? /* @__PURE__ */ new Set(),
+      [0.5, 0.5]
+    );
+    const subjects2 = perSubjectSeries(
+      perFrameTracked,
+      srcW,
+      srcH,
+      perKeyframeSpeaker,
+      frameCount,
+      cutFrames
+    );
+    return { centers: centers2, subjects: subjects2, resolvedFrames: sel.resolvedFrames, shotFits };
+  }
+  if (subject.kind === "face" || subject.kind === "active-speaker") {
+    const pick = subject.kind === "face" ? { kind: "face", authoredFaceId: subject.faceId } : { kind: "active-speaker" };
+    const single = selectSingleSubjectBoxes(
+      perFrameTracked,
+      srcW,
+      srcH,
+      perKeyframeSpeaker,
+      pick,
+      (frame) => nearestKpValue(perKeyframeSpeaker, frame)
+    );
+    const regions = buildRequiredRegions(
+      single.perFrameBoxes,
+      fps ?? 30,
+      cutFrames ?? /* @__PURE__ */ new Set()
+    );
+    const effAspect = aspect ?? "9:16";
+    const win = cropWindowSizeFor(srcW, srcH, zoomScale ?? 1, effAspect);
+    const centers2 = cameraPath(
+      regions,
+      () => win,
+      fps ?? 30,
+      cutFrames ?? /* @__PURE__ */ new Set(),
+      [0.5, 0.5]
+    );
+    const subjects2 = perSubjectSeries(perFrameTracked, srcW, srcH, perKeyframeSpeaker, frameCount, cutFrames);
+    return { centers: centers2, subjects: subjects2, resolvedFrames: single.resolvedFrames };
+  }
+  const rawCenters = new Array(frameCount).fill(null);
+  for (let i = 0; i < frameCount; i++) {
+    const tracked = perFrameTracked[i];
+    if (!tracked || Object.keys(tracked).length === 0) continue;
+    const faceDicts = Object.entries(tracked).map(([faceId, b]) => ({
+      faceId,
+      x: b[0] / srcW,
+      y: b[1] / srcH,
+      width: (b[2] - b[0]) / srcW,
+      height: (b[3] - b[1]) / srcH
+    }));
+    rawCenters[i] = selectedFaceCenter(faceDicts, subject);
+  }
+  const resolvedFrames = rawCenters.reduce((n, c) => c !== null ? n + 1 : n, 0);
+  const smoothed = emaSmooth(rawCenters, 0.35, cutFrames);
+  const centers = [];
+  for (let i = 0; i < frameCount; i++) {
+    const c = i < smoothed.length ? smoothed[i] : null;
+    centers.push(c === null ? [0.5, 0.5] : [c[0], c[1]]);
+  }
+  const subjects = perSubjectSeries(perFrameTracked, srcW, srcH, perKeyframeSpeaker, frameCount, cutFrames);
+  return { centers, subjects, resolvedFrames };
+}
+function focusToSubject(focus) {
+  switch (focus.mode) {
+    case "face":
+      return { kind: "face", faceId: focus.faceId };
+    case "point":
+      return { kind: "point", x: focus.x, y: focus.y };
+    case "all-faces":
+      return { kind: "all-faces" };
+    case "frame-center":
+      return { kind: "frame-center" };
+    case "active-speaker":
+      return { kind: "active-speaker" };
+  }
+}
+var FRAME_ROUNDING_TOLERANCE = 0.5;
+function internalGap(seg, segIdx, detail) {
+  return new Error(
+    encodeError(
+      new CueframeError(
+        "trajectory_internal_gap",
+        `authored segment ${segIdx} [${seg.startSec}\u2013${seg.endSec}s]: sub-shots do not tile the segment \u2014 ${detail}. A dropped sub-shot leaves an internal coverage gap the render would only catch downstream.`,
+        { segment: [seg.startSec, seg.endSec], segIdx, detail }
+      )
+    )
+  );
+}
+function deriveTrajectory(track, segments, aspect, bakeVersion, isGenerated = false) {
+  const fps = track.srcFps;
+  const perKf = new Map(
+    Object.entries(track.perKeyframeSpeaker).map(([k, v]) => [Number(k), v])
+  );
+  const out = [];
+  const trackLen = track.perFrameTracked.length;
+  const winCuts = track.shotBoundaries ?? [];
+  for (let idx = 0; idx < segments.length; idx++) {
+    const seg = segments[idx];
+    const subject = focusToSubject(seg.focus);
+    const shotScale = seg.focus.mode === "face" ? seg.focus.shotScale : void 0;
+    const zoomScale = seg.zoom;
+    const isEasedPan = seg.focus.mode === "point" && !!seg.ease && !!seg.bias;
+    const verticalBias = isEasedPan ? 0 : seg.bias?.y;
+    const lateralBias = isEasedPan ? 0 : seg.bias?.x ?? 0;
+    const segStart = Math.min(Math.round(seg.startSec * fps), trackLen);
+    const segEnd = Math.min(Math.round(seg.endSec * fps), trackLen);
+    if (segEnd - segStart <= 0) continue;
+    const segPerFrame = track.perFrameTracked.slice(segStart, segEnd);
+    const segKf = /* @__PURE__ */ new Map();
+    for (const [k, v] of perKf) {
+      if (k >= segStart && k < segEnd) segKf.set(k - segStart, v);
+    }
+    const segCuts = /* @__PURE__ */ new Set();
+    for (const b of winCuts) {
+      if (b > segStart && b < segEnd) segCuts.add(b - segStart);
+    }
+    const { centers, subjects, resolvedFrames, shotFits } = deriveSegment(
+      segPerFrame,
+      track.srcW,
+      track.srcH,
+      segKf,
+      subject,
+      segCuts,
+      fps,
+      // The all-faces cameraPath sizes its deadzone-inclusion crop window from
+      // the output aspect + the segment's authored zoom (default 1.0). Other
+      // modes ignore these. Per-shot zoom calibration (below) is `face`-only, so
+      // the all-faces window matches the emitted `zoom_scale` for every sub-shot.
+      aspect,
+      zoomScale
+    );
+    if (centers.length === 0) continue;
+    if (isGenerated && (subject.kind === "face" || subject.kind === "active-speaker" || subject.kind === "all-faces")) {
+      const rate = resolvedFrames / (segEnd - segStart);
+      if (rate < MIN_SUBJECT_RESOLUTION) {
+        throw new Error(
+          encodeError(
+            new CueframeError(
+              "subject_detection_failed_on_generated",
+              `segment [${seg.startSec}\u2013${seg.endSec}s] authored subject mode '${subject.kind}'` + (subject.kind === "face" ? ` (face '${subject.faceId}')` : "") + ` resolved in only ${resolvedFrames}/${segEnd - segStart} frames (${(rate * 100).toFixed(0)}%) on AI-GENERATED media \u2014 generated b-roll carries no detectable subject for this reframe. Use a GEOMETRIC reframe (frame-center or point) on generated footage instead of a subject-tracking mode.`,
+              {
+                mode: subject.kind,
+                ...subject.kind === "face" ? { faceId: subject.faceId } : {},
+                resolvedFrames,
+                totalFrames: segEnd - segStart,
+                segment: [seg.startSec, seg.endSec]
+              }
+            )
+          )
+        );
+      }
+    }
+    if (subject.kind === "face") {
+      const rate = resolvedFrames / (segEnd - segStart);
+      if (rate < MIN_SUBJECT_RESOLUTION) {
+        throw new Error(
+          encodeError(
+            new CueframeError(
+              "subject_not_tracked",
+              `segment [${seg.startSec}\u2013${seg.endSec}s] authored subject face '${subject.faceId}' resolved in only ${resolvedFrames}/${segEnd - segStart} frames (${(rate * 100).toFixed(0)}%) \u2014 the per-frame tracker does not carry this identity across the segment (ID fragmentation). Refusing to ship a frame-centered crop on no subject.`,
+              {
+                faceId: subject.faceId,
+                resolvedFrames,
+                totalFrames: segEnd - segStart,
+                segment: [seg.startSec, seg.endSec]
+              }
+            )
+          )
+        );
+      }
+    }
+    const segLen = segEnd - segStart;
+    const interior = [...segCuts].sort((a, b) => a - b);
+    const bounds = [0, ...interior, segLen];
+    const emittedSpans = [];
+    let shotIdx = 0;
+    for (let k = 0; k < bounds.length - 1; k++) {
+      const a = bounds[k];
+      const b = bounds[k + 1];
+      if (b - a <= 0) continue;
+      emittedSpans.push([a, b]);
+      const thisShot = shotIdx;
+      shotIdx++;
+      const subSubjects = subjects.map((s) => ({
+        face_id: s.face_id,
+        face_box_series: s.face_box_series.slice(a, b),
+        active_windows: s.active_windows.map(([ws, we]) => [Math.max(ws, a) - a, Math.min(we, b) - a]).filter(([ws, we]) => we > ws)
+      }));
+      const allFacesFit = subject.kind === "all-faces" ? shotFits?.[thisShot] : void 0;
+      const [zoom, vbias] = allFacesFit ? [allFacesFit.zoom, verticalBias ?? 0] : calibrateShotScale(
+        shotScale,
+        subSubjects,
+        track.srcW,
+        track.srcH,
+        aspect,
+        zoomScale,
+        verticalBias,
+        subject
+      );
+      const overframed = allFacesFit?.overframed === true;
+      const subLen = b - a;
+      const subCenters = isEasedPan && seg.focus.mode === "point" ? buildPannedCenters(
+        subLen,
+        fps,
+        [seg.focus.x, seg.focus.y],
+        [seg.bias?.x ?? 0, seg.bias?.y ?? 0],
+        seg.ease?.in ?? 0
+      ) : centers.slice(a, b);
+      const zooms = seg.ease ? buildEasedZooms(subLen, fps, zoom, seg.ease.in, seg.ease.out) : void 0;
+      out.push({
+        idx: out.length,
+        // Frame-based off the SNAPPED segStart (not the authored seg.startSec) so
+        // the segment times line up with the cut-aligned slice the render reads.
+        start_sec: (segStart + a) / fps,
+        end_sec: (segStart + b) / fps,
+        zoom_scale: zoom,
+        vertical_bias: vbias,
+        lateral_bias: lateralBias,
+        centers: subCenters,
+        subjects: subSubjects,
+        caption_band_reserve: captionBandReserve(aspect),
+        ...zooms ? { zooms } : {},
+        // Emit the DERIVED `overframed` outcome ONLY when true (an all-faces
+        // sub-shot whose group is wider than the aspect). Omitted (undefined) on
+        // a fitting group and every other mode, so the field never appears unless
+        // it is the documented widest-honest-frame case — keeps the trajectory
+        // JSON minimal and the golden diff scoped to real over-wide shots.
+        ...overframed ? { overframed: true } : {}
+      });
+    }
+    if (emittedSpans.length > 0) {
+      const sorted = [...emittedSpans].sort((x, y) => x[0] - y[0]);
+      if (Math.abs(sorted[0][0]) > FRAME_ROUNDING_TOLERANCE) {
+        throw internalGap(seg, idx, `first sub-shot starts at frame ${sorted[0][0]}, not 0`);
+      }
+      if (Math.abs(sorted[sorted.length - 1][1] - segLen) > FRAME_ROUNDING_TOLERANCE) {
+        throw internalGap(seg, idx, `last sub-shot ends at frame ${sorted[sorted.length - 1][1]}, not ${segLen}`);
+      }
+      for (let s = 0; s < sorted.length - 1; s++) {
+        if (sorted[s + 1][0] - sorted[s][1] > FRAME_ROUNDING_TOLERANCE) {
+          throw internalGap(seg, idx, `gap between sub-shot ending at frame ${sorted[s][1]} and next starting at ${sorted[s + 1][0]}`);
+        }
+      }
+    }
+  }
+  return {
+    bake_version: bakeVersion,
+    aspect,
+    src_w: track.srcW,
+    src_h: track.srcH,
+    src_fps: fps,
+    segments: out
+  };
+}
+
+// ../execution/core/src/render/mapFaceToPerson.ts
+function containment(face, person) {
+  const [fx1, fy1, fx2, fy2] = face;
+  const [px1, py1, px2, py2] = person;
+  const faceArea2 = Math.max(0, fx2 - fx1) * Math.max(0, fy2 - fy1);
+  if (faceArea2 === 0) return 0;
+  const ix = Math.max(0, Math.min(fx2, px2) - Math.max(fx1, px1));
+  const iy = Math.max(0, Math.min(fy2, py2) - Math.max(fy1, py1));
+  return ix * iy / faceArea2;
+}
+function mapFaceIdToPersonId(faceTrack, personTrack, faceId) {
+  const nF = faceTrack.perFrameTracked.length;
+  const nP = personTrack.perFrameTracked.length;
+  if (nF === 0 || nP === 0) return null;
+  const scores = /* @__PURE__ */ new Map();
+  let faceFrames = 0;
+  for (let i = 0; i < nF; i++) {
+    const face = faceTrack.perFrameTracked[i]?.[faceId];
+    if (!face) continue;
+    faceFrames++;
+    const j = nF === 1 ? 0 : Math.round(i * (nP - 1) / (nF - 1));
+    const persons = personTrack.perFrameTracked[j] ?? {};
+    for (const [pid, pbox] of Object.entries(persons)) {
+      const c = containment(face, pbox);
+      if (c <= 0) continue;
+      const s = scores.get(pid) ?? { total: 0, matched: 0 };
+      s.total += c;
+      if (c >= 0.6) s.matched++;
+      scores.set(pid, s);
+    }
+  }
+  if (faceFrames === 0 || scores.size === 0) return null;
+  const ranked = [...scores.entries()].sort((a, b) => b[1].total - a[1].total);
+  const [winnerId, winner] = ranked[0];
+  const runnerUp = ranked[1]?.[1].total ?? 0;
+  const margin = runnerUp > 0 ? winner.total / runnerUp : Infinity;
+  if (winner.matched / faceFrames < 0.3) return null;
+  if (margin < 1.5) return null;
+  return { personId: winnerId, matchedFrames: winner.matched, faceFrames, margin };
+}
+
+export {
+  buildEmphasisSet,
+  isEmphasized,
+  sliceTranscriptWords,
+  extractCaptionWordsFromDoc,
+  splitIntoSentences,
+  CARD_BOOKEND_DEFAULT_MS,
+  VIDEO_BOOKEND_DEFAULT_MS,
+  bookendFrames,
+  resolveBookendTimeline,
+  compositionFormatDimensions,
+  validateComposition,
+  playableSpans,
+  referencedMediaIds,
+  componentRefsByClipId,
+  compositionToRenderInput,
+  assembleRenderInput,
+  DEFAULT_FPS,
+  DEFAULT_WIDTH,
+  DEFAULT_HEIGHT,
+  DEFAULT_RENDER_SETTINGS,
+  FORMAT_PRESETS,
+  RESOLUTION_PRESETS,
+  bppToCrf,
+  computeExportDimensions,
+  ensureEven,
+  faceArea,
+  resolveSubjectFaces,
+  selectedFaceCenter,
+  JUMP_THRESHOLD,
+  MIN_SUBJECT_RESOLUTION,
+  isJump,
+  emaSmooth,
+  clip01,
+  captionBandReserve,
+  aspectWhRatio,
+  nearestKpValue,
+  activeWindowsFor,
+  perSubjectSeries,
+  calibrateShotScale,
+  deriveSegment,
+  deriveTrajectory,
+  mapFaceIdToPersonId
+};