@cueframe/kernel 0.1.0 → 0.1.1

package/dist/_members/core/render/emphasis.js

@@ -1,16 +0,0 @@
-/**
- * Build a Set keyed by "poolItemId:sourceStart" for O(1) emphasis lookups.
- * sourceStart is rounded to 3 decimal places to handle floating-point drift
- * between transcript sources and stored emphasis data.
- */
-export function buildEmphasisSet(emphasisWords) {
-    const set = new Set();
-    for (const w of emphasisWords) {
-        set.add(`${w.poolItemId}:${w.sourceStart.toFixed(3)}`);
-    }
-    return set;
-}
-/** Check if a word (by poolItemId + sourceStart) is in the emphasis set. */
-export function isEmphasized(set, poolItemId, sourceStart) {
-    return set.has(`${poolItemId}:${sourceStart.toFixed(3)}`);
-}

package/dist/_members/core/render/eval/cropBox.js

@@ -1,139 +0,0 @@
-/**
- * Reframe eval — the COMPOSED crop box per output frame.
- *
- * The eval target is the crop box the camera ACTUALLY lands on, in
- * output-crop-normalized space — NOT the raw `centers`/`zoom_scale` of the
- * trajectory JSON. Per the virtual-camera spec ("the composed (post-floor) crop
- * is the eval target … zoom is two-layer"), the jitter / center-crop metrics
- * sample the box `computeCropTransform` produces, so they measure what ships.
- *
- * Phase 0 samples the BASE camera path (the trajectory) — the floor yield is a
- * separate, caption-driven layer with its own golden (Phase 4). The geometry
- * below is the bake half of `computeCropTransform`
- * (packages/execution/render-entry/src/CropFromTrajectory.tsx): crop-window size from
- * `zoom_scale`, center from the per-frame `centers`, coverage-clamped so the
- * window never runs past the source edge. We replicate it here (rather than
- * import the renderer — execution must not depend on the Remotion bundle) and a
- * test pins this replica against the renderer's published clamp behavior.
- *
- * Coordinate system: the crop box is expressed in SOURCE-NORMALIZED units —
- * `cx,cy` ∈ [0,1] (window center vs source dims) and `w,h` ∈ [0,1] (window size
- * as a fraction of the source). Frame-to-frame motion of THIS box is the camera
- * motion; normalizing the per-component delta by the box's own size converts it
- * to output-crop-normalized units (a half-window pan is the same number at any
- * zoom — the zoom-invariant "held feel" the spec requires).
- */
-import { aspectWhRatio } from '../deriveTrajectory';
-/**
- * Crop-window dimensions (source-normalized) for a given `zoom_scale` + output
- * aspect — the bake half of `computeCropTransform`. The largest output-aspect
- * rect that fits the source, scaled by the clamped zoom. No `faceScale` (the
- * floor's caption-band yield) is applied here — Phase 0 samples the base path.
- */
-export function cropWindowSize(srcW, srcH, zoomScale, aspect) {
-    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;
-    }
-    // Mirror the renderer: zoom clamps to [0.4, 1.0] (CropFromTrajectory bakedZoom).
-    const bakedZoom = Math.max(0.4, Math.min(1.0, zoomScale));
-    cropW *= bakedZoom;
-    cropH *= bakedZoom;
-    return { w: cropW / srcW, h: cropH / srcH };
-}
-/**
- * Coverage-clamp a window center so the crop window stays fully inside the
- * source — the geometric invariant `computeCropTransform` enforces via
- * `tx = clamp(…)`, expressed here directly on the source-normalized center.
- * A window of width `w` can have its center range over `[w/2, 1 - w/2]`.
- */
-function clampCenter(c, sizeFrac) {
-    const half = sizeFrac / 2;
-    if (sizeFrac >= 1)
-        return 0.5; // window covers the whole axis → centered
-    return Math.max(half, Math.min(1 - half, c));
-}
-/** The composed crop box for one frame of one segment. */
-export function cropBoxForFrame(seg, frameInSeg, srcW, srcH, aspect) {
-    // Eased segments carry a per-frame `zooms`; otherwise the scalar `zoom_scale`.
-    const zoom = seg.zooms ? seg.zooms[Math.min(frameInSeg, seg.zooms.length - 1)] : seg.zoom_scale;
-    const { w, h } = cropWindowSize(srcW, srcH, zoom, aspect);
-    const center = seg.centers[Math.min(frameInSeg, seg.centers.length - 1)] ?? [0.5, 0.5];
-    return {
-        cx: clampCenter(center[0], w),
-        cy: clampCenter(center[1], h),
-        w,
-        h,
-    };
-}
-/**
- * Flatten a `TrajectoryData` to the per-output-frame composed crop-box series
- * over all its segments, in order. This is the series the jitter metric walks.
- */
-export function cropBoxSeries(traj) {
-    const out = [];
-    for (const seg of traj.segments) {
-        const n = seg.centers.length;
-        for (let i = 0; i < n; i++) {
-            out.push(cropBoxForFrame(seg, i, traj.src_w, traj.src_h, traj.aspect));
-        }
-    }
-    return out;
-}
-/**
- * The STATIC center-crop baseline a content-aware reframe MUST beat on
- * smoothness: the same per-segment `zoom_scale` (so the only variable is WHERE
- * the camera points), but the center pinned to source-center every frame
- * (coverage-clamped, which for a centered window is a no-op). A static crop has
- * zero pan jitter by construction — its only frame-to-frame motion is the
- * per-shot `zoom_scale` steps the algorithm itself authors. The reframe is
- * "adding jitter for nothing" if it cannot beat THIS.
- */
-export function centerCropBoxSeries(traj) {
-    const out = [];
-    for (const seg of traj.segments) {
-        const n = seg.centers.length;
-        for (let i = 0; i < n; i++) {
-            const zoom = seg.zooms ? seg.zooms[Math.min(i, seg.zooms.length - 1)] : seg.zoom_scale;
-            const { w, h } = cropWindowSize(traj.src_w, traj.src_h, zoom, traj.aspect);
-            out.push({ cx: 0.5, cy: 0.5, w, h });
-        }
-    }
-    return out;
-}
-/**
- * The RAW subject-centroid path baseline (the research bar): the per-frame
- * `centers` the algorithm computed, BEFORE any smoothing/deadzone, composed into
- * a crop box at the same per-segment zoom. A reframe must be SMOOTHER than the
- * path it is smoothing. Phase 0 cannot reconstruct the pre-EMA centroid from the
- * shipped trajectory (it only carries the smoothed `centers`), so this is a
- * scaffold that returns the shipped centers; Phase 3 wires the true raw path via
- * `eval/inclusion` + `eval/index` (keeping `emaSmooth` importable, per the
- * spec's characterization gate).
- */
-export function rawCentroidBoxSeries(traj) {
-    return cropBoxSeries(traj);
-}
-/**
- * Compose an arbitrary per-frame `centers` series (e.g. the raw tracking
- * centroid, or the same centroid through the OLD `emaSmooth`) into a crop-box
- * series at a fixed per-frame crop window — the Phase-3 "smoother than EMA"
- * characterization baseline. `cropFor(frame)` gives the source-normalized window
- * for that output frame (the same the shipping path uses), so the ONLY variable
- * between ours and the baseline is the smoother. Centers are coverage-clamped
- * exactly as the renderer clamps them.
- */
-export function cropBoxSeriesFromCenters(centers, cropFor) {
-    return centers.map((c, i) => {
-        const { w, h } = cropFor(i);
-        return { cx: clampCenter(c[0], w), cy: clampCenter(c[1], h), w, h };
-    });
-}

package/dist/_members/core/render/eval/inclusion.js

@@ -1,96 +0,0 @@
-/**
- * Reframe eval — the INCLUSION metric (Phase 3 gate) + the shot-aware teleport
- * and old-vs-new smoothness baselines.
- *
- * The Phase-2 gate (jitter ≤ center-crop) is the WRONG bar for a MOVING subject:
- * a static center crop has jitter 0, but the subject walks out of frame. The
- * camera that TRACKS the subject HAS motion (jitter > 0) and is CORRECT. So the
- * Phase-3 gate is INCLUSION: the per-frame RequiredRegion (the padded subject/
- * group box the crop must contain) must stay ⊆ the crop window. Our reframe must
- * reach inclusionRate ≈ 1.0 on a moving subject (the camera tracks), and a
- * static center-crop's inclusionRate must be materially LOWER (the subject walks
- * out). See the virtual-camera spec, "Virtual-camera stability" + the Phase-3
- * gate note.
- *
- * Pure, deterministic, no I/O. Replays the SAME `selectSubjectSet` +
- * `regionsFromBoxes` the shipping all-faces derive uses, so the regions are
- * EXACTLY the boxes the camera was obliged to contain.
- */
-import { selectSubjectSet } from '../vcam/subjectSet';
-import { buildRequiredRegions } from '../vcam/requiredRegion';
-/** True iff the padded RequiredRegion is fully inside the crop box (the crop
- *  window contains the region — the subject stays in frame). */
-export function regionInCrop(region, crop) {
-    const rx1 = region.cx - region.w / 2;
-    const rx2 = region.cx + region.w / 2;
-    const ry1 = region.cy - region.h / 2;
-    const ry2 = region.cy + region.h / 2;
-    const cx1 = crop.cx - crop.w / 2;
-    const cx2 = crop.cx + crop.w / 2;
-    const cy1 = crop.cy - crop.h / 2;
-    const cy2 = crop.cy + crop.h / 2;
-    // A tiny tolerance absorbs float noise at the exact edge (a region flush with
-    // the crop edge is contained, not out).
-    const eps = 1e-6;
-    return rx1 >= cx1 - eps && rx2 <= cx2 + eps && ry1 >= cy1 - eps && ry2 <= cy2 + eps;
-}
-/**
- * The per-frame RequiredRegions an `all-faces` camera was obliged to contain,
- * over the WHOLE track window (one all-faces segment). Recomputes the shipping
- * selection so the regions match the derive exactly. Null where no framed member
- * is present (occlusion / gap) — those frames are EXCLUDED from inclusionRate
- * (there's no subject to keep in frame).
- */
-export function requiredRegionsForTrack(track) {
-    const cuts = new Set((track.shotBoundaries ?? []).filter((b) => b > 0));
-    const sel = selectSubjectSet(track.perFrameTracked, track.srcW, track.srcH, track.srcFps, new Map(Object.entries(track.perKeyframeSpeaker).map(([k, v]) => [Number(k), v])), cuts);
-    // Use the SAME canonical RequiredRegions the camera frames (pad + per-shot
-    // outlier reject) — the gate measures inclusion against exactly the region the
-    // derive was obliged to contain, so it can't be gamed by measuring a looser box.
-    return buildRequiredRegions(sel.perFrameBoxes, track.srcFps, cuts);
-}
-/** The all-faces `inclusionRate` for a crop-box series vs the per-frame
- *  RequiredRegions: the fraction of REGION-BEARING frames whose region is fully
- *  inside the crop. `1.0` ⇒ the subject never walks out of frame. Frames with no
- *  region (no subject present) are not counted. */
-export function inclusionRate(regions, crops) {
-    let framesWithRegion = 0;
-    let contained = 0;
-    const n = Math.min(regions.length, crops.length);
-    for (let i = 0; i < n; i++) {
-        const r = regions[i];
-        if (r === null)
-            continue;
-        framesWithRegion++;
-        if (regionInCrop(r, crops[i]))
-            contained++;
-    }
-    return {
-        rate: framesWithRegion > 0 ? contained / framesWithRegion : 1,
-        framesWithRegion,
-        contained,
-    };
-}
-/**
- * The largest per-frame center step measured WITHIN trajectory segments (one per
- * sub-shot), in output-crop-normalized units. Steps ACROSS a segment boundary
- * (a detector shot cut) are EXCLUDED — a camera snap at a real cut is intended
- * (the only reset), so it is not a "teleport". An intra-shot maxStep above the
- * bar is the chase/teleport the gate guards against. `segLens` are the per-
- * segment frame counts (so the walk knows where the cut-snaps are).
- */
-export function intraShotMaxStep(crops, segLens) {
-    let max = 0;
-    let frame = 0;
-    for (const len of segLens) {
-        for (let i = 1; i < len; i++) {
-            const a = crops[frame + i - 1];
-            const b = crops[frame + i];
-            const step = Math.abs(b.cx - a.cx) / Math.max(b.w, 1e-6) + Math.abs(b.cy - a.cy) / Math.max(b.h, 1e-6);
-            if (step > max)
-                max = step;
-        }
-        frame += len;
-    }
-    return max;
-}

package/dist/_members/core/render/eval/index.js

@@ -1,146 +0,0 @@
-/**
- * Reframe eval harness — the public surface for the metrics + the fixture-driven
- * report. Pure TS, no Modal, no R2: every metric replays a cached `SubjectTrack`
- * fixture through the REAL `deriveTrajectory` and measures the composed crop box.
- * See the virtual-camera spec's "Eval / metrics / test harness (built FIRST)".
- *
- * Phase 0 shipped jitter + center-crop. Phase 3 adds the INCLUSION gate (the
- * camera tracks a moving subject ⇒ region ⊆ crop) + the shot-aware teleport
- * metric + the "smoother than the old EMA path" characterization, because pure
- * jitter-beats-center-crop is the WRONG bar once the camera legitimately moves to
- * track (a static center-crop has jitter 0 but loses a walking subject).
- */
-import { deriveTrajectory, emaSmooth, cropWindowSizeFor, nearestKpValue } from '../deriveTrajectory';
-import { cropBoxSeries, centerCropBoxSeries, rawCentroidBoxSeries, cropBoxSeriesFromCenters, } from './cropBox';
-import { jitter } from './metrics';
-import { requiredRegionsForTrack, inclusionRate, intraShotMaxStep, regionInCrop, } from './inclusion';
-import { selectSubjectSet, selectSingleSubjectBoxes, } from '../vcam/subjectSet';
-import { buildRequiredRegions } from '../vcam/requiredRegion';
-import { segmentShots } from '../vcam/shots';
-export { cropBoxSeries, centerCropBoxSeries, rawCentroidBoxSeries, cropBoxSeriesFromCenters, cropWindowSize, cropBoxForFrame, } from './cropBox';
-export { jitter, iou, mIoU } from './metrics';
-export { requiredRegionsForTrack, inclusionRate, intraShotMaxStep, regionInCrop, } from './inclusion';
-/**
- * Run the base eval over a fixture track + authored reframe segments. Derives the
- * trajectory through the SHIPPING `deriveTrajectory`, composes the crop boxes,
- * and reports jitter vs the center-crop + raw-centroid baselines.
- */
-export function evalReframe(track, segments, aspect, bakeVersion) {
-    const traj = deriveTrajectory(track, segments, aspect, bakeVersion);
-    const ours = cropBoxSeries(traj);
-    const center = centerCropBoxSeries(traj);
-    const raw = rawCentroidBoxSeries(traj);
-    const j = jitter(ours);
-    const cj = jitter(center);
-    const rj = jitter(raw);
-    return {
-        jitter: j,
-        centerCropJitter: cj,
-        rawCentroidJitter: rj,
-        beatsCenterCrop: j.total <= cj.total,
-        frames: ours.length,
-    };
-}
-/**
- * The Phase-3 tracking eval for an `all-faces` segment over the whole window.
- * Recomputes the per-frame RequiredRegions (the SAME `selectSubjectSet` the
- * derive uses) and measures whether the camera keeps the subject in frame
- * (inclusion), how it compares to the old EMA path (smoothness), and that it
- * never teleports within a shot. The fixed crop window per frame is the
- * segment's authored zoom + aspect (all-faces has no eased per-frame zoom).
- */
-export function evalTracking(track, aspect, bakeVersion) {
-    const segments = [
-        { startSec: 0, endSec: track.window.endSec, focus: { mode: 'all-faces' }, zoom: 1 },
-    ];
-    const traj = deriveTrajectory(track, segments, aspect, bakeVersion);
-    const ours = cropBoxSeries(traj);
-    const center = centerCropBoxSeries(traj);
-    const regions = requiredRegionsForTrack(track);
-    // The fixed per-frame crop window (zoom 1.0 here — the authored all-faces zoom).
-    const win = cropWindowSizeFor(track.srcW, track.srcH, 1.0, aspect);
-    const cropFor = () => win;
-    // Reconstruct the RAW per-frame tracking centroid + the OLD emaSmooth path over
-    // the SAME selection, to prove ours (cameraPath) is no rougher than EMA.
-    const cuts = new Set((track.shotBoundaries ?? []).filter((b) => b > 0));
-    const sel = selectSubjectSet(track.perFrameTracked, track.srcW, track.srcH, track.srcFps, new Map(Object.entries(track.perKeyframeSpeaker).map(([k, v]) => [Number(k), v])), cuts);
-    const rawCenters = sel.centers;
-    const emaCenters = emaSmooth(rawCenters, 0.35, cuts);
-    const rawBoxes = cropBoxSeriesFromCenters(rawCenters, cropFor);
-    const emaBoxes = cropBoxSeriesFromCenters(emaCenters, cropFor);
-    const segLens = traj.segments.map((s) => s.centers.length);
-    return {
-        inclusionRate: inclusionRate(regions, ours).rate,
-        centerCropInclusionRate: inclusionRate(regions, center).rate,
-        framesWithRegion: inclusionRate(regions, ours).framesWithRegion,
-        jitter: jitter(ours),
-        emaPathJitter: jitter(emaBoxes),
-        rawPathJitter: jitter(rawBoxes),
-        intraShotMaxStep: intraShotMaxStep(ours, segLens),
-        frames: ours.length,
-    };
-}
-/** Resolve a Focus mode + faceId into the single-subject adapter pick. */
-function pickFor(mode, faceId) {
-    return mode === 'face' ? { kind: 'face', authoredFaceId: faceId ?? '' } : { kind: 'active-speaker' };
-}
-/**
- * Characterize the P4 `face` / `active-speaker` migration on a real fixture: the
- * NEW core geometric-deadzone path (run via the SHIPPING `deriveTrajectory`) vs
- * the OLD `emaSmooth` path (reconstructed here over the SAME per-frame chosen-
- * subject centroid the old code used), measured against ONE inclusion region (the
- * chosen subject's per-frame padded BOX). All over a single full-window segment.
- */
-export function evalSingleSubject(track, mode, aspect, bakeVersion, faceId) {
-    const segments = [
-        {
-            startSec: 0,
-            endSec: track.window.endSec,
-            focus: mode === 'face' ? { mode: 'face', faceId: faceId ?? 'face-0' } : { mode: 'active-speaker' },
-            zoom: 1,
-        },
-    ];
-    // NEW: the shipping migrated derive.
-    const traj = deriveTrajectory(track, segments, aspect, bakeVersion);
-    const newBoxes = cropBoxSeries(traj);
-    // The chosen subject's per-frame box (the adapter the migrated derive uses) →
-    // the SINGLE inclusion region both paths are judged against + the centroid the
-    // OLD emaSmooth consumed.
-    const cuts = new Set((track.shotBoundaries ?? []).filter((b) => b > 0));
-    const perKf = new Map(Object.entries(track.perKeyframeSpeaker).map(([k, v]) => [Number(k), v]));
-    const single = selectSingleSubjectBoxes(track.perFrameTracked, track.srcW, track.srcH, perKf, pickFor(mode, faceId), (frame) => nearestKpValue(perKf, frame));
-    const regions = buildRequiredRegions(single.perFrameBoxes, track.srcFps, cuts);
-    // OLD: emaSmooth(0.35) over the chosen subject's per-frame centroid (the bare
-    // center the deleted branch produced), composed at the SAME zoom-1.0 window.
-    const win = cropWindowSizeFor(track.srcW, track.srcH, 1.0, aspect);
-    const cropFor = () => win;
-    const centroids = single.perFrameBoxes.map((b) => b === null ? null : [(b[0] + b[2]) / 2, (b[1] + b[3]) / 2]);
-    const emaCenters = emaSmooth(centroids, 0.35, cuts);
-    const emaBoxes = cropBoxSeriesFromCenters(emaCenters.map((c) => [c[0], c[1]]), cropFor);
-    // Inclusion vs the chosen subject's padded box region (one bar for both paths).
-    const incl = (crops) => {
-        let fw = 0;
-        let contained = 0;
-        for (let i = 0; i < regions.length; i++) {
-            const r = regions[i];
-            if (r === null)
-                continue;
-            fw++;
-            if (regionInCrop(r, crops[i]))
-                contained++;
-        }
-        return { rate: fw > 0 ? contained / fw : 1, framesWithRegion: fw };
-    };
-    // Intra-shot max step (cut-snaps excluded) needs per-shot frame counts.
-    const segLens = segmentShots(cuts, regions.length).map((s) => s.end - s.start);
-    const newIncl = incl(newBoxes);
-    return {
-        jitter: jitter(newBoxes),
-        emaJitter: jitter(emaBoxes),
-        inclusionRate: newIncl.rate,
-        emaInclusionRate: incl(emaBoxes).rate,
-        intraShotMaxStep: intraShotMaxStep(newBoxes, segLens),
-        emaIntraShotMaxStep: intraShotMaxStep(emaBoxes, segLens),
-        framesWithRegion: newIncl.framesWithRegion,
-    };
-}

package/dist/_members/core/render/eval/metrics.js

@@ -1,94 +0,0 @@
-/**
- * Reframe eval metrics — pure, label-free, deterministic.
- *
- * Tier 1 (HARD CI BLOCKERS, no human labels): `jitter` + the center-crop
- * comparison. These are what gate the build per the virtual-camera spec —
- * "jitter-beats-center-crop is the only ship-blocker".
- *
- * Tier 2 (REPORTED, not blocking): `mIoU` — scaffolded + reported, NOT a gate,
- * because per-frame human ground-truth boxes don't exist yet (RESOLVED #3).
- *
- * `jitter` = mean over frames of the absolute frame-to-frame difference of the
- * composed crop box (center x/y AND size), in output-crop-normalized units. The
- * per-component delta is normalized by the box's own size, so the metric is
- * zoom-invariant: a half-window pan reads the same number at any zoom (the spec's
- * "held feel is zoom-invariant" requirement). Lower is smoother. A static crop
- * has zero pan jitter; the only motion it carries is the per-shot `zoom_scale`
- * steps, which both paths share — so `jitter(ours) ≤ jitter(centerCrop)` isolates
- * "where the camera points" as the sole variable.
- */
-/**
- * Jitter of a composed crop-box series. Empty / single-frame series → all zeros
- * (no motion to measure). The center delta is divided by the per-frame window
- * size so it is expressed in fractions of the crop window (output-crop space);
- * the zoom delta is divided by the mean window size for the same normalization.
- */
-export function jitter(boxes) {
-    if (boxes.length < 2) {
-        return { center: 0, zoom: 0, total: 0, maxCenterStep: 0 };
-    }
-    let centerAcc = 0;
-    let zoomAcc = 0;
-    let maxCenterStep = 0;
-    let wSum = 0;
-    let hSum = 0;
-    for (const b of boxes) {
-        wSum += b.w;
-        hSum += b.h;
-    }
-    const meanW = wSum / boxes.length || 1e-6;
-    const meanH = hSum / boxes.length || 1e-6;
-    for (let i = 1; i < boxes.length; i++) {
-        const a = boxes[i - 1];
-        const b = boxes[i];
-        // Center delta in output-crop units: source-normalized delta ÷ window size
-        // (so it's a fraction of the visible window, not of the whole source).
-        const dxOut = Math.abs(b.cx - a.cx) / Math.max(b.w, 1e-6);
-        const dyOut = Math.abs(b.cy - a.cy) / Math.max(b.h, 1e-6);
-        const step = dxOut + dyOut;
-        centerAcc += step;
-        if (step > maxCenterStep)
-            maxCenterStep = step;
-        // Zoom (window-size) delta, normalized by the mean window size.
-        zoomAcc += Math.abs(b.w - a.w) / meanW + Math.abs(b.h - a.h) / meanH;
-    }
-    const denom = boxes.length - 1;
-    const center = centerAcc / denom;
-    const zoom = zoomAcc / denom;
-    return { center, zoom, total: center + zoom, maxCenterStep };
-}
-/** Intersection-over-union of two source-normalized crop boxes. */
-export function iou(a, b) {
-    const ax1 = a.cx - a.w / 2;
-    const ax2 = a.cx + a.w / 2;
-    const ay1 = a.cy - a.h / 2;
-    const ay2 = a.cy + a.h / 2;
-    const bx1 = b.cx - b.w / 2;
-    const bx2 = b.cx + b.w / 2;
-    const by1 = b.cy - b.h / 2;
-    const by2 = b.cy + b.h / 2;
-    const ix = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));
-    const iy = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));
-    const inter = ix * iy;
-    const union = a.w * a.h + b.w * b.h - inter;
-    return union > 0 ? inter / union : 0;
-}
-/**
- * mIoU + IoU@0.5 vs a per-frame ground-truth crop-box series (Tier 2, REPORTED
- * only). Scaffolded now so the harness emits a number the moment labels exist;
- * NOT a CI gate (no hand-labeled fixtures yet — RESOLVED #3). Lengths must match.
- */
-export function mIoU(ours, groundTruth) {
-    const n = Math.min(ours.length, groundTruth.length);
-    if (n === 0)
-        return { mIoU: 0, iouAt50: 0, n: 0 };
-    let sum = 0;
-    let hits = 0;
-    for (let i = 0; i < n; i++) {
-        const v = iou(ours[i], groundTruth[i]);
-        sum += v;
-        if (v >= 0.5)
-            hits++;
-    }
-    return { mIoU: sum / n, iouAt50: hits / n, n };
-}

package/dist/_members/core/render/exportSettings.js

@@ -1,65 +0,0 @@
-// ── Constants ──────────────────────────────────────────────────────────────
-export const DEFAULT_FPS = 30;
-export const DEFAULT_WIDTH = 1920;
-export const DEFAULT_HEIGHT = 1080;
-export const DEFAULT_RENDER_SETTINGS = {
-    format: 'source',
-    quality: 'source',
-    resolution: 'source',
-    watermark: false,
-    captionsEnabled: true,
-};
-export const 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 },
-};
-export const RESOLUTION_PRESETS = {
-    '1080p': { label: '1080p (Full HD)', height: 1080 },
-    '1440p': { label: '1440p (2K)', height: 1440 },
-    '4k': { label: '4K (Ultra HD)', height: 2160 },
-};
-// BPP (bits-per-pixel) presets — scales encoding quality proportionally to
-// resolution so file sizes are predictable across 720p through 4K.
-const BPP = {
-    maximum: 0.3,
-    social: 0.15,
-    web: 0.08,
-    potato: 0.04,
-};
-// ── Functions ──────────────────────────────────────────────────────────────
-/** Convert a BPP value to an approximate CRF (H.264). */
-export function bppToCrf(bpp) {
-    return Math.max(15, Math.min(36, Math.round(51 - bpp * 120)));
-}
-/** Compute output dimensions and CRF from source dims + quality preset. */
-export 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));
-    }
-    // Ensure even dimensions (required by most codecs)
-    w = w % 2 === 0 ? w : w + 1;
-    h = h % 2 === 0 ? h : h + 1;
-    if (quality === 'source') {
-        return { width: w, height: h, crf: undefined };
-    }
-    const bpp = BPP[quality];
-    if (bpp === undefined)
-        return { width: w, height: h, crf: undefined };
-    return { width: w, height: h, crf: bppToCrf(bpp) };
-}
-/** Ensure a dimension is even (required by most codecs). */
-export function ensureEven(n) {
-    return n % 2 === 0 ? n : n + 1;
-}

package/dist/_members/core/render/index.js

@@ -1,20 +0,0 @@
-export { buildEmphasisSet, isEmphasized } from './emphasis';
-export { extractCaptionWordsFromDoc, sliceTranscriptWords, splitIntoSentences } from './captions';
-// (auto-reframe module deleted 2026-05-25 — baked-variants substrate
-// replacement. Crop trajectories now live in pre-baked variant videos,
-// not in render-time computation.)
-// (caption-safe-area deleted 2026-06-04 — the composition floor's reframe-yield
-// replaces the scalar caption shift. See @cueframe/composition/projection
-// resolveCompositionFloor + packages/execution/render-entry/src/floor/buildFloorInput.ts.)
-export { compositionToRenderInput, referencedMediaIds, componentRefsByClipId, assembleRenderInput, validateComposition, compositionFormatDimensions, playableSpans, } from './compositionRender';
-// Brand intro/outro bookend timeline math — pure, fps-driven, never throws.
-// Shared by compositionToRenderInput (forward: body → extended total) and the
-// cueframe renderer's MainComposition (bumper → reserved frames + body shift).
-export { bookendFrames, resolveBookendTimeline, CARD_BOOKEND_DEFAULT_MS, VIDEO_BOOKEND_DEFAULT_MS, } from './bookends';
-export { DEFAULT_FPS, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_RENDER_SETTINGS, FORMAT_PRESETS, RESOLUTION_PRESETS, bppToCrf, computeExportDimensions, ensureEven, } from './exportSettings';
-// Crop-trajectory inline derive — PURE STAGE-B math over a cached SubjectTrack.
-// The render derives the crop trajectory INLINE from the track + the clip's
-// reframe (no pre-baked variant cache). See
-// brain/Projects/CueFrame/specs/2026-06-14-render-time-resolution-design.md.
-export { faceArea, resolveSubjectFaces, selectedFaceCenter, isJump, emaSmooth, clip01, captionBandReserve, aspectWhRatio, nearestKpValue, activeWindowsFor, perSubjectSeries, calibrateShotScale, deriveSegment, deriveTrajectory, buildEasedZooms, buildPannedCenters, easeOutCubic, JUMP_THRESHOLD, MIN_SUBJECT_RESOLUTION, } from './deriveTrajectory';
-export { mapFaceIdToPersonId } from './mapFaceToPerson';

package/dist/_members/core/render/mapFaceToPerson.js

@@ -1,73 +0,0 @@
-/**
- * Face→person identity mapping for the perception ESCALATION path.
- *
- * The plan authors subjects against the FACE roster (`face-N`, YuNet/SCRFD).
- * When the face tracker carries that identity in too few frames
- * (`subject_not_tracked` — e.g. the subject looks away for most of a long
- * segment), the compose escalates to the PERSON detector (YOLO11x + BoT-SORT),
- * whose track names identities `person-N`. This maps the authored face id onto
- * the person id whose body boxes CONTAIN that face, scored over exactly the
- * frames where the face DID resolve — the face evidence is sparse but real, and
- * a face box sits inside its own person's box in every such frame.
- *
- * Pure math, no I/O. Tracks may have different frame counts (defensive):
- * frames align by relative position in the shared detection window.
- */
-/** Fraction of the FACE box's area inside the person box. 1 = fully contained. */
-function containment(face, person) {
-    const [fx1, fy1, fx2, fy2] = face;
-    const [px1, py1, px2, py2] = person;
-    const faceArea = Math.max(0, fx2 - fx1) * Math.max(0, fy2 - fy1);
-    if (faceArea === 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) / faceArea;
-}
-/**
- * Map one authored face id to the person-track id that carries it, or null when
- * the evidence is missing/ambiguous (caller fails loud — never a guess).
- *
- * Decision rule: sum per-frame containment per person id over the frames where
- * the face resolves; the winner needs (a) support in ≥30% of those frames at
- * ≥60% containment, and (b) a 1.5× margin over the runner-up (two people
- * side-by-side must not coin-flip).
- */
-export function mapFaceIdToPersonId(faceTrack, personTrack, faceId) {
-    const nF = faceTrack.perFrameTracked.length;
-    const nP = personTrack.perFrameTracked.length;
-    if (nF === 0 || nP === 0)
-        return null;
-    const scores = new Map();
-    let faceFrames = 0;
-    for (let i = 0; i < nF; i++) {
-        const face = faceTrack.perFrameTracked[i]?.[faceId];
-        if (!face)
-            continue;
-        faceFrames++;
-        // Align by relative position — identical-length tracks map i→i exactly.
-        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; // too little real containment
-    if (margin < 1.5)
-        return null; // ambiguous between two people
-    return { personId: winnerId, matchedFrames: winner.matched, faceFrames, margin };
-}

package/dist/_members/core/render/types.js

@@ -1,8 +0,0 @@
-// Self-contained types for the render pipeline.
-// These MUST NOT import from @tauri-apps/* or any barrel that re-exports Tauri types,
-// because Remotion's webpack bundler will try to resolve those imports and fail.
-//
-// OverlayTemplate and OverlayParams are intentionally duplicated from src/types/index.ts.
-// Remotion bundles via webpack which cannot resolve @tauri-apps/* imports that appear
-// in the main types barrel. Keeping these copies decoupled avoids webpack build failures.
-export {};