2sagaco48 1.0.0

package/src/lib/sage/reality-grounding.ts

@@ -0,0 +1,380 @@
+/**
+ * REALITY GROUNDING SYSTEM — abstract ⇄ documentary-real control axis.
+ * ---------------------------------------------------------------------------
+ * Type C net-new. A single user-selected integer 0..6 that STRICTLY constrains
+ * what the fiction engine may put on the page. This is not a tone hint: each
+ * level emits hard PERMIT / FORBID clauses, a causality contract, a sensory
+ * specificity floor, and a verification register that are injected directly
+ * into the per-chapter prompt.
+ *
+ * RUNTIME HONESTY
+ * - Pure, deterministic, offline. No LLM, no network, no storage side effects.
+ * - The engine cannot *force* an LLM to obey; it can only (a) state the
+ *   constraint unambiguously, (b) forbid the specific failure modes by name,
+ *   and (c) run a real local post-hoc audit that flags violations. Both the
+ *   directive and the audit are implemented here. The audit is lexical, so it
+ *   detects surface violations, not every semantic one — declared, not hidden.
+ */
+
+export type RealityLevelId = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export type RealityLevel = {
+  id: RealityLevelId;
+  key: string;
+  label: string;
+  short: string;
+  /** one-line description shown next to the slider */
+  blurb: string;
+  /** what the prose MAY contain */
+  permit: string[];
+  /** what the prose MUST NOT contain — enforced by name */
+  forbid: string[];
+  /** how cause→effect must behave */
+  causality: string;
+  /** concrete-detail floor per scene */
+  sensoryFloor: string;
+  /** how claims inside the fiction are evidenced */
+  register: string;
+  /** metaphor budget: max simile/metaphor per 100 words (0 = none) */
+  figurativePer100w: number;
+  /** how much unexplained phenomena is allowed, 0..1 */
+  unexplainedTolerance: number;
+  /** required proper-noun / measurement density per 1000 words */
+  specificityPer1000w: number;
+  accent: string;
+};
+
+export const REALITY_LEVELS: readonly RealityLevel[] = [
+  {
+    id: 0,
+    key: "MYTHIC_ABSTRACT",
+    label: "Mythic / Abstract",
+    short: "Mythic",
+    blurb: "Archetypal. Physics is symbolic. Figures may be forces rather than people.",
+    permit: [
+      "impossible geography, symbolic physics, talking elements, unnamed archetypal figures",
+      "time that folds, repeats, or runs at emblematic speed",
+      "events whose meaning outranks their mechanism",
+    ],
+    forbid: [
+      "modern procedural detail that anchors the tale to one dated bureaucracy",
+      "clinical brand names, model numbers, or statistics presented as fact",
+    ],
+    causality: "Cause may be moral or symbolic rather than physical; consequence must still follow inevitably from the transgression or the vow.",
+    sensoryFloor: "At least one concrete physical image per scene so the abstraction has a body.",
+    register: "Assertion by narration. No sourcing, no documentation.",
+    figurativePer100w: 6,
+    unexplainedTolerance: 1.0,
+    specificityPer1000w: 2,
+    accent: "violet",
+  },
+  {
+    id: 1,
+    key: "SURREAL",
+    label: "Surreal",
+    short: "Surreal",
+    blurb: "Dream logic. Transformations need no explanation, but they must recur consistently.",
+    permit: [
+      "dream logic, uncanny transformation, non-sequitur adjacency",
+      "objects and rooms behaving as psychological states",
+    ],
+    forbid: [
+      "explaining the surreal element with a rational cause (a dream frame, a drug, a hoax)",
+      "treating the impossible as a puzzle to be solved",
+    ],
+    causality: "Local causality may break, but any broken rule must break the SAME way each time it appears.",
+    sensoryFloor: "Two concrete, mundane sensory details per scene to anchor the strangeness.",
+    register: "Assertion by narration. Contradiction is permitted if it is deliberate and recurring.",
+    figurativePer100w: 5,
+    unexplainedTolerance: 0.9,
+    specificityPer1000w: 3,
+    accent: "fuchsia",
+  },
+  {
+    id: 2,
+    key: "FABULIST",
+    label: "Fabulist",
+    short: "Fabulist",
+    blurb: "One clean impossible premise, worked out with rigorous internal logic.",
+    permit: [
+      "exactly ONE openly impossible premise, stated plainly and early",
+      "institutions and ordinary people reacting to that premise realistically",
+    ],
+    forbid: [
+      "a second unrelated impossibility",
+      "the impossible premise solving a problem it was not established to solve",
+    ],
+    causality: "One rule is suspended. Everything downstream of it obeys ordinary cause and effect, including cost and paperwork.",
+    sensoryFloor: "Ordinary-life texture in every scene: labour, money, food, weather, fatigue.",
+    register: "Assertion by narration for the premise; ordinary plausibility for everything else.",
+    figurativePer100w: 4,
+    unexplainedTolerance: 0.55,
+    specificityPer1000w: 6,
+    accent: "indigo",
+  },
+  {
+    id: 3,
+    key: "MAGIC_REALIST",
+    label: "Magic Realist",
+    short: "Magic-Real",
+    blurb: "The impossible is real, unremarked, and socially absorbed. No wonder, no explanation.",
+    permit: [
+      "the impossible treated as unremarkable by the characters",
+      "the marvellous embedded in domestic, civic and economic routine",
+    ],
+    forbid: [
+      "characters reacting with astonishment or investigating the marvellous",
+      "systematised 'magic rules' or a magic-system exposition",
+    ],
+    causality: "The marvellous has social and economic consequences even though nobody explains it. Consequence is mandatory; explanation is forbidden.",
+    sensoryFloor: "Every marvellous beat is paired with a mundane, verifiable detail in the same paragraph.",
+    register: "Flat declarative. The impossible receives the same sentence temperature as the weather.",
+    figurativePer100w: 3.5,
+    unexplainedTolerance: 0.45,
+    specificityPer1000w: 8,
+    accent: "sky",
+  },
+  {
+    id: 4,
+    key: "HEIGHTENED_REALIST",
+    label: "Heightened Realist",
+    short: "Heightened",
+    blurb: "Everything is physically possible, but coincidence and intensity run hot.",
+    permit: [
+      "improbable but physically possible events; charged coincidence; dramatic compression of time",
+      "heightened, stylised dialogue",
+    ],
+    forbid: [
+      "any event that violates physics, biology, or established law",
+      "supernatural agency of any kind, including ambiguous hints of it",
+    ],
+    causality: "Strict physical causality. Coincidence is allowed to start a problem but never to solve one.",
+    sensoryFloor: "Named places, specific times, working objects, and at least one concrete cost per scene.",
+    register: "Realist. Any factual claim a character makes must be something a person in that role could plausibly know.",
+    figurativePer100w: 3,
+    unexplainedTolerance: 0.15,
+    specificityPer1000w: 12,
+    accent: "teal",
+  },
+  {
+    id: 5,
+    key: "REALIST",
+    label: "Realist",
+    short: "Realist",
+    blurb: "Ordinary probability. Boring things take the time they actually take.",
+    permit: [
+      "only events with everyday probability; institutional friction, delay, and paperwork",
+      "unresolved and undramatic outcomes",
+    ],
+    forbid: [
+      "supernatural or impossible events",
+      "convenient coincidence at any turning point",
+      "expertise a character has no route to; instant mastery; money or transport appearing without account",
+    ],
+    causality: "Strict physical, legal, and economic causality. Every capability is paid for in time, money, training, or relationship.",
+    sensoryFloor: "Named specifics in every scene: place, hour, tool, quantity, price, or procedure.",
+    register: "Realist. Distances, durations, prices, and procedures must be internally consistent and plausible.",
+    figurativePer100w: 2,
+    unexplainedTolerance: 0.05,
+    specificityPer1000w: 18,
+    accent: "emerald",
+  },
+  {
+    id: 6,
+    key: "DOCUMENTARY",
+    label: "Documentary Real",
+    short: "Documentary",
+    blurb: "Procedural, evidence-forward, unornamented. Reads like reported fact.",
+    permit: [
+      "verifiable-sounding procedure, timestamps, measurements, forms, transcripts, and chains of custody",
+      "flat reportorial narration; direct quotation; source attribution inside the fiction",
+    ],
+    forbid: [
+      "any impossible or supernatural event",
+      "coincidence at a turning point",
+      "omniscient access to a mind the narrator could not have interviewed",
+      "lyrical or ornamental figuration; metaphor used for decoration",
+      "round, unsourced statistics presented as authoritative",
+    ],
+    causality: "Documented causality only. If a fact appears, the text shows how the narrator could know it — a document, a witness, an observation, or an admission.",
+    sensoryFloor: "Every scene carries a date or clock time, a named location, and at least one measured quantity with units.",
+    register: "Reportorial. Attribute inside the fiction ('the log recorded', 'she said', 'the invoice showed'). Prefer the specific to the general in every sentence.",
+    figurativePer100w: 0.5,
+    unexplainedTolerance: 0,
+    specificityPer1000w: 28,
+    accent: "zinc",
+  },
+] as const;
+
+export function realityLevel(id: number): RealityLevel {
+  const clamped = Math.max(0, Math.min(6, Math.round(id))) as RealityLevelId;
+  return REALITY_LEVELS[clamped];
+}
+
+/**
+ * The hard directive injected into every chapter prompt. Deliberately
+ * imperative and specific: named forbidden failure modes beat vague tone words.
+ */
+export function buildRealityDirective(id: number, opts?: { chapterWords?: number }): string {
+  const L = realityLevel(id);
+  const words = Math.max(300, opts?.chapterWords ?? 1200);
+  const figBudget = Math.max(0, Math.round((L.figurativePer100w * words) / 100));
+  const specBudget = Math.max(1, Math.round((L.specificityPer1000w * words) / 1000));
+
+  const lines = [
+    `REALITY GROUNDING — LEVEL ${L.id}/6: ${L.label.toUpperCase()}. This is a HARD CONSTRAINT and outranks genre, tone, and style. If any other instruction conflicts with it, obey this one.`,
+    `Stance: ${L.blurb}`,
+    `Causality contract: ${L.causality}`,
+    `Concrete-detail floor: ${L.sensoryFloor}`,
+    `Evidence register: ${L.register}`,
+    "PERMITTED in this chapter:",
+    ...L.permit.map((p) => `  - ${p}`),
+    "FORBIDDEN in this chapter — do not write these under any circumstance:",
+    ...L.forbid.map((p) => `  - ${p}`),
+    `Figurative budget: at most ${figBudget} simile(s)/metaphor(s) in this chapter (~${L.figurativePer100w} per 100 words). Prefer literal description.`,
+    `Specificity floor: at least ${specBudget} concrete specifics (named place, clock time, date, measured quantity with units, price, procedure, or proper noun) in this chapter.`,
+  ];
+
+  if (L.id >= 4) {
+    lines.push(
+      "Physical-plausibility check before you write each scene: could this happen to a real person, in a real body, under real law and real economics? If not, rewrite the beat until it could.",
+      "No character may acquire a skill, a document, money, or access without the text showing the cost and the route.",
+    );
+  }
+  if (L.id === 6) {
+    lines.push(
+      "Every scene must open with a locatable anchor: a date or clock time AND a named place.",
+      "Attribute every non-observed fact inside the fiction (a document, a witness, a recording, an admission). If it cannot be attributed, cut it.",
+      "Write plainly. No lyric flourish. Short declaratives. Numbers carry units.",
+    );
+  }
+  if (L.id <= 1) {
+    lines.push(
+      "Do not rationalise the impossible. No dream frame, no hallucination reveal, no hoax explanation.",
+    );
+  }
+  return lines.join("\n");
+}
+
+// ── Local post-hoc audit (real computation, lexical scope declared) ─────────
+
+export type RealityFinding = {
+  rule: string;
+  severity: "pass" | "warn" | "fail";
+  detail: string;
+};
+export type RealityAuditReport = {
+  level: RealityLevel;
+  findings: RealityFinding[];
+  score: number;      // 0..1 conformance
+  passCount: number;
+  warnCount: number;
+  failCount: number;
+  method: string;
+};
+
+const FIGURATIVE_RE = /\b(like a|like the|as if|as though|as a|resembl\w+|reminded \w+ of)\b/gi;
+const IMPOSSIBLE_RE = /\b(magic|spell|wizard|sorcer\w+|dragon|ghost|spectre|specter|demon|angel|telepath\w+|teleport\w+|levitat\w+|resurrect\w+|immortal|prophec\w+|enchant\w+|curse[ds]?)\b/gi;
+const HEDGE_RE = /\b(somehow|inexplicably|for some reason|mysteriously|without explanation)\b/gi;
+const TIME_ANCHOR_RE = /\b(\d{1,2}[:.]\d{2}\s*(?:am|pm)?|\d{1,2}\s*(?:am|pm)\b|monday|tuesday|wednesday|thursday|friday|saturday|sunday|january|february|march|april|may|june|july|august|september|october|november|december|\b(?:19|20)\d{2}\b)/gi;
+const MEASURE_RE = /\b\d+(?:[.,]\d+)?\s?(?:%|kg|km|cm|mm|m\b|g\b|lb|lbs|oz|mi\b|ft\b|in\b|l\b|ml|hours?|minutes?|seconds?|days?|weeks?|months?|years?|dollars?|euros?|pounds?|usd|eur|gbp|£|\$|€)/gi;
+const PROPER_RE = /(?<![.!?]\s)(?<!^)\b[A-Z][a-z]{2,}\b/gm;
+
+function countMatches(text: string, re: RegExp): number {
+  const m = text.match(re);
+  return m ? m.length : 0;
+}
+
+/**
+ * Runs the level's checkable constraints over finished prose. Lexical only:
+ * it reliably detects surface violations (named impossible nouns, figurative
+ * density, missing anchors) and cannot detect every semantic violation. That
+ * limitation is reported in `method` rather than hidden.
+ */
+export function auditRealityGrounding(text: string, id: number): RealityAuditReport {
+  const L = realityLevel(id);
+  const words = (text.trim().match(/\S+/g) || []).length;
+  const findings: RealityFinding[] = [];
+  const per100 = (n: number) => (words ? (n * 100) / words : 0);
+  const per1000 = (n: number) => (words ? (n * 1000) / words : 0);
+
+  // 1. figurative density
+  const fig = countMatches(text, FIGURATIVE_RE);
+  const figRate = per100(fig);
+  findings.push({
+    rule: "RG-FIG figurative budget",
+    severity: figRate <= L.figurativePer100w ? "pass" : figRate <= L.figurativePer100w * 1.6 ? "warn" : "fail",
+    detail: `${fig} figurative markers = ${figRate.toFixed(2)}/100w (budget ${L.figurativePer100w}/100w)`,
+  });
+
+  // 2. impossible vocabulary vs tolerance
+  const imp = countMatches(text, IMPOSSIBLE_RE);
+  const impAllowed = L.unexplainedTolerance > 0.3;
+  findings.push({
+    rule: "RG-IMP impossible-phenomena vocabulary",
+    severity: impAllowed ? "pass" : imp === 0 ? "pass" : imp <= 1 ? "warn" : "fail",
+    detail: impAllowed
+      ? `${imp} marker(s) — permitted at level ${L.id}`
+      : `${imp} marker(s) found; level ${L.id} forbids supernatural phenomena`,
+  });
+
+  // 3. unexplained hedges
+  const hedge = countMatches(text, HEDGE_RE);
+  findings.push({
+    rule: "RG-HEDGE unexplained hedging",
+    severity: hedge === 0 ? "pass" : L.unexplainedTolerance >= 0.45 ? "pass" : hedge <= 1 ? "warn" : "fail",
+    detail: `${hedge} hedge phrase(s) ("somehow", "inexplicably", …); tolerance ${L.unexplainedTolerance.toFixed(2)}`,
+  });
+
+  // 4. specificity floor
+  const specifics = countMatches(text, TIME_ANCHOR_RE) + countMatches(text, MEASURE_RE) + Math.min(countMatches(text, PROPER_RE), 40);
+  const specRate = per1000(specifics);
+  findings.push({
+    rule: "RG-SPEC specificity floor",
+    severity: specRate >= L.specificityPer1000w ? "pass" : specRate >= L.specificityPer1000w * 0.6 ? "warn" : "fail",
+    detail: `${specifics} specifics = ${specRate.toFixed(1)}/1000w (floor ${L.specificityPer1000w}/1000w)`,
+  });
+
+  // 5. documentary anchors
+  if (L.id === 6) {
+    const anchors = countMatches(text, TIME_ANCHOR_RE);
+    const measures = countMatches(text, MEASURE_RE);
+    findings.push({
+      rule: "RG-DOC time anchors",
+      severity: anchors >= 1 ? "pass" : "fail",
+      detail: `${anchors} date/clock anchor(s); documentary level requires at least one per scene`,
+    });
+    findings.push({
+      rule: "RG-DOC measured quantities",
+      severity: measures >= 1 ? "pass" : "fail",
+      detail: `${measures} measured quantit(ies) with units`,
+    });
+  }
+
+  const passCount = findings.filter((f) => f.severity === "pass").length;
+  const warnCount = findings.filter((f) => f.severity === "warn").length;
+  const failCount = findings.filter((f) => f.severity === "fail").length;
+  const score = findings.length ? (passCount + 0.5 * warnCount) / findings.length : 0;
+
+  return {
+    level: L, findings, score, passCount, warnCount, failCount,
+    method:
+      "Lexical audit over finished prose (regex families: figurative markers, supernatural nouns, hedges, " +
+      "time anchors, measured quantities, proper nouns). Detects surface violations; does NOT detect every " +
+      "semantic violation (e.g. an implausible causal chain written in plain words). No LLM was used.",
+  };
+}
+
+export const REALITY_STORAGE_KEY = "veritas.sage.realityLevel.v1";
+
+export function loadRealityLevel(fallback = 4): RealityLevelId {
+  try {
+    const raw = localStorage.getItem(REALITY_STORAGE_KEY);
+    if (raw == null) return fallback as RealityLevelId;
+    const n = Number(raw);
+    return (Number.isFinite(n) ? Math.max(0, Math.min(6, Math.round(n))) : fallback) as RealityLevelId;
+  } catch { return fallback as RealityLevelId; }
+}
+export function saveRealityLevel(id: number): void {
+  try { localStorage.setItem(REALITY_STORAGE_KEY, String(Math.max(0, Math.min(6, Math.round(id))))); } catch { /* optional */ }
+}

package/src/lib/sage/repetition.ts

@@ -0,0 +1,151 @@
+/**
+ * SAGE repetition / context-poisoning detector.
+ * ---------------------------------------------------------------------------
+ * Real, deterministic, locally-computed detector (no LLM call) for the
+ * degenerate-repetition failure mode reported on weaker frontier models
+ * (e.g. gemini-3.1-flash-lite): a single word, sentence, or paragraph
+ * repeating throughout later chapters. This is the classic small-model
+ * self-reinforcing-loop failure, distinct from ordinary stylistic motif
+ * recurrence.
+ *
+ * Runs after each chapter is generated. If flagged, ChatApp.tsx performs
+ * exactly ONE regeneration for that chapter using a fresh, compact prompt
+ * (never re-feeding the poisoned draft back into context).
+ */
+
+export type RepetitionReport = {
+  flagged: boolean;
+  reasons: string[];
+  evidence: string[];
+};
+
+function splitSentences(text: string): string[] {
+  return text
+    .replace(/\s+/g, " ")
+    .split(/(?<=[.!?])\s+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+function splitParagraphs(text: string): string[] {
+  return text
+    .split(/\n{2,}/)
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+}
+
+function normalize(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9' ]/g, "").replace(/\s+/g, " ").trim();
+}
+
+/** Detects exact-duplicate sentences (>=3x) or paragraphs (>=2x). */
+function detectExactDuplicates(text: string): { sentenceHit?: string; paragraphHit?: string } {
+  const sentences = splitSentences(text);
+  const sCounts = new Map<string, number>();
+  for (const s of sentences) {
+    if (s.length < 15) continue;
+    const key = normalize(s);
+    sCounts.set(key, (sCounts.get(key) ?? 0) + 1);
+  }
+  const sentenceHit = Array.from(sCounts.entries()).find(([, n]) => n >= 3)?.[0];
+
+  const paragraphs = splitParagraphs(text);
+  const pCounts = new Map<string, number>();
+  for (const p of paragraphs) {
+    if (p.length < 40) continue;
+    const key = normalize(p);
+    pCounts.set(key, (pCounts.get(key) ?? 0) + 1);
+  }
+  const paragraphHit = Array.from(pCounts.entries()).find(([, n]) => n >= 2)?.[0];
+
+  return { sentenceHit, paragraphHit };
+}
+
+/** Detects a single word dominating the text (word-level loop). */
+function detectWordLoop(text: string): { word: string; ratio: number } | null {
+  const words = normalize(text).split(" ").filter((w) => w.length >= 4);
+  if (words.length < 60) return null;
+  const counts = new Map<string, number>();
+  for (const w of words) counts.set(w, (counts.get(w) ?? 0) + 1);
+  let topWord = "";
+  let topCount = 0;
+  for (const [w, c] of counts) {
+    if (c > topCount) {
+      topCount = c;
+      topWord = w;
+    }
+  }
+  const ratio = topCount / words.length;
+  return ratio > 0.12 ? { word: topWord, ratio } : null;
+}
+
+/** Detects a repeated 4-gram phrase loop (classic degenerate-repetition signature). */
+function detectPhraseLoop(text: string): string | null {
+  const words = normalize(text).split(" ").filter(Boolean);
+  if (words.length < 20) return null;
+  const shingles = new Map<string, number>();
+  for (let i = 0; i + 4 <= words.length; i += 1) {
+    const gram = words.slice(i, i + 4).join(" ");
+    shingles.set(gram, (shingles.get(gram) ?? 0) + 1);
+  }
+  const hit = Array.from(shingles.entries()).find(([, n]) => n >= 4);
+  return hit ? hit[0] : null;
+}
+
+export function detectDegenerateRepetition(text: string): RepetitionReport {
+  const reasons: string[] = [];
+  const evidence: string[] = [];
+
+  const { sentenceHit, paragraphHit } = detectExactDuplicates(text);
+  if (sentenceHit) {
+    reasons.push("exact sentence repeated 3+ times");
+    evidence.push(sentenceHit.slice(0, 140));
+  }
+  if (paragraphHit) {
+    reasons.push("exact paragraph repeated 2+ times");
+    evidence.push(paragraphHit.slice(0, 200));
+  }
+  const wordLoop = detectWordLoop(text);
+  if (wordLoop) {
+    reasons.push(`single word "${wordLoop.word}" dominates (${(wordLoop.ratio * 100).toFixed(1)}% of tokens)`);
+    evidence.push(wordLoop.word);
+  }
+  const phraseLoop = detectPhraseLoop(text);
+  if (phraseLoop) {
+    reasons.push("4-word phrase loop detected 4+ times");
+    evidence.push(phraseLoop);
+  }
+
+  return { flagged: reasons.length > 0, reasons, evidence };
+}
+
+/**
+ * Self-test hook — exposed on window in dev builds so the fix can be
+ * hand-traced against a synthetic context-poisoning sample without needing
+ * a live model call. Not executed automatically; call
+ * `window.__sageRepetitionSelfTest()` in the browser console.
+ */
+export function sageRepetitionSelfTest(): { pass: boolean; cases: { name: string; pass: boolean }[] } {
+  const cases: { name: string; pass: boolean }[] = [];
+
+  const poisoned = "The bell tolled again. The bell tolled again. The bell tolled again. Nothing else happened in the square that day.";
+  cases.push({ name: "exact sentence loop (3x)", pass: detectDegenerateRepetition(poisoned).flagged });
+
+  const wordLoopSample = Array(80).fill("shadow").join(" ") + " walked into the room and sat down quietly near the window.";
+  cases.push({ name: "single-word loop", pass: detectDegenerateRepetition(wordLoopSample).flagged });
+
+  const phraseLoopSample = Array(6).fill("in the quiet dark of").join(" the corridor ") + " she waited for morning.";
+  cases.push({ name: "phrase loop", pass: detectDegenerateRepetition(phraseLoopSample).flagged });
+
+  const clean =
+    "Mira crossed the bridge before dawn. The river below carried last night's rain toward the mill. " +
+    "She had promised her brother she would not look back, and she kept that promise exactly once. " +
+    "By the time the sun cleared the ridgeline, the town behind her was only smoke and roofline.";
+  cases.push({ name: "clean prose (no false positive)", pass: !detectDegenerateRepetition(clean).flagged });
+
+  return { pass: cases.every((c) => c.pass), cases };
+}
+
+if (typeof window !== "undefined") {
+  (window as unknown as { __sageRepetitionSelfTest?: typeof sageRepetitionSelfTest }).__sageRepetitionSelfTest = sageRepetitionSelfTest;
+}