@cueframe/kernel 0.0.1

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

@@ -0,0 +1,388 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 declare const SELECTOR_ERROR_CODES: readonly ["selector_signal_absent", "selector_override_conflict", "selector_timebase_undefined", "selector_group_unsynced", "selector_segment_out_of_media", "selector_speaking_double_count", "selector_identity_detector_version_mismatch"];
+export type SelectorErrorCode = (typeof SELECTOR_ERROR_CODES)[number];

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

@@ -0,0 +1,38 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 type { SignalKey, Signal, CandidateSignals, Candidate, CandidateTimebase, CoreCandidate, WhenClause, EligibilityClause, SelectorRule, OverrideSpan, SelectorPolicy, Chosen, CandidateScore, PacingNote, SelectorSegment, Advisory, } from './model.js';
+export { HOLD } from './model.js';
+export { select, scoreAndRank, type SelectOptions } from './select.js';
+export { stabilizeSelectionHysteresis, stabilizeIncumbentChallenger, stabilizePresenceGate, cameraPath, type StabilizerKind, type SelectionHysteresisParams, type SelectionHysteresisResult, type IncumbentChallengerParams, type IncumbentChallengerResult, type SuppressedSwitch, type PresenceGateParams, type PresenceWindow, type CropWindow, } from './stabilize.js';
+export { SELECTOR_ERROR_CODES, type SelectorErrorCode } from './errorCodes.js';
+/** 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.js';
+/** 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 declare const SELECTOR_VERSION = "selector-core-v1-2026.06.21";

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

@@ -0,0 +1,26 @@
+/**
+ * @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';