@cueframe/kernel 0.1.0 → 0.1.1

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

@@ -1,244 +0,0 @@
-/**
- * select/select.ts — THE durable Selector core (~40 lines of selection logic).
- *
- * `select(candidates, policy, opts) → Advisory`: a candidate-agnostic
- * `score → stabilize-selection → advise` contract (selector-abstraction spec
- * §1.4). It is the generalization of vcam's `dominance()` ranking (§2): a
- * weighted-sum combinator + an eligibility-gate predicate + topK membership + a
- * first-class `__hold__`/abstain + the override ladder + reasons surfacing.
- *
- * THE ROT-GUARD (spec §8, the most important invariant): this module reads ONLY
- * `CoreCandidate.id`, `CandidateSignals[*].value/confidence`, and `policy` — it
- * NEVER references `Candidate.kind`, `Candidate.timebase`, or any geometry. It is
- * typed against `CoreCandidate` (id + signals), NOT the full `Candidate`, so the
- * adapter MUST do the projection and the core STRUCTURALLY cannot branch on kind.
- * A structural test (`__tests__/rotGuard.test.ts`) asserts this module imports no
- * geometry/kind types and references none of those fields.
- *
- * The selection STABILIZER (continuity over time) is NOT here — it is a per-kind
- * seam (`stabilize.ts`): `select()` produces the per-moment scored advisory; the
- * stabilizer (selection-hysteresis | geometric-deadzone | …) is dispatched per
- * kind by the adapter. This split is L1 of the spec, stated honestly.
- *
- * Pure, deterministic. No I/O, no Date.now, no Map-order reads in the math.
- */
-import { CueframeError, encodeError } from '@cueframe/errors';
-import { HOLD } from './model';
-/** Throw a registered fail-loud error (no silent fallback —
- *  `feedback_never_add_fallbacks`). */
-function fail(code, message, fix) {
-    throw new Error(encodeError(new CueframeError(code, message, fix)));
-}
-/** Does a candidate's signal envelope satisfy a single clause at this moment?
- *  Geometry-free: reads `signal value ≥ gte` and (adapter-projected) role match.
- *  `role`/`topicMatches` are matched against a projected `roleTag` the adapter
- *  folds into a synthetic signal — the core itself never reads `Candidate.role`. */
-function clauseHolds(sig, clause) {
-    if (clause.signal !== undefined) {
-        const s = sig[clause.signal];
-        if (s === undefined)
-            return false;
-        if (clause.gte !== undefined && s.value < clause.gte)
-            return false;
-    }
-    return true;
-}
-/** AND-of-clauses (eligibility) / a rule's `when` (all = AND, any = OR). */
-function whenHolds(sig, when) {
-    const all = when.all ?? [];
-    const any = when.any ?? [];
-    if (all.length > 0 && !all.every((c) => clauseHolds(sig, c)))
-        return false;
-    if (any.length > 0 && !any.some((c) => clauseHolds(sig, c)))
-        return false;
-    return true;
-}
-/** The per-moment weighted score `Σ_k weights[k]·signal[k].value·confidence`,
- *  with each weighted term recorded for legibility. The weight-key iteration
- *  order is the CALLER'S (adapter-supplied) order — for the reframe instance the
- *  subjects adapter supplies `{size,centrality,persistence,speaking}` in exactly
- *  vcam's `dominance()` order, so the float sum is byte-identical (the byte-
- *  equivalence acceptance bar). */
-function scoreCandidate(id, sig, weightKeys, weights, ruleBoost) {
-    const contributions = {};
-    let score = 0;
-    for (const k of weightKeys) {
-        const w = weights[k];
-        const s = sig[k];
-        // A weight over an ALL-ABSENT signal is fail-loud upstream (preflight); here
-        // an absent signal at a single moment contributes 0 (the candidate simply
-        // isn't measured on that axis this tick), NOT a silent default for the whole
-        // run.
-        const v = s ? s.value * (s.confidence ?? 1) : 0;
-        const term = w * v;
-        contributions[k] = term;
-        score += term;
-    }
-    score += ruleBoost;
-    return { candidateId: id, score, contributions };
-}
-/**
- * The core selection over an already-aligned grid. Produces a per-TICK scored
- * advisory (one `SelectorSegment` per tick, tiling the timeline). The per-kind
- * stabilizer (`stabilize.ts`) then coalesces ticks under hysteresis/deadzone and
- * surfaces holds — this function is the SCORE half only.
- *
- * Override ladder (spec §1.4 step 1, ONE ordered evaluation):
- *   tier 0 overrides[] (hard span pin) > tier 1 lock* > tier 2 force rule >
- *   tier 3 weighted score + eligibility + floor/__hold__.
- * A SAME-TIER conflict (two overlapping overrides, or two firing force rules at
- * one tick) FAILS LOUD (`selector_override_conflict` — the Gap.strict() lesson).
- */
-export function select(candidates, policy, opts) {
-    const { dtSec, ticks } = opts;
-    const ids = candidates.map((c) => c.id);
-    const idSet = new Set(ids);
-    // Preflight: a weighted signal that is ABSENT for EVERY candidate at EVERY tick
-    // is fail-loud (a weight that can never contribute — the agent mis-wired the
-    // policy). This is the spec's `selector_signal_absent` (§1.2/§8).
-    const weightKeys = Object.keys(policy.weights).filter((k) => (policy.weights[k] ?? 0) > 0);
-    for (const k of weightKeys) {
-        let measured = false;
-        for (const c of candidates) {
-            for (const env of c.signals)
-                if (env[k] !== undefined) {
-                    measured = true;
-                    break;
-                }
-            if (measured)
-                break;
-        }
-        if (!measured) {
-            fail('selector_signal_absent', `weight on signal '${k}' but no candidate measures it at any moment`, { signal: k });
-        }
-    }
-    // Validate override/lock ids exist (unknown id REJECTED, never remapped).
-    for (const o of policy.overrides ?? []) {
-        if (!idSet.has(o.candidateId))
-            fail('selector_override_conflict', `override candidateId '${o.candidateId}' not in roster`, { candidateId: o.candidateId });
-    }
-    const rules = policy.rules ?? [];
-    const eligibility = policy.eligibility ?? [];
-    const floor = policy.floor ?? {};
-    const segments = new Array(ticks);
-    for (let t = 0; t < ticks; t++) {
-        const startSec = t * dtSec;
-        const endSec = (t + 1) * dtSec;
-        const tSec = startSec; // a span is "covered" by an override iff its start is inside
-        // ── Tier 0: hard span overrides (fail loud on same-tier overlap). ──────────
-        const hits = (policy.overrides ?? []).filter((o) => tSec >= o.startSec && tSec < o.endSec);
-        if (hits.length > 1) {
-            fail('selector_override_conflict', `two overlapping overrides at ${tSec}s: ${hits.map((h) => h.candidateId).join(', ')}`, { atSec: tSec });
-        }
-        if (hits.length === 1) {
-            segments[t] = pinned(startSec, endSec, hits[0].candidateId, 'override', 'override span');
-            continue;
-        }
-        // ── Tier 1: lock (camera/candidate pin). ───────────────────────────────────
-        if (policy.lockSourceId && idSet.has(policy.lockSourceId)) {
-            segments[t] = pinned(startSec, endSec, policy.lockSourceId, 'lock', `locked to '${policy.lockSourceId}'`);
-            continue;
-        }
-        // ── Tier 3 prep: eligibility filter + rule boosts (geometry-free). ─────────
-        const sigAt = (c) => c.signals[t] ?? {};
-        const eligible = candidates.filter((c) => eligibility.length === 0 || eligibility.every((cl) => clauseHolds(sigAt(c), cl)));
-        const ruleBoostFor = (c) => {
-            let boost = 0;
-            const forces = [];
-            for (const r of rules) {
-                const fires = whenHolds(sigAt(c), r.when) && rulePrefers(r, c.id);
-                if (!fires)
-                    continue;
-                if (r.then.force)
-                    forces.push(r);
-                boost += r.then.boost ?? 0.3;
-            }
-            return { boost, forces };
-        };
-        // ── Tier 2: force rules (fail loud on two distinct forced candidates). ─────
-        const forcedIds = new Set();
-        for (const c of eligible) {
-            const { forces } = ruleBoostFor(c);
-            if (forces.length > 0)
-                forcedIds.add(c.id);
-        }
-        if (forcedIds.size > 1) {
-            fail('selector_override_conflict', `two force rules elect different candidates at ${tSec}s: ${[...forcedIds].join(', ')}`, { atSec: tSec });
-        }
-        if (forcedIds.size === 1) {
-            const fid = [...forcedIds][0];
-            const scored = scoreAll(eligible, sigAt, weightKeys, policy.weights, ruleBoostFor);
-            segments[t] = { startSec, endSec, chosen: fid, alsoChosen: [], perCandidateScores: scored, reasons: [`force rule → '${fid}'`], pacingNote: 'rule' };
-            continue;
-        }
-        // ── Tier 3: weighted score + floor/__hold__ + topK membership. ─────────────
-        const scored = scoreAll(eligible, sigAt, weightKeys, policy.weights, ruleBoostFor);
-        // Floor: if no eligible candidate has ANY contributing signal at/above its
-        // floor, elect __hold__ (abstain — forcing a pick on nothing is autopilot
-        // bias, G8). A candidate clears the floor iff every floored signal it has is
-        // ≥ its floor AND at least one floored signal is present (an empty floor →
-        // never holds, the reframe default).
-        const floorKeys = Object.keys(floor);
-        const anyAboveFloor = floorKeys.length === 0 ||
-            eligible.some((c) => {
-                const sig = sigAt(c);
-                return floorKeys.some((k) => sig[k] !== undefined && sig[k].value >= (floor[k] ?? 0));
-            });
-        if (eligible.length === 0 || !anyAboveFloor) {
-            segments[t] = { startSec, endSec, chosen: HOLD, alsoChosen: [], perCandidateScores: scored, reasons: floorKeys.length && eligible.length ? ['no candidate above floor'] : ['no eligible candidate'], pacingNote: 'hold' };
-            continue;
-        }
-        // topK membership: the top-K by score (stable id tiebreak — deterministic).
-        const k = Math.max(1, policy.topK);
-        const top = scored.slice(0, k);
-        segments[t] = {
-            startSec,
-            endSec,
-            chosen: top[0].candidateId,
-            alsoChosen: top.slice(1).map((s) => s.candidateId),
-            perCandidateScores: scored,
-            reasons: [`argmax score ${top[0].score.toFixed(4)}`],
-            pacingNote: 'argmax',
-        };
-    }
-    return segments;
-}
-function pinned(startSec, endSec, id, note, reason) {
-    return { startSec, endSec, chosen: id, alsoChosen: [], perCandidateScores: [], reasons: [reason], pacingNote: note };
-}
-function rulePrefers(r, id) {
-    // A rule with no preference target applies to all candidates; a targeted rule
-    // applies only to its candidate (role-targeting is folded by the adapter).
-    if (r.then.preferCandidateId !== undefined)
-        return r.then.preferCandidateId === id;
-    return true;
-}
-function scoreAll(cands, sigAt, weightKeys, weights, ruleBoostFor) {
-    const scored = cands.map((c) => scoreCandidate(c.id, sigAt(c), weightKeys, weights, ruleBoostFor(c).boost));
-    return sortScores(scored);
-}
-/** Sort desc by score, then stable id tiebreak — the EXACT vcam `dominance`
- *  ranking tiebreak (byte-equivalence-preserving for the reframe pool ranking). */
-function sortScores(scored) {
-    scored.sort((a, b) => {
-        if (b.score !== a.score)
-            return b.score - a.score;
-        return a.candidateId < b.candidateId ? -1 : a.candidateId > b.candidateId ? 1 : 0;
-    });
-    return scored;
-}
-/**
- * The shared scoring COMBINATOR as a pure ONE-SHOT ranking primitive — the
- * durable `Σ weights·signal` win (spec §2). Both the per-tick `select()` (switch)
- * and the reframe's segment-wide pool ranking call this, so there is ONE scoring
- * implementation. `weightKeys` is the CALLER's iteration order: the reframe
- * subjects adapter passes `{size,centrality,persistence,speaking}` in vcam's
- * `DOMINANCE_WEIGHTS` order, so the float sum is byte-identical to `dominance()`.
- *
- * Reads ONLY `id` + `signals.value/confidence` + `weights` — the rot-guard holds.
- */
-export function scoreAndRank(candidates, weights) {
-    const weightKeys = Object.keys(weights);
-    const scored = candidates.map((c) => scoreCandidate(c.id, c.signals, weightKeys, weights, 0));
-    return sortScores(scored);
-}

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

@@ -1,242 +0,0 @@
-/**
- * select/stabilize.ts — the continuity/selection STABILIZER seam (spec §1.4 step
- * 4 + L1). The scoring (`select.ts`) generalizes cleanly; the stabilizer does
- * NOT — it is THREE kinds behind ONE `stabilize(kind, …)` seam, dispatched per
- * kind by the adapter. This is the honest "build a small fixed set of per-kind
- * stabilizers," not "one function" (L1; the prior draft's "selection-hysteresis
- * generalizes verbatim" claim is retracted).
- *
- * Phase 1 implements the two kinds reframe needs:
- *   - `selection-hysteresis` — the per-id set-MEMBERSHIP state machine (the
- *     `topK>1` reframe stabilizer), lifted VERBATIM from `vcam/subjectSet.ts`
- *     (`inset`/`presRun`/`absRun` + the short-clip `usedFallback` bypass). Pure;
- *     byte-equivalence-preserving.
- *   - `geometric-deadzone` — `vcam/cameraPath.ts`, lifted VERBATIM and SEALED
- *     (deadzone inclusion invariant + Hamming + glide cap). Re-exported, NEVER
- *     altered — perturbing its math risks the shipped `inclusionRate ≈ 1.0` (L1).
- *
- * Phase 2 (switch) adds `incumbent-challenger` (topK=1 + switchMargin — NEW code,
- * vcam has no incumbent concept) and `presence-gate` (overlay binary show/hide).
- * Their seams are declared here so the dispatch shape is fixed; they fail loud
- * until built (no silent stub — `feedback_never_add_fallbacks`).
- */
-/**
- * The per-id set-MEMBERSHIP hysteresis state machine — the `topK>1` selection
- * stabilizer (spec §1.4 step 4; §2 maps it as CORE for reframe's membership).
- * Lifted VERBATIM from `vcam/subjectSet.ts:306-343`: each member enters after
- * `enterFrames` consecutive present frames and leaves after `leaveFrames` absent
- * frames — independent per-id booleans. A member is FRAMED this frame iff it is
- * IN the set AND present this frame.
- *
- * `usedFallback` is the short-segment bypass: a segment that ends before any
- * member clears the ENTER debounce uses the static framed set (so a brief clip
- * with a clear dominant subject is still framed, never center-held — the spec's
- * `minSegmentForHysteresis` bypass).
- *
- * Pure. Byte-identical to the inline vcam logic — `framedIds` order drives the
- * per-frame `here` order, so the adapter must pass ids in dominance order.
- */
-export function stabilizeSelectionHysteresis(framedIds, presence, n, params) {
-    const { enterFrames, leaveFrames } = params;
-    const everIn = new Set();
-    const inset = new Map(framedIds.map((id) => [id, false]));
-    const presRun = new Map(framedIds.map((id) => [id, 0]));
-    const absRun = new Map(framedIds.map((id) => [id, 0]));
-    const inThisFrame = new Array(n);
-    for (let i = 0; i < n; i++) {
-        const here = [];
-        for (const id of framedIds) {
-            if (presence(id, i)) {
-                presRun.set(id, presRun.get(id) + 1);
-                absRun.set(id, 0);
-            }
-            else {
-                absRun.set(id, absRun.get(id) + 1);
-                presRun.set(id, 0);
-            }
-            if (!inset.get(id) && presRun.get(id) >= enterFrames)
-                inset.set(id, true);
-            if (inset.get(id) && absRun.get(id) >= leaveFrames)
-                inset.set(id, false);
-            if (inset.get(id) && presence(id, i)) {
-                here.push(id);
-                everIn.add(id);
-            }
-        }
-        inThisFrame[i] = here;
-    }
-    return { everIn, inThisFrame, usedFallback: everIn.size === 0 };
-}
-// ── geometric-deadzone (Phase 1) ─────────────────────────────────────────────
-// `cameraPath` is the geometric-deadzone continuity stabilizer, lifted VERBATIM
-// and SEALED. It is NOT re-implemented here — it is re-exported from its sealed
-// home so the dispatch surface names it without touching its math.
-export { cameraPath } from '../render/vcam/cameraPath';
-/**
- * The incumbent/challenger selection stabilizer — the `topK=1` (switch cut)
- * anti-ping-pong machine (spec §1.4 step 4, NEW code; L1). Inputs are the per-tick
- * RAW winner id (the score argmax for that tick) and the per-tick scores by id, so
- * the stabilizer is candidate-AGNOSTIC (it reads ids + scalars + policy knobs).
- *
- * Rule (spec §3.2 + §1.3 knobs):
- *   - A challenger replaces the incumbent ONLY IF it leads the incumbent by
- *     `switchMargin` for `enterFrames` CONTINUOUS ticks AND the incumbent has held
- *     ≥ `minHoldFrames`.
- *   - `cooldownFrames` forbids re-entering the just-left incumbent for that long.
- *   - `maxHoldFrames` (optional) forces the incumbent to yield to the best
- *     challenger after that many held ticks even without a margin lead.
- *   - A `__hold__` raw winner (no candidate above floor) holds the incumbent (the
- *     source lowering: "stay on the incumbent, emit no cut").
- *
- * `scoreById(id, t)` returns the candidate's score at tick t (0 if not scored).
- * Pure. Deterministic — no Date, no Map-order math.
- */
-export function stabilizeIncumbentChallenger(rawWinnerPerTick, scoreById, n, params) {
-    const { minHoldFrames, enterFrames, switchMargin, cooldownFrames, maxHoldFrames } = params;
-    const chosenPerTick = new Array(n);
-    const suppressed = [];
-    if (n === 0)
-        return { chosenPerTick, suppressed };
-    // Seed the incumbent with the first tick's raw winner (a __hold__ first tick
-    // means there is no incumbent yet — the first concrete winner seeds it).
-    let incumbent = null;
-    let heldFrames = 0;
-    // Per-challenger continuous-lead run length (reset when the lead breaks).
-    const leadRun = new Map();
-    // Cooldown: the id just dethroned → ticks remaining before it may re-enter.
-    let cooldownId = null;
-    let cooldownLeft = 0;
-    for (let t = 0; t < n; t++) {
-        const raw = rawWinnerPerTick[t];
-        if (incumbent === null) {
-            // No incumbent yet: adopt the first concrete (non-hold) raw winner.
-            if (raw !== HOLD_ID) {
-                incumbent = raw;
-                heldFrames = 1;
-            }
-            chosenPerTick[t] = incumbent ?? raw; // raw is HOLD here if still unseeded
-            if (cooldownLeft > 0)
-                cooldownLeft--;
-            continue;
-        }
-        const incScore = scoreById(incumbent, t);
-        // Find the best challenger (the highest-scoring id that is NOT the incumbent
-        // and is not in cooldown). The raw winner is the global argmax; if it equals
-        // the incumbent there is no challenger this tick.
-        let challenger = null;
-        let challengerScore = -Infinity;
-        if (raw !== HOLD_ID && raw !== incumbent) {
-            challenger = raw;
-            challengerScore = scoreById(raw, t);
-        }
-        // Update each challenger's continuous-lead run.
-        if (challenger !== null && challengerScore >= incScore + switchMargin) {
-            leadRun.set(challenger, (leadRun.get(challenger) ?? 0) + 1);
-        }
-        // Any id that is NOT a margin-leading challenger this tick loses its run.
-        for (const id of [...leadRun.keys()]) {
-            if (id !== challenger || challengerScore < incScore + switchMargin)
-                leadRun.set(id, 0);
-        }
-        const leadFrames = challenger !== null ? (leadRun.get(challenger) ?? 0) : 0;
-        const inCooldown = challenger !== null && challenger === cooldownId && cooldownLeft > 0;
-        // Forced variety: maxHold reached → yield to the best challenger (margin
-        // waived). Without a challenger this tick, keep holding (nothing to yield to).
-        const maxHoldHit = maxHoldFrames !== undefined && heldFrames >= maxHoldFrames && challenger !== null && !inCooldown;
-        const eligibleToSwitch = challenger !== null &&
-            !inCooldown &&
-            (maxHoldHit || (heldFrames >= minHoldFrames && leadFrames >= enterFrames));
-        if (eligibleToSwitch) {
-            // Dethrone: the old incumbent enters cooldown.
-            cooldownId = incumbent;
-            cooldownLeft = cooldownFrames;
-            incumbent = challenger;
-            heldFrames = 1;
-            leadRun.clear();
-        }
-        else {
-            // Hold. If there WAS a margin-leading challenger we blocked, surface it.
-            if (challenger !== null && challengerScore > incScore) {
-                const blockedBy = inCooldown
-                    ? 'cooldown'
-                    : challengerScore < incScore + switchMargin
-                        ? 'switch-margin'
-                        : heldFrames < minHoldFrames
-                            ? 'min-hold'
-                            : 'enter-debounce';
-                const releaseAtTick = blockedBy === 'min-hold'
-                    ? t + (minHoldFrames - heldFrames)
-                    : blockedBy === 'cooldown'
-                        ? t + cooldownLeft
-                        : null;
-                suppressed.push({ atTick: t, wouldHaveBeenId: challenger, byScore: challengerScore - incScore, blockedBy, releaseAtTick });
-            }
-            heldFrames++;
-        }
-        chosenPerTick[t] = incumbent;
-        if (cooldownLeft > 0)
-            cooldownLeft--;
-    }
-    return { chosenPerTick, suppressed };
-}
-/** The abstain sentinel, mirrored here so the stabilizer can recognize a held
- *  tick without importing the model (keeps the stabilizer model-free at runtime;
- *  the value is the same literal as `model.HOLD`). */
-const HOLD_ID = '__hold__';
-/**
- * The presence-gate stabilizer — overlay binary show/hide (spec §6.2 + L1, NEW
- * code). Overlay is ADDITIVE (the primary is always underneath; there is no
- * incumbent to dethrone), so this is NOT incumbent/challenger: it is a per-
- * candidate binary "is this overlay on?" with min-on (no blink-out) and min-gap
- * (no re-trigger flicker) hysteresis.
- *
- * `wantOnPerTick[t]` is the candidate id the adapter wants overlaid at tick t (the
- * floor-cleared winner), or `__hold__` for "no overlay this tick" (primary alone).
- * Output: coalesced ON windows per candidate, after the min-on / min-gap debounce.
- *
- * Reads ONLY ids + policy knobs (the rot-guard holds). Pure + deterministic.
- */
-export function stabilizePresenceGate(wantOnPerTick, n, params) {
-    const { minOnFrames, minGapFrames } = params;
-    const windows = [];
-    if (n === 0)
-        return windows;
-    let activeId = null;
-    let activeStart = 0;
-    // Last OFF tick per candidate (for the min-gap check) — the tick AFTER its last
-    // ON window ended.
-    const lastOffTick = new Map();
-    const closeActive = (endTick) => {
-        if (activeId !== null) {
-            windows.push({ candidateId: activeId, startTick: activeStart, endTick });
-            lastOffTick.set(activeId, endTick);
-            activeId = null;
-        }
-    };
-    for (let t = 0; t < n; t++) {
-        const want = wantOnPerTick[t];
-        if (activeId !== null) {
-            const heldFrames = t - activeStart;
-            if (want === activeId) {
-                continue; // stay on
-            }
-            // Want to turn this one off (either a different candidate or __hold__). Honor
-            // min-on: don't close before minOnFrames have elapsed.
-            if (heldFrames < minOnFrames)
-                continue; // extend the ON window through min-on
-            closeActive(t);
-            // fall through to (possibly) start a new candidate this same tick
-        }
-        if (want !== HOLD_ID) {
-            // Want this candidate ON. Honor min-gap from its OWN previous OFF.
-            const off = lastOffTick.get(want);
-            if (off !== undefined && t - off < minGapFrames) {
-                continue; // too soon to re-trigger this candidate; stay off
-            }
-            activeId = want;
-            activeStart = t;
-        }
-    }
-    closeActive(n);
-    return windows;
-}

package/dist/_members/core/types.js

@@ -1,7 +0,0 @@
-// ============ Project Types ============
-export {};
-// ============ Brand Kit Types ============
-// Moved to @cueframe/composition/brand-kit (Phase-3 Slice 1 — decouple authoring
-// from the renderer; brand is a composition-level fact). Reconcile with the
-// render-side BrandKit (@cueframe/composition/validators) + ResolvedBrandKit
-// (@cueframe/composition/projection) in Phase 4.

package/dist/_members/errors/index.js

@@ -1 +0,0 @@
-export * from "./registry";