@thesimonharms/basa 0.1.0 → 0.1.2

package/dist/flashcards/sound.js

@@ -0,0 +1,100 @@
+import { AudioOut, detectAudio, silentRequested } from '@mudah-cli/audio';
+const SAMPLE_RATE = 44100;
+/** A BasaFx is a tiny sound effect player with two one-shots. */
+export class BasaFx {
+    audio = null;
+    detection;
+    constructor(audio, detection) {
+        this.audio = audio;
+        this.detection = detection;
+    }
+    /** Probe + open. Returns a silent instance if no backend is available. */
+    static async open() {
+        if (silentRequested())
+            return new BasaFx(null, null);
+        const detection = detectAudio();
+        if (detection.backend === 'silent')
+            return new BasaFx(null, detection);
+        try {
+            const audio = await AudioOut.open({ sampleRate: SAMPLE_RATE, channels: 1 });
+            return new BasaFx(audio, detection);
+        }
+        catch {
+            return new BasaFx(null, detection);
+        }
+    }
+    get isLive() {
+        return this.audio !== null;
+    }
+    /** Play the "you got it" sound. Grade 2 (Good) and 3 (Easy) → happy ding. */
+    async playCorrect(grade) {
+        if (this.audio === null)
+            return;
+        const clip = grade === 3 ? happyChirp() : ding();
+        await this.audio.play(clip);
+    }
+    /** Play the "not quite" sound. Grade 0 (Again) → low buzz. */
+    async playIncorrect() {
+        if (this.audio === null)
+            return;
+        await this.audio.play(buzz());
+    }
+    async dispose() {
+        this.audio?.dispose();
+        this.audio = null;
+    }
+}
+/**
+ * A two-note ascending arpeggio (C5 → E5). Quick, bright, low-volume.
+ * 0.18s total.
+ */
+function ding() {
+    const samples = renderSequence([
+        { freq: 523.25, durationMs: 90, volume: 0.4 },
+        { freq: 659.25, durationMs: 90, volume: 0.4 },
+    ]);
+    return { samples, sampleRate: SAMPLE_RATE, channels: 1 };
+}
+/** Three ascending notes (C5 → E5 → G5). Triumphant. 0.30s total. */
+function happyChirp() {
+    const samples = renderSequence([
+        { freq: 523.25, durationMs: 80, volume: 0.45 },
+        { freq: 659.25, durationMs: 80, volume: 0.45 },
+        { freq: 783.99, durationMs: 140, volume: 0.5 },
+    ]);
+    return { samples, sampleRate: SAMPLE_RATE, channels: 1 };
+}
+/** Two low square-ish pulses. 0.20s total. */
+function buzz() {
+    const samples = renderSequence([
+        { freq: 196.0, durationMs: 90, volume: 0.35, pulse: true },
+        { freq: 164.81, durationMs: 90, volume: 0.35, pulse: true },
+    ]);
+    return { samples, sampleRate: SAMPLE_RATE, channels: 1 };
+}
+function renderSequence(notes) {
+    const total = notes.reduce((sum, n) => sum + Math.ceil((n.durationMs / 1000) * SAMPLE_RATE), 0);
+    const out = new Int16Array(total);
+    let cursor = 0;
+    for (const note of notes) {
+        const frames = Math.ceil((note.durationMs / 1000) * SAMPLE_RATE);
+        for (let i = 0; i < frames; i++) {
+            const t = i / SAMPLE_RATE;
+            const envelope = triangle(i, frames);
+            const value = Math.sin(2 * Math.PI * note.freq * t) * envelope * note.volume;
+            const square = note.pulse ? (Math.sin(2 * Math.PI * note.freq * t) >= 0 ? 1 : -1) : 0;
+            const mixed = note.pulse ? 0.6 * value + 0.4 * square * note.volume * envelope : value;
+            out[cursor + i] = Math.max(-1, Math.min(1, mixed)) * 0x7fff;
+        }
+        cursor += frames;
+    }
+    return out;
+}
+function triangle(i, total) {
+    // Quick attack, slow release: 0..0.05 then linear decay to 0.
+    const attack = 0.05;
+    const t = i / total;
+    if (t < attack)
+        return t / attack;
+    return Math.max(0, 1 - (t - attack) / (1 - attack));
+}

package/dist/flashcards/srs.js

@@ -0,0 +1,77 @@
+/** A relaxed SM-2 implementation. Reasonable defaults, no anki-parity goal. */
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function freshState(now = Date.now()) {
+    // `due: null` means "due immediately" — see `isDue`. Using a captured
+    // timestamp here is racey when the caller samples `Date.now()` again
+    // later (e.g. the list command compares state.due against a `now`
+    // sampled before the loop, while the loop's `loadReviewCards` calls
+    // freshState() for each card with progressively later timestamps).
+    void now;
+    return {
+        due: null,
+        streak: 0,
+        ease: 2.5,
+        intervalDays: 0,
+        reviews: 0,
+        lastGrade: null,
+    };
+}
+/**
+ * Apply a grade to a card's state and return the next state.
+ * Pure function — no I/O, no randomness — so it's trivially testable.
+ */
+export function grade(state, grade, now = Date.now()) {
+    const next = {
+        due: state.due,
+        streak: state.streak,
+        ease: state.ease,
+        intervalDays: state.intervalDays,
+        reviews: state.reviews + 1,
+        lastGrade: grade,
+    };
+    if (grade === 0) {
+        // Again: reset streak, ease drops, see it again in 10 minutes.
+        next.streak = 0;
+        next.ease = Math.max(1.3, state.ease - 0.2);
+        next.intervalDays = 0;
+        next.due = now + 10 * 60 * 1000;
+        return next;
+    }
+    next.streak = state.streak + 1;
+    // SM-2 ease adjustment for non-failing grades. Hard (1) drops ease slightly;
+    // Easy (3) bumps it; Good (2) holds.
+    const easeDelta = grade === 1 ? -0.15 : grade === 3 ? 0.15 : 0;
+    next.ease = clamp(state.ease + easeDelta, 1.3, 2.8);
+    if (next.streak === 1) {
+        next.intervalDays = 1;
+    }
+    else if (next.streak === 2) {
+        next.intervalDays = 6;
+    }
+    else {
+        next.intervalDays = Math.max(1, Math.round(state.intervalDays * next.ease));
+    }
+    next.due = now + next.intervalDays * DAY_MS;
+    return next;
+}
+function clamp(value, lo, hi) {
+    return Math.max(lo, Math.min(hi, value));
+}
+/** Cards that are due now or earlier. `null` `due` is treated as "due immediately". */
+export function isDue(state, now = Date.now()) {
+    if (state.due === null)
+        return true;
+    return state.due <= now;
+}
+/** Pick the next due card, ordered by oldest-due first, with new cards last. */
+export function pickNext(cards, now = Date.now()) {
+    const due = cards.filter((c) => isDue(c.state, now));
+    if (due.length === 0)
+        return undefined;
+    const sorted = [...due].sort((a, b) => {
+        const ad = a.state.due ?? 0;
+        const bd = b.state.due ?? 0;
+        return ad - bd;
+    });
+    return sorted[0];
+}

package/dist/flashcards/types.js

@@ -0,0 +1,26 @@
+/**
+ * Open flashcard format.
+ *
+ * A deck is a single file (YAML or JSON) with this shape:
+ *
+ *   name: "Spanish 101"
+ *   description: "First-year Spanish vocabulary"
+ *   cards:
+ *     - front: "hola"
+ *       back: "hello"
+ *     - front: "perro"
+ *       back: "dog"
+ *     - front:
+ *         text: "ありがとう"
+ *         image: "./assets/thanks.png"   # optional
+ *       back:
+ *         text: "thank you"
+ *
+ * Each side is either a plain string (a single text field) or a list of
+ * fields, where each field is `{ text?, image?, audio? }`. The renderer walks
+ * the list top-to-bottom, leaving a blank line between fields. An `image`
+ * field is rendered with half-block cells (universal truecolor); a `text`
+ * field is rendered verbatim. An `audio` field is a relative path to a WAV
+ * that the user can play with `p` while reviewing.
+ */
+export const GRADE_LABELS = ['Again', 'Hard', 'Good', 'Easy'];

package/dist/providers/AppProvider.js

@@ -0,0 +1,13 @@
+import { ServiceProvider } from '@mudah-cli/mudah';
+export default class BasaProvider extends ServiceProvider {
+    register() {
+        this.app.config().merge('app', {
+            name: 'basa',
+            env: 'local',
+            // Default location for user decks (~/.config/basa/decks).
+            decksDir: '~/basa/decks',
+            // Optional sound effects: 'on' | 'off' | 'auto'.
+            sound: 'auto',
+        });
+    }
+}

package/dist/tui/CardView.js

@@ -0,0 +1,228 @@
+import { BaseComponent } from '@mudah-cli/tui';
+import { detectCapabilities } from '@mudah-cli/terminal';
+import { paint, visibleLength } from '@mudah-cli/ui';
+import { renderSide } from '../flashcards/render.js';
+import { confettiRows, shakeRows, typeOnRows, } from './effects.js';
+/**
+ * The flashcard face. Renders the front; on space, animates the back in.
+ * Keys 1-4 grade. `n` skips (no grade recorded). `enter` submits typed answer.
+ *
+ * Owns its own animation state — tick() is called by the host every frame.
+ */
+export class CardView extends BaseComponent {
+    focusable = true;
+    typed = '';
+    front = { text: [], imageRows: [] };
+    back = { text: [], imageRows: [] };
+    doneStats = null;
+    revealed = false;
+    revealAnim = { durationFrames: 8, frame: 0 };
+    shake = null;
+    confetti = null;
+    ctx;
+    current;
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.ctx = {
+            deckPath: options.deckPath,
+            cellsWidth: options.cellsWidth,
+            cellsHeight: options.cellsHeight,
+            imageCache: new Map(),
+        };
+    }
+    /** Update the active card. Resets reveal + animation state. */
+    async setCard(card, stats) {
+        this.current = card;
+        this.revealed = false;
+        this.typed = '';
+        this.shake = null;
+        this.confetti = null;
+        this.revealAnim = { durationFrames: 8, frame: 0 };
+        if (card === undefined) {
+            this.doneStats = stats ?? null;
+            this.front = { text: this.doneViewText(), imageRows: [] };
+            this.back = { text: [], imageRows: [] };
+            this.options.onDone?.();
+            return;
+        }
+        this.doneStats = null;
+        this.front = await renderSide(card.card.front, this.ctx);
+        this.back = await renderSide(card.card.back, this.ctx);
+    }
+    doneViewText() {
+        if (this.doneStats === null) {
+            return ['All caught up!', 'Press Esc to quit.'];
+        }
+        const s = this.doneStats;
+        return [
+            '',
+            '   ╭───────────────────────────────────────╮',
+            '   │                                       │',
+            '   │        session complete!              │',
+            '   │                                       │',
+            `   │   reviewed  ${pad(s.reviewed, 3)} cards                    │`,
+            `   │   again  ${pad(s.again, 3)}   hard  ${pad(s.hard, 3)}   good  ${pad(s.good, 3)}   easy  ${pad(s.easy, 3)}    │`,
+            '   │                                       │',
+            '   │        press esc to exit              │',
+            '   │                                       │',
+            '   ╰───────────────────────────────────────╯',
+            '',
+        ];
+    }
+    /** Drive animations. Called by the host once per repaint. */
+    tick() {
+        if (this.revealed && this.revealAnim.frame < this.revealAnim.durationFrames) {
+            this.revealAnim.frame++;
+        }
+        if (this.shake !== null && this.shake.frame < this.shake.durationFrames) {
+            this.shake.frame++;
+            if (this.shake.frame >= this.shake.durationFrames)
+                this.shake = null;
+        }
+        if (this.confetti !== null && this.confetti.frame < this.confetti.durationFrames) {
+            this.confetti.frame++;
+            if (this.confetti.frame >= this.confetti.durationFrames)
+                this.confetti = null;
+        }
+    }
+    /** Resize the rendering area (after a terminal resize). */
+    resize(cellsWidth, cellsHeight) {
+        this.ctx.cellsWidth = cellsWidth;
+        this.ctx.cellsHeight = cellsHeight;
+        this.ctx.imageCache.clear();
+        if (this.current !== undefined) {
+            // Re-render in the background. Until the new rows arrive, the existing
+            // rows still display — no flicker, no jump.
+            void this.setCard(this.current);
+        }
+    }
+    onKey(event) {
+        if (event.name === 'space' || event.name === 'enter') {
+            this.revealed = true;
+            this.revealAnim = { durationFrames: 8, frame: 0 };
+            return true;
+        }
+        if (event.name === 'backspace') {
+            this.typed = this.typed.slice(0, -1);
+            return true;
+        }
+        if (this.revealed) {
+            switch (event.name) {
+                case '1':
+                    this.grade(0);
+                    return true;
+                case '2':
+                    this.grade(1);
+                    return true;
+                case '3':
+                    this.grade(2);
+                    return true;
+                case '4':
+                    this.grade(3);
+                    return true;
+            }
+        }
+        if (event.name === 'n') {
+            this.options.onSkip();
+            return true;
+        }
+        if (event.ch !== undefined && event.ch >= ' ' && event.ch !== 'n' && (event.ch < '0' || event.ch > '9')) {
+            this.typed += event.ch;
+            return true;
+        }
+        return false;
+    }
+    grade(g) {
+        this.options.onGraded(g, this.typed);
+        if (g === 0) {
+            this.shake = { durationFrames: 10, frame: 0 };
+        }
+        else if (g === 3) {
+            this.confetti = {
+                frame: 0,
+                durationFrames: 24,
+                seed: Math.floor(Math.random() * 1e6),
+                width: this.options.cellsWidth,
+                palette: ['\x1b[38;5;213m', '\x1b[38;5;215m', '\x1b[38;5;220m', '\x1b[38;5;156m', '\x1b[38;5;123m'],
+            };
+        }
+        this.typed = '';
+    }
+    render() {
+        const out = [];
+        // Header line: prompt + type input
+        const lvl = detectCapabilities().colorLevel;
+        const promptText = this.revealed
+            ? paint('#fbbf24', 'Type your answer, then press 1-4 to grade', lvl)
+            : paint('#94a3b8', 'Press Space to reveal', lvl);
+        const typed = this.typed.length > 0 ? paint('#e2e8f0', ` > ${this.typed}▏`, lvl) : '';
+        out.push(centerLine(`${promptText}${typed}`, this.options.cellsWidth));
+        // Spacer
+        out.push('');
+        // Card front
+        const frontRows = this.front.text;
+        const centeredFront = frontRows.map((row) => centerLine(row, this.options.cellsWidth));
+        out.push(...this.applyEffects(centeredFront, 'front'));
+        // Spacer
+        out.push('');
+        // Divider
+        if (this.revealed) {
+            out.push(centerLine(paint('#475569', '─'.repeat(Math.min(60, this.options.cellsWidth - 4)), lvl), this.options.cellsWidth));
+            out.push('');
+            const backRows = this.back.text;
+            const typedBack = this.revealed ? typeOnRows(this.revealAnim, backRows) : [];
+            const centeredBack = typedBack.map((row) => centerLine(row, this.options.cellsWidth));
+            out.push(...this.applyEffects(centeredBack, 'back'));
+            // Hint, if any
+            if (this.current?.card.hint !== undefined && this.revealed) {
+                out.push('');
+                out.push(centerLine(paint('#64748b', `hint: ${this.current.card.hint}`, lvl), this.options.cellsWidth));
+            }
+        }
+        // Image rows (always rendered below the text).
+        const imageRows = this.revealed
+            ? [...this.front.imageRows, ...this.back.imageRows]
+            : this.front.imageRows;
+        for (const row of imageRows) {
+            out.push(centerLine(row, this.options.cellsWidth));
+        }
+        // Confetti overlay
+        if (this.confetti !== null) {
+            const overlay = confettiRows(this.confetti, Math.min(8, this.options.cellsHeight));
+            for (let i = 0; i < overlay.length; i++) {
+                out[out.length - overlay.length + i] = overlay[i] ?? '';
+            }
+        }
+        // Pad / truncate to fit the cell height so the screen layout is stable.
+        while (out.length < this.options.cellsHeight)
+            out.push('');
+        if (out.length > this.options.cellsHeight)
+            out.length = this.options.cellsHeight;
+        return out;
+    }
+    applyEffects(rows, seedKey) {
+        let out = rows;
+        if (this.shake !== null) {
+            out = shakeRows(this.shake, out, hashString(`${seedKey}:${this.current?.card.front ?? ''}`));
+        }
+        return out;
+    }
+}
+function centerLine(text, width) {
+    const visible = visibleLength(text);
+    if (visible >= width)
+        return text;
+    const pad = Math.floor((width - visible) / 2);
+    return ' '.repeat(pad) + text;
+}
+function hashString(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++)
+        h = (h * 31 + s.charCodeAt(i)) | 0;
+    return h;
+}
+function pad(n, width) {
+    return String(n).padStart(width, ' ');
+}

package/dist/tui/Footer.js

@@ -0,0 +1,57 @@
+import { BaseComponent } from '@mudah-cli/tui';
+import { detectCapabilities } from '@mudah-cli/terminal';
+import { paint } from '@mudah-cli/ui';
+const KEYS = [
+    { key: '1', label: 'Again', tone: 'bad' },
+    { key: '2', label: 'Hard', tone: 'meh' },
+    { key: '3', label: 'Good', tone: 'good' },
+    { key: '4', label: 'Easy', tone: 'good' },
+];
+const TONES = {
+    good: '#4ade80',
+    meh: '#fbbf24',
+    bad: '#f87171',
+    neutral: '#94a3b8',
+};
+/** The key legend. Centered, three rows: title, four key chips, hints. */
+export class Footer extends BaseComponent {
+    focusable = false;
+    width;
+    constructor(width) {
+        super();
+        this.width = width;
+    }
+    resize(width) {
+        this.width = width;
+    }
+    render() {
+        const lvl = detectCapabilities().colorLevel;
+        const chips = KEYS.map((k) => {
+            const color = TONES[k.tone];
+            return `${paint('#0f172a', ` ${k.key} `, lvl)}${paint(color, ` ${k.label} `, lvl)}`;
+        }).join('  ');
+        const row1 = centerLine(chips, this.width);
+        const row2 = centerLine(paint('#64748b', 'space/enter: reveal   n: skip   esc: quit', lvl), this.width);
+        return ['', row1, row2];
+    }
+}
+function centerLine(text, width) {
+    return ' '.repeat(Math.max(0, Math.floor((width - visibleOf(text)) / 2))) + text;
+}
+function visibleOf(text) {
+    let visible = 0;
+    let inEscape = false;
+    for (const ch of text) {
+        if (ch === '\x1b') {
+            inEscape = true;
+            continue;
+        }
+        if (inEscape) {
+            if (ch === 'm')
+                inEscape = false;
+            continue;
+        }
+        visible++;
+    }
+    return visible;
+}

package/dist/tui/Header.js

@@ -0,0 +1,48 @@
+import { BaseComponent } from '@mudah-cli/tui';
+import { detectCapabilities } from '@mudah-cli/terminal';
+import { paint } from '@mudah-cli/ui';
+/** Deck name + progress bar. One row, centered. */
+export class Header extends BaseComponent {
+    focusable = false;
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    update(options) {
+        Object.assign(this.options, options);
+    }
+    render() {
+        const lvl = detectCapabilities().colorLevel;
+        const barWidth = Math.max(10, Math.min(40, this.options.width - 30));
+        const ratio = this.options.total > 0 ? this.options.reviewed / this.options.total : 0;
+        const filled = Math.round(ratio * barWidth);
+        const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+        const left = paint('#e2e8f0', this.options.deckName, lvl);
+        const right = paint('#94a3b8', ` ${this.options.reviewed}/${this.options.total}`, lvl);
+        const progress = paint(ratio >= 1 ? '#4ade80' : '#60a5fa', bar, lvl);
+        const line = `${left}  ${progress}${right}`;
+        return [centerLine(line, this.options.width)];
+    }
+}
+function centerLine(text, width) {
+    // Use a simple visible-length estimate: count chars, ignore ANSI.
+    return ' '.repeat(Math.max(0, Math.floor((width - visibleOf(text)) / 2))) + text;
+}
+function visibleOf(text) {
+    let visible = 0;
+    let inEscape = false;
+    for (const ch of text) {
+        if (ch === '\x1b') {
+            inEscape = true;
+            continue;
+        }
+        if (inEscape) {
+            if (ch === 'm')
+                inEscape = false;
+            continue;
+        }
+        visible++;
+    }
+    return visible;
+}

package/dist/tui/StudyApp.js

@@ -0,0 +1,120 @@
+import { Container } from '@mudah-cli/tui';
+import { grade, pickNext } from '../flashcards/srs.js';
+import { saveReviewCards } from '../flashcards/deck.js';
+import { BasaFx } from '../flashcards/sound.js';
+import { CardView } from './CardView.js';
+import { Header } from './Header.js';
+import { Footer } from './Footer.js';
+/**
+ * The study session. Owns SRS state, the focused card, the session stats.
+ * Exposes a `Container` for the TUI program to mount, plus `tick()` and
+ * `resize()` methods the host calls every frame and on terminal resize.
+ */
+export class StudyApp {
+    root;
+    cardView;
+    header;
+    footer;
+    cards;
+    current;
+    stats = { reviewed: 0, again: 0, hard: 0, good: 0, easy: 0 };
+    width;
+    height;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.cards = options.cards;
+        this.width = options.width;
+        this.height = options.height;
+        const cardHeight = Math.max(8, options.height - 8);
+        this.cardView = new CardView({
+            deckPath: options.deckPath,
+            cellsWidth: options.width,
+            cellsHeight: cardHeight,
+            onGraded: (g, typed) => void this.handleGrade(g, typed),
+            onSkip: () => this.handleSkip(),
+        });
+        this.header = new Header({
+            deckName: options.deck.name,
+            reviewed: 0,
+            total: this.cards.length,
+            width: options.width,
+        });
+        this.footer = new Footer(options.width);
+        this.root = new Container().add(this.header).add(this.cardView).add(this.footer);
+        void this.advance();
+    }
+    /** Drive animations. Called by the host on every frame. */
+    tick() {
+        this.cardView.tick();
+    }
+    /** Apply a terminal resize. */
+    resize(width, height) {
+        this.width = width;
+        this.height = height;
+        this.header.update({
+            deckName: this.options.deck.name,
+            reviewed: this.stats.reviewed,
+            total: this.cards.length,
+            width,
+        });
+        this.footer.resize(width);
+        const cardHeight = Math.max(8, height - 8);
+        this.cardView.resize(width, cardHeight);
+    }
+    /** Persist state on shutdown. Safe to call multiple times. */
+    async persist() {
+        await saveReviewCards(this.options.deckPath, this.cards).catch(() => { });
+    }
+    async advance() {
+        this.current = pickNext(this.cards, Date.now());
+        if (this.current === undefined) {
+            await this.cardView.setCard(undefined, this.stats);
+            return;
+        }
+        await this.cardView.setCard(this.current);
+    }
+    async handleGrade(gradeValue, _typed) {
+        if (this.current === undefined)
+            return;
+        const idx = this.cards.indexOf(this.current);
+        if (idx < 0)
+            return;
+        const next = grade(this.current.state, gradeValue);
+        this.cards[idx] = { card: this.current.card, state: next };
+        this.stats = {
+            reviewed: this.stats.reviewed + 1,
+            again: this.stats.again + (gradeValue === 0 ? 1 : 0),
+            hard: this.stats.hard + (gradeValue === 1 ? 1 : 0),
+            good: this.stats.good + (gradeValue === 2 ? 1 : 0),
+            easy: this.stats.easy + (gradeValue === 3 ? 1 : 0),
+        };
+        this.header.update({
+            deckName: this.options.deck.name,
+            reviewed: this.stats.reviewed,
+            total: this.cards.length,
+            width: this.width,
+        });
+        if (gradeValue === 0) {
+            await this.options.fx.playIncorrect();
+        }
+        else {
+            await this.options.fx.playCorrect(gradeValue);
+        }
+        // Persist after every grade so a crash doesn't lose progress.
+        await saveReviewCards(this.options.deckPath, this.cards).catch(() => { });
+        await this.advance();
+    }
+    handleSkip() {
+        if (this.current === undefined)
+            return;
+        const idx = this.cards.indexOf(this.current);
+        if (idx < 0)
+            return;
+        this.cards[idx] = {
+            card: this.current.card,
+            state: { ...this.current.state, due: Date.now() + 30_000 },
+        };
+        void this.advance();
+    }
+}