@cueframe/kernel 0.0.1 → 0.1.1

package/dist/_members/core/render/vcam/shots.js

@@ -1,53 +0,0 @@
-/**
- * vcam/shots.ts — shot segmentation, the SOLE cut source.
- *
- * Phase 1 of the virtual-camera redesign (brain spec
- * 2026-06-21-virtual-camera-reframe-design.md, "Shot/segment handling"):
- * cuts come ONLY from the detector's `track.shotBoundaries` (HSV hard cuts),
- * NEVER inferred from a face-center jump. The deleted `isJump`-as-cut inference
- * is the false-cut snap (the 1.6-frame-widths/sec teleport) — structurally
- * impossible once the only reset is a real detector boundary.
- *
- * Two scopes the selection math must NOT conflate:
- *   - **Identity scope = the authored segment** (cross-shot). A tracker id is
- *     stable within a shot; the same person is followed across cuts. The
- *     `MIN_SUBJECT_RESOLUTION` resolution gate lives at segment granularity.
- *   - **Camera re-lock scope = the shot.** The per-shot LOCKED subject set
- *     (quality gate) is computed per shot; deadzone / window / zoom-fit reset
- *     at a shot boundary (the latter two land in Phase 3/5).
- *
- * Pure, deterministic, no I/O. Inputs are already segment-local frame indices
- * (the caller rebased the window-local `shotBoundaries` into segment offsets).
- */
-/**
- * Split `[0, segLen)` into shot ranges at the interior cut frames.
- *
- * `interiorCuts` are segment-local frame indices where a NEW shot begins — the
- * SAME set `deriveTrajectory` already derives (`segCuts`: window-local
- * `shotBoundaries` strictly inside the segment, rebased to segment offsets). A
- * cut at frame `c` ends the prior shot at `c` and starts the next at `c`.
- *
- * Legacy tracks with no `shotBoundaries` → no interior cuts → ONE shot covering
- * the whole segment (the safe hold). `shot_boundaries_missing` is NOT thrown —
- * a one-shot segment is a legal, documented outcome, never a degrade.
- *
- * Out-of-range / duplicate / unsorted cuts are tolerated: cuts are sorted,
- * deduped, and clamped to `(0, segLen)`; zero-length spans are dropped. A
- * segment of length 0 yields no shots.
- */
-export function segmentShots(interiorCuts, segLen) {
-    if (segLen <= 0)
-        return [];
-    const cuts = [...new Set(interiorCuts)]
-        .filter((c) => c > 0 && c < segLen)
-        .sort((a, b) => a - b);
-    const bounds = [0, ...cuts, segLen];
-    const shots = [];
-    for (let i = 0; i < bounds.length - 1; i++) {
-        const start = bounds[i];
-        const end = bounds[i + 1];
-        if (end - start > 0)
-            shots.push({ start, end });
-    }
-    return shots;
-}

package/dist/_members/core/render/vcam/subjectSet.js

@@ -1,388 +0,0 @@
-/**
- * vcam/subjectSet.ts — the CHASE KILLER (Phase 2).
- *
- * The `all-faces` failure is the per-frame area-weighted centroid of EVERY
- * detected face: any transient face (a crowd extra, a ByteTrack fragment, a
- * background head) yanks the centroid, so the camera ping-pongs (the "chase").
- * This module selects a STABLE subject set and frames the GROUP smoothly,
- * beating a static center crop on jitter — the headline behavioral fix.
- *
- * Mode-isolated: this is consulted ONLY for the `all-faces` path in
- * `deriveSegment`. `face` / `point` / `frame-center` / `active-speaker` keep
- * their existing selection verbatim.
- *
- * Pipeline (brain spec 2026-06-21-virtual-camera-reframe-design.md, "Subject-of
- * -interest selection"):
- *   1. Per-shot LOCKED subject set (quality gate) — size-aware drop, NOT a flat
- *      persistence gate, so a dominant late entrant is kept and a transient
- *      small face is dropped.
- *   2. Identity scope = the authored SEGMENT: union the per-shot locked sets →
- *      the segment candidate pool; rank by segment-wide dominance; take top-K.
- *   3. Per-frame set-MEMBERSHIP hysteresis over the pool (add/drop debounce) so
- *      a member flickering at the gate boundary doesn't toggle the framing.
- *   4. Emit, PER FRAME, the area-weighted centroid + union bbox over the framed
- *      members PRESENT this frame. The centroid is the raw crop target; the box
- *      is the RequiredRegion source. Transient entries/exits can't yank the
- *      camera (they're gated out of the framed set), but the framed group's own
- *      motion IS followed — Phase 3's deadzone + Hamming window in `cameraPath`
- *      turn this per-frame target into a held-then-glide path, so a walking
- *      subject stays in frame (the camera tracks) without chasing micro-jitter.
- *      (Phase 2 held this target static, which kept a moving subject framed only
- *      while it stayed near the centroid; Phase 3 lets the hold glide to re-
- *      contain the subject when it walks.)
- *
- * The per-subject `face_box_series` the floor reads is produced UNCHANGED by
- * `perSubjectSeries` — this module only chooses WHERE the camera points.
- */
-import { segmentShots } from './shots';
-import { P_MIN, SIZE_MIN, SIZE_DOMINANT, MAX_SUBJECTS, DOMINANCE_WEIGHTS, ENTER_SEC, LEAVE_SEC, } from './constants';
-import { scoreAndRank } from '../../select/select';
-import { stabilizeSelectionHysteresis } from '../../select/stabilize';
-/** Median of a numeric array (lower-median for even length, matching the
- *  detector-side convention used for `size_med`). Empty → fallback. */
-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)];
-}
-/** Per-id stats over one shot's frames (segment-local slice). */
-function shotStats(perFrameTracked, srcW, srcH, perKeyframeSpeaker, shot) {
-    const shotLen = shot.end - shot.start;
-    // Accumulators per id.
-    const heights = new Map();
-    const centralities = new Map();
-    const present = 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;
-            // Centrality: 1 at frame center, decreasing with normalized distance.
-            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);
-        }
-    }
-    // Speaking fraction over this shot's keyframe picks.
-    const shotPicks = [];
-    for (const [kf, fid] of perKeyframeSpeaker) {
-        if (kf >= shot.start && kf < shot.end)
-            shotPicks.push(fid);
-    }
-    const speakCount = new Map();
-    for (const fid of shotPicks)
-        speakCount.set(fid, (speakCount.get(fid) ?? 0) + 1);
-    const out = 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;
-}
-/** The size-aware locked-set gate. Drop iff
- *  `(persistence < P_MIN AND sizeMed < SIZE_DOMINANT) OR (sizeMed < SIZE_MIN)`.
- *  Keeps a dominant late entrant (low persistence, large size); drops a
- *  transient small face. `speaking`/`centrality` feed dominance, NOT the gate. */
-function passesGate(s) {
-    if (s.sizeMed < SIZE_MIN)
-        return false;
-    if (s.persistence < P_MIN && s.sizeMed < SIZE_DOMINANT)
-        return false;
-    return true;
-}
-/** Map a track's stats → the Selector core's signal envelope. The subjects
- *  Candidate adapter PRODUCES these `{size,centrality,persistence,speaking}`
- *  signals (the `shotStats`/`segStats` geometry lives HERE, in the adapter; the
- *  core only sees the absolute scalars — the rot-guard). Keys are in
- *  `DOMINANCE_WEIGHTS` order so `scoreAndRank`'s `Σ weights·signal` sums in the
- *  SAME float order as the old `dominance()`, preserving byte-equivalence. */
-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 = new Map();
-    const widths = new Map();
-    const cxs = new Map();
-    const cys = new Map();
-    const centralities = new Map();
-    const present = 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 = 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 = 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;
-}
-/**
- * Select the stable subject set for an `all-faces` segment and emit the per-
- * frame crop target. Pure over the segment-local slice.
- *
- * Empty locked set (no face survives the gate — a faceless / crowd-only clip) →
- * center-hold (`[0.5,0.5]` every frame), a DEFINED outcome, never a throw
- * (per spec fail-loud invariants).
- */
-export 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();
-    // 1. Per-shot LOCKED set (quality gate). Union across shots → segment pool.
-    const shots = segmentShots(interiorCuts, n);
-    const pool = 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();
-    // 2. Rank the pool by SEGMENT-WIDE dominance through the SELECTOR CORE's
-    //    `Σ weights·signal` combinator (`scoreAndRank`) — `DOMINANCE_WEIGHTS` is
-    //    `policy.weights`, the per-track segStats are the adapter-produced
-    //    `{size,centrality,persistence,speaking}` signals. `scoreAndRank` sorts
-    //    desc by score with the SAME stable id tiebreak as the old inline sort, so
-    //    `framedIds` is byte-identical. Take top-K.
-    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);
-    // 3. Per-frame set-MEMBERSHIP hysteresis over the framed pool — the SELECTOR
-    //    CORE's `selection-hysteresis` stabilizer (`stabilizeSelectionHysteresis`,
-    //    the `topK>1` per-id state machine). A member must be present for
-    //    ENTER_FRAMES consecutive frames to enter the framed set and absent for
-    //    LEAVE_FRAMES to leave, so a member flickering at the boundary doesn't
-    //    toggle the framing. The deadzone (cameraPath = the geometric-deadzone
-    //    stabilizer) stabilizes PAN; this stabilizes set MEMBERSHIP. Lifted
-    //    verbatim, so `inThisFrame`/`everIn`/`usedFallback` are byte-identical.
-    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++;
-    // A short clip can end before any member clears the ENTER debounce; fall back
-    // to the full framed set so the group is still framed (never center-hold a
-    // clip that has a clear dominant subject just because it's brief). When that
-    // fallback fires, treat every present framed id as "in" for the box/centroid.
-    const groupIds = everIn.size > 0 ? [...everIn] : framedIds;
-    // 4. PER-FRAME tracking target + union box. For each frame, take the framed
-    //    members PRESENT this frame, build their area-weighted centroid (the crop
-    //    target that frame) and their union bbox (the RequiredRegion source). The
-    //    camera now FOLLOWS the framed group as it moves — Phase 3's deadzone +
-    //    Hamming window in cameraPath turn this raw per-frame target into a held-
-    //    then-glide path. Frames where no framed member is present → null box +
-    //    null center, gap-filled consistently below (so a leading warmup frame is
-    //    byte-identical to the first resolved frame — no float-drifted seed).
-    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; // null box + null center → gap-filled below
-        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;
-    }
-    // Gap-fill the per-frame centers for the SubjectSetResult.centers field (the
-    // diagnostic/legacy crop-target basis). Leading gap borrows the first known
-    // center; interior/trailing gaps hold the last known one. (cameraPath does its
-    // OWN shot-scoped forward-fill on the regions; this fill is only so `.centers`
-    // is a complete series for direct callers / the synthetic tests.) When NO
-    // frame ever resolved → the held representative centroid → else source center.
-    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,
-    };
-}
-/**
- * Return the largest face this frame (the active-speaker degrade + the empty
- * authored-id fallback — mirror of `resolveSubjectFaces`'s largest-face path).
- */
-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;
-}
-/**
- * The `topK=1` subjects adapter for `face` / `active-speaker`. Per frame, resolve
- * the single chosen subject and emit its source-normalized box. Pure over the
- * segment-local slice.
- *
- *  - `face` (authored id): the box of that STABLE tracker id this frame; absent →
- *    null (no silent snap to a different person — the roster rule). The empty /
- *    non-`face-` sentinel id resolves to the largest face (legacy callers).
- *  - `active-speaker`: the box of the per-keyframe speaker pick when tracked this
- *    frame; otherwise the largest face this frame (the ASD degrade, mirror of
- *    `deriveSegment`'s active-speaker path).
- */
-export 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) {
-            // The per-keyframe speaker pick, when tracked this frame (mirror of
-            // deriveSegment's active-speaker nearest-keyframe lookup).
-            const sp = nearestSpeaker(i);
-            if (sp && tracked[sp])
-                chosenId = sp;
-        }
-        if (chosenId === null) {
-            // face: the authored id (when present this frame); else (active-speaker with
-            // no ASD pick, or the largest-face sentinel) the largest face — the existing
-            // degrade.
-            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 };
-}

package/dist/_members/core/select/errorCodes.js

@@ -1,38 +0,0 @@
-/**
- * select/errorCodes.ts — the Selector error vocabulary, as VALUES.
- *
- * Every code the Selector core / adapters / lowerings can throw (now or in a
- * later phase) is listed here as a literal value, and the registry-membership CI
- * test (`__tests__/selectorErrorRegistry.test.ts`) imports THIS list and asserts
- * each exists in `@cueframe/errors`'s `ERROR_CODES`. Importing the codes as VALUES
- * (not grepping literals) means a template/variable code can't slip past — an
- * unregistered code would make the CFERR decode fall back to `internal_error` and
- * 500 (the `clip_source_track_mismatch` landmine).
- *
- * Phase 1 (this phase) registers all of these even though only the CORE codes
- * (`selector_signal_absent`, `selector_override_conflict`) are thrown today; the
- * adapter/lowering codes (`selector_timebase_undefined`, `selector_group_unsynced`,
- * `selector_segment_out_of_media`) are thrown by the Phase-2 switch adapters and
- * are registered now so they can never 500 when that phase lands. Phase 3
- * (active-speaker) adds `selector_speaking_double_count` — the structural double-
- * count guard (§11-L5): weighting both `activeSpeaker` and `speaking` fails loud.
- * Phase 6 (cross-source identity) adds `selector_identity_detector_version_mismatch`
- * — a `lockPersonId` match over a STALE-detector-version embedding fails loud (the
- * 3-stamp lesson: a person-lock cosine over embeddings from a different
- * `DETECTOR_VERSION` than the reference is meaningless; refuse rather than guess).
- */
-/** The error codes the Selector layer is allowed to throw. Each MUST be a row in
- *  `@cueframe/errors` `ERROR_CODES` (asserted in CI). */
-export const SELECTOR_ERROR_CODES = [
-    // CORE (thrown in Phase 1):
-    'selector_signal_absent',
-    'selector_override_conflict',
-    // ADAPTER / LOWERING (registered now, thrown in Phase 2 switch):
-    'selector_timebase_undefined',
-    'selector_group_unsynced',
-    'selector_segment_out_of_media',
-    // ADAPTER (Phase 3 active-speaker — the structural double-count guard, §11-L5):
-    'selector_speaking_double_count',
-    // ADAPTER (Phase 6 cross-source identity — the stale-embedding version guard):
-    'selector_identity_detector_version_mismatch',
-];

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

@@ -1,26 +0,0 @@
-/**
- * @cueframe/core/select — the durable Selector core (selector-abstraction spec).
- *
- * The candidate-agnostic data model + the ~40-line `select()` scoring contract +
- * the per-kind `stabilize` seam. Reframe is its first instance (the subjects
- * adapter lives in `render/vcam/subjectSet.ts`, which calls `scoreAndRank` +
- * `stabilizeSelectionHysteresis` and lowers via the sealed `cameraPath`).
- *
- * Switch (Phase 2) is the second instance — same core, new candidate adapter +
- * the incumbent-challenger/presence-gate stabilizers + the cut/overlay lowering.
- */
-export { HOLD } from './model';
-export { select, scoreAndRank } from './select';
-export { stabilizeSelectionHysteresis, stabilizeIncumbentChallenger, stabilizePresenceGate, cameraPath, } from './stabilize';
-export { SELECTOR_ERROR_CODES } from './errorCodes';
-/** The default prominence weights — vcam's `DOMINANCE_WEIGHTS`, re-exported as the
- *  canonical "dominant-subject" `policy.weights` for the SCORE combinator. The
- *  switch instance's video-on-prominence path uses these directly (spec §9.1 P2 —
- *  "video-switch on prominence = vcam dominance, exists"); reframe uses the same
- *  constant. Re-exporting it here keeps the scoring default in the select surface.
- *  (This import is in index.ts, NOT select.ts — the rot-guard scans select.ts.) */
-export { DOMINANCE_WEIGHTS } from '../render/vcam/constants';
-/** The Selector engine version (spec §8). DISTINCT from BAKE_VERSION (the crop
- *  lowering stamp) and the per-signal stamps. Bump when the scoring/stabilizer
- *  math changes in a way that changes the Advisory for fixed inputs. */
-export const SELECTOR_VERSION = 'selector-core-v1-2026.06.21';

package/dist/_members/core/select/model.js

@@ -1,18 +0,0 @@
-/**
- * select/model.ts — the candidate-agnostic data model for the Selector core.
- *
- * Four nouns (selector-abstraction spec §1): Candidate, Signal, SelectorPolicy,
- * Advisory. The CORE (`select.ts`) scores over these and reads ONLY `candidateId`,
- * `Signal.value/confidence`, and `policy` — NEVER `Candidate.kind`,
- * `Candidate.timebase`, or any geometry (the §8 rot-guard, enforced by a test AND
- * by `select()` receiving a projected `CoreCandidate`, not the full `Candidate`).
- *
- * Plain TS (no zod): the core package has no zod dependency and the vcam math it
- * generalizes is plain TS. The spec's zod schemas describe the SHAPE; the fail-
- * loud invariants live in `select.ts` as explicit guards (no silent fallbacks —
- * `feedback_never_add_fallbacks`).
- */
-/** The held/abstain sentinel — first-class, not a magic empty (spec §1.4 step 3).
- *  Lowers per kind: sources → stay on incumbent/primary, no cut; subjects →
- *  center-hold the crop. */
-export const HOLD = '__hold__';