tests/srsSession.test.ts
Rama main · réplica de lectura del repositorio original.
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import type { DeckCard } from "../shared/decks.ts";
import type { Schedule } from "../shared/srs.ts";
import { createSession, gradeCard, nextCard, phaseOf, previews, remaining, retention, skipCard, waitFor, type Session } from "../shared/srsSession.ts";
import { ORBITS_COPY } from "../client/orbits/copy.ts";
import { delimiterOf, parseDelimited, stripAnkiHeader } from "../client/orbits/csv.ts";
import { cardsOfText } from "../client/orbits/lines.ts";
import { hardest, newIntroduced, readLog, retention as deviceRetention, retentionSeries } from "../client/orbits/log.ts";
import { headOf, keysOf, CardQueue } from "../client/orbits/queue.ts";
import { forecast, statesOf, streakOf } from "../client/orbits/stats.ts";
import { diffAnswer, normaliseAnswer } from "../client/orbits/typed.ts";
// A fake localStorage for the queue's daily counter and the device's log
// (client/orbits/log.ts reads it lazily; node's own wants a flag and warns
// without it).
const store = new Map<string, string>();
Object.defineProperty(globalThis, "localStorage", {
configurable: true,
value: {
getItem: (k: string) => store.get(k) ?? null,
setItem: (k: string, v: string) => void store.set(k, String(v)),
removeItem: (k: string) => void store.delete(k),
},
});
const TODAY = "2026-09-28";
const T0 = Date.UTC(2026, 8, 28, 9, 0, 0);
const MIN = 60_000;
function star(n: number, schedule: Schedule | null = null): DeckCard {
return { id: `k.md#${n}#fwd`, path: "k.md", line: n, end: n, dir: "fwd", kind: "qa", front: `f${n}`, back: `b${n}`, extra: null, section: null, tags: [], schedule };
}
const due = (day: string, interval = 6): Schedule => ({ due: day, interval, ease: 2500 });
/** Grade whatever is next; returns the new session and what was written. */
function step(s: Session, grade: "again" | "hard" | "good" | "easy", now: number): { session: Session; write: Schedule | null; id: string } {
const next = nextCard(s, now);
assert.ok(next, "nothing to show");
const r = gradeCard(s, next.star.id, grade, now, TODAY);
return { ...r, id: next.star.id };
}
describe("a session's queues", () => {
it("shows due reviews soonest-due first, then new cards in document order, up to the limit", () => {
const stars = [star(1), star(2, due("2026-09-27")), star(3, due("2026-09-20")), star(4, due("2026-10-05")), star(5), star(6)];
const s = createSession(stars, TODAY, T0, { newLimit: 2 });
assert.deepEqual(s.reviews, ["k.md#3#fwd", "k.md#2#fwd"]);
assert.deepEqual(s.fresh, ["k.md#1#fwd", "k.md#5#fwd"]);
assert.deepEqual(remaining(s), { review: 2, new: 2, learning: 0, total: 4 });
assert.equal(nextCard(s, T0)!.star.id, "k.md#3#fwd");
assert.equal(nextCard(s, T0)!.phase, "review");
// Study ahead brings the not-yet-due one in, after the due ones.
const ahead = createSession(stars, TODAY, T0, { newLimit: 0, studyAhead: true });
assert.deepEqual(ahead.reviews, ["k.md#3#fwd", "k.md#2#fwd", "k.md#4#fwd"]);
assert.deepEqual(ahead.fresh, []);
});
it("slips one new star in after every four reviews", () => {
const stars = [star(1), star(2), ...[3, 4, 5, 6, 7, 8, 9, 10, 11].map((n) => star(n, due("2026-09-27")))];
let s = createSession(stars, TODAY, T0, { newLimit: 10 });
const shown: string[] = [];
for (let i = 0; i < 11; i++) {
const r = step(s, "easy", T0 + i * MIN);
shown.push(r.id);
s = r.session;
}
assert.deepEqual(shown, ["k.md#3#fwd", "k.md#4#fwd", "k.md#5#fwd", "k.md#6#fwd", "k.md#1#fwd", "k.md#7#fwd", "k.md#8#fwd", "k.md#9#fwd", "k.md#10#fwd", "k.md#2#fwd", "k.md#11#fwd"]);
assert.equal(nextCard(s, T0 + 12 * MIN), null);
assert.equal(s.introduced, 2);
assert.equal(s.done, 11);
});
});
describe("learning steps", () => {
it("walks a new star through 1m and 10m and graduates to one day on good", () => {
let s = createSession([star(1)], TODAY, T0, { newLimit: 10, steps: [1, 10] });
assert.deepEqual(previews(s, "k.md#1#fwd", TODAY), { again: { minutes: 1 }, hard: { minutes: 1 }, good: { minutes: 10 }, easy: { days: 4 } });
let r = step(s, "good", T0);
s = r.session;
assert.equal(r.write, null);
assert.equal(phaseOf(s, "k.md#1#fwd"), "learning");
assert.equal(s.introduced, 1);
assert.deepEqual(previews(s, "k.md#1#fwd", TODAY), { again: { minutes: 1 }, hard: { minutes: 10 }, good: { days: 1 }, easy: { days: 4 } });
// Not due for ten minutes: shown early only because nothing else remains.
assert.equal(nextCard(s, T0 + MIN)!.early, true);
assert.equal(waitFor(s, T0 + MIN), 9 * MIN);
assert.equal(nextCard(s, T0 + 10 * MIN)!.early, false);
assert.equal(waitFor(s, T0 + 10 * MIN), null);
r = step(s, "good", T0 + 10 * MIN);
s = r.session;
assert.deepEqual(r.write, { due: "2026-09-29", interval: 1, ease: 2500 });
assert.equal(nextCard(s, T0 + 11 * MIN), null);
assert.equal(s.done, 1);
assert.deepEqual(s.stars["k.md#1#fwd"].schedule, r.write);
});
it("again restarts the steps, hard repeats one, easy graduates at once to four days", () => {
let s = createSession([star(1)], TODAY, T0, { newLimit: 10, steps: [1, 10] });
s = step(s, "good", T0).session; // → step 1 (10m)
let r = step(s, "again", T0 + 10 * MIN);
s = r.session;
assert.equal(r.write, null);
assert.equal(s.learning[0].step, 0);
assert.equal(s.learning[0].dueAt, T0 + 11 * MIN);
assert.deepEqual(s.again, ["k.md#1#fwd"]);
r = step(s, "hard", T0 + 11 * MIN);
s = r.session;
assert.equal(s.learning[0].step, 0);
assert.equal(s.learning[0].dueAt, T0 + 12 * MIN);
r = step(s, "easy", T0 + 12 * MIN);
assert.deepEqual(r.write, { due: "2026-10-02", interval: 4, ease: 2650 });
assert.equal(nextCard(r.session, T0 + 13 * MIN), null);
});
it("a due learning star comes before every review and every new star", () => {
const stars = [star(1), star(2, due("2026-09-27")), star(3, due("2026-09-27"))];
let s = createSession(stars, TODAY, T0, { newLimit: 10, steps: [1, 10] });
s = step(s, "good", T0).session; // review 2
s = step(s, "good", T0).session; // review 3
s = step(s, "good", T0).session; // new 1 → learning, due at +10m
assert.equal(nextCard(s, T0 + 10 * MIN)!.star.id, "k.md#1#fwd");
const withMore = createSession([star(4), ...stars], TODAY, T0, { newLimit: 10 });
let w = step(withMore, "good", T0).session; // review 2
// 4 is new; 1 is new; the learning one, once due, outranks both.
w = { ...w, learning: [{ id: "k.md#3#fwd", phase: "learning", step: 1, dueAt: T0 + MIN }], reviews: [] };
assert.equal(nextCard(w, T0)!.star.id, "k.md#4#fwd");
assert.equal(nextCard(w, T0 + MIN)!.star.id, "k.md#3#fwd");
});
});
describe("lapses", () => {
it("writes SM-2's again at once and relearns for ten minutes", () => {
let s = createSession([star(1, due("2026-09-27", 15))], TODAY, T0, { newLimit: 0 });
assert.deepEqual(previews(s, "k.md#1#fwd", TODAY), { again: { minutes: 10 }, hard: { days: 18 }, good: { days: 38 }, easy: { days: 52 } });
let r = step(s, "again", T0);
s = r.session;
assert.deepEqual(r.write, { due: "2026-09-29", interval: 1, ease: 2300 });
assert.equal(phaseOf(s, "k.md#1#fwd"), "relearning");
assert.equal(s.learning[0].dueAt, T0 + 10 * MIN);
assert.equal(s.done, 0);
assert.deepEqual(previews(s, "k.md#1#fwd", TODAY), { again: { minutes: 10 }, hard: { minutes: 10 }, good: { days: 1 }, easy: { days: 1 } });
// Graduating relearning writes nothing more: the lapse already did.
r = step(s, "good", T0 + 10 * MIN);
assert.equal(r.write, null);
assert.equal(r.session.done, 1);
assert.equal(nextCard(r.session, T0 + 11 * MIN), null);
});
it("good, hard and easy on a review write SM-2 and finish the star", () => {
const s = createSession([star(1, due("2026-09-27", 6)), star(2, due("2026-09-27", 6))], TODAY, T0, { newLimit: 0 });
const r = gradeCard(s, "k.md#1#fwd", "hard", T0, TODAY);
assert.deepEqual(r.write, { due: "2026-10-05", interval: 7, ease: 2350 });
assert.deepEqual(r.session.reviews, ["k.md#2#fwd"]);
assert.equal(r.session.done, 1);
assert.equal(r.session.sinceNew, 1);
});
});
describe("the rest of a session", () => {
it("skips, counts, tells retention, ignores an unknown star, and never mutates", () => {
const stars = [star(1), star(2, due("2026-09-27"))];
const s = createSession(stars, TODAY, T0, { newLimit: 10 });
const skipped = skipCard(s, "k.md#2#fwd");
assert.deepEqual(remaining(skipped), { review: 0, new: 1, learning: 0, total: 1 });
assert.deepEqual(remaining(s), { review: 1, new: 1, learning: 0, total: 2 });
assert.equal(gradeCard(s, "nope", "good", T0, TODAY).session, s);
assert.equal(phaseOf(s, "nope"), null);
assert.equal(previews(s, "nope", TODAY), null);
assert.equal(retention([]), null);
let t = s;
t = gradeCard(t, "k.md#2#fwd", "good", T0, TODAY).session;
t = gradeCard(t, "k.md#1#fwd", "again", T0, TODAY).session;
t = gradeCard(t, "k.md#1#fwd", "easy", T0 + MIN, TODAY).session;
assert.equal(retention(t.log), 2 / 3);
assert.deepEqual(s.reviews, ["k.md#2#fwd"]);
assert.equal(s.log.length, 0);
assert.equal(nextCard(createSession([], TODAY, T0, { newLimit: 10 }), T0), null);
});
});
// The surface's copy travels in its own chunk (client/orbits/copy.ts), which
// check-i18n does not walk — so this is that table's parity gate, with the
// same rules: both halves present, the Arabic actually Arabic, and the
// placeholders the same on both sides.
describe("the decks' own copy", () => {
it("has both languages and matching placeholders for every key", () => {
const ph = (s: string): string => [...s.matchAll(/\{(\w+)\}/g)].map((m) => m[1]).sort().join(",");
for (const [key, text] of Object.entries(ORBITS_COPY)) {
assert.ok(text.en.trim() !== "", `${key}: empty en`);
assert.ok(text.ar.trim() !== "", `${key}: empty ar`);
assert.ok(/[-ۿ]/.test(text.ar), `${key}: ar has no Arabic script`);
assert.notEqual(text.en, text.ar, `${key}: untranslated`);
assert.equal(ph(text.en), ph(text.ar), `${key}: placeholders differ`);
}
assert.ok(Object.keys(ORBITS_COPY).length > 80);
});
});
// ── The client's walk, as the UI builder wrote it, over the kept machine ────
const DAY = "2026-09-15";
const NOW = Date.parse("2026-09-15T09:00:00Z");
function s2(line: number, schedule: DeckCard["schedule"] = null): DeckCard {
return { id: `n.md#${line}#fwd`, path: "n.md", line, end: line, dir: "fwd", kind: "qa", front: `f${line}`, back: `b${line}`, extra: null, section: null, tags: [], schedule };
}
describe("a session's queue, from the client's side", () => {
it("shows due reviews soonest first, then new stars, one after every four reviews", () => {
const stars = [
s2(1, { due: "2026-09-14", interval: 3, ease: 2500 }),
s2(2, { due: "2026-09-10", interval: 1, ease: 2500 }),
s2(3, { due: "2026-09-20", interval: 6, ease: 2500 }),
s2(4),
s2(5),
s2(6, { due: "2026-09-15", interval: 2, ease: 2500 }),
s2(7, { due: "2026-09-15", interval: 2, ease: 2500 }),
s2(8, { due: "2026-09-15", interval: 2, ease: 2500 }),
];
let s = createSession(stars, DAY, NOW, { newLimit: 10, steps: [1, 10] });
assert.deepEqual(s.reviews, ["n.md#2#fwd", "n.md#1#fwd", "n.md#6#fwd", "n.md#7#fwd", "n.md#8#fwd"]);
assert.deepEqual(s.fresh, ["n.md#4#fwd", "n.md#5#fwd"]);
const order: string[] = [];
for (let i = 0; i < 7; i++) {
const p = nextCard(s, NOW)!;
order.push(`${p.phase}:${p.star.id.split("#")[1]}`);
s = gradeCard(s, p.star.id, "easy", NOW, DAY).session;
}
assert.deepEqual(order, ["review:2", "review:1", "review:6", "review:7", "new:4", "review:8", "new:5"]);
assert.equal(nextCard(s, NOW), null);
});
it("caps new stars at the daily allowance and never limits reviews", () => {
const stars = [s2(1), s2(2), s2(3), s2(4, { due: "2026-01-01", interval: 1, ease: 2500 })];
const s = createSession(stars, DAY, NOW, { newLimit: 2 });
assert.equal(s.fresh.length, 2);
assert.equal(s.reviews.length, 1);
assert.equal(createSession(stars, DAY, NOW, { newLimit: 0 }).fresh.length, 0);
});
it("walks a new star through the learning steps and writes only on graduation", () => {
const n = s2(1);
let s = createSession([n], DAY, NOW, { newLimit: 10, steps: [1, 10] });
let p = nextCard(s, NOW)!;
assert.equal(p.phase, "new");
assert.deepEqual(previews(s, n.id, DAY)!.good, { minutes: 10 });
assert.deepEqual(previews(s, n.id, DAY)!.easy, { days: 4 });
assert.deepEqual(previews(s, n.id, DAY)!.again, { minutes: 1 });
let r = gradeCard(s, p.star.id, "good", NOW, DAY);
assert.equal(r.write, null);
s = r.session;
assert.equal(s.learning[0].step, 1);
assert.equal(s.learning[0].dueAt, NOW + 10 * MIN);
// Not due yet, but nothing else is left: shown early.
p = nextCard(s, NOW + MIN)!;
assert.equal(p.phase, "learning");
assert.equal(p.early, true);
assert.deepEqual(previews(s, n.id, DAY)!.good, { days: 1 });
r = gradeCard(s, p.star.id, "good", NOW + 11 * MIN, DAY);
assert.deepEqual(r.write, { due: "2026-09-16", interval: 1, ease: 2500 });
assert.equal(nextCard(r.session, NOW), null);
});
it("a lapse writes SM-2's again and relearns for ten minutes, then writes nothing more", () => {
const rv = s2(1, { due: "2026-09-14", interval: 12, ease: 2500 });
const s = createSession([rv], DAY, NOW, { newLimit: 10, steps: [1, 10] });
const p = nextCard(s, NOW)!;
assert.equal(p.phase, "review");
assert.deepEqual(previews(s, rv.id, DAY)!.good, { days: 30 });
const r = gradeCard(s, p.star.id, "again", NOW, DAY);
assert.deepEqual(r.write, { due: "2026-09-16", interval: 1, ease: 2300 });
assert.equal(r.session.learning.length, 1);
assert.equal(r.session.learning[0].phase, "relearning");
assert.equal(r.session.learning[0].dueAt, NOW + 10 * MIN);
// Ready learning stars come before anything else.
const again = nextCard(r.session, NOW + 10 * MIN)!;
assert.equal(again.phase, "relearning");
assert.equal(again.early, false);
const done = gradeCard(r.session, again.star.id, "good", NOW + 10 * MIN, DAY);
assert.equal(done.write, null);
assert.equal(nextCard(done.session, NOW + 10 * MIN), null);
});
it("study ahead takes the stars not yet due, soonest first, and no new ones", () => {
const stars = [s2(1, { due: "2026-09-20", interval: 6, ease: 2500 }), s2(2, { due: "2026-09-17", interval: 2, ease: 2500 }), s2(3)];
const s = createSession(stars, DAY, NOW, { newLimit: 0, studyAhead: true });
assert.deepEqual(s.reviews, ["n.md#2#fwd", "n.md#1#fwd"]);
assert.deepEqual(s.fresh, []);
});
});
describe("the shelf's numbers", () => {
it("counts a streak back from today, forgiving a day not yet studied", () => {
assert.equal(streakOf(["2026-09-15", "2026-09-14", "2026-09-13", "2026-09-10"], "2026-09-15"), 3);
assert.equal(streakOf(["2026-09-14", "2026-09-13"], "2026-09-15"), 2);
assert.equal(streakOf(["2026-09-12"], "2026-09-15"), 0);
assert.equal(streakOf([], "2026-09-15"), 0);
});
it("forecasts due stars per day with the overdue on today", () => {
const f = forecast([s2(1, { due: "2026-09-01", interval: 1, ease: 2500 }), s2(2, { due: "2026-09-17", interval: 2, ease: 2500 }), s2(3, { due: "2027-01-01", interval: 100, ease: 2500 }), s2(4)], DAY, 30);
assert.equal(f.length, 30);
assert.equal(f[0], 1);
assert.equal(f[2], 1);
assert.equal(f.reduce((a, b) => a + b, 0), 2);
});
it("splits stars into new, learning, young and mature", () => {
const st = statesOf([s2(1), s2(2, { due: "x", interval: 3, ease: 2500 }), s2(3, { due: "x", interval: 21, ease: 2500 })], new Set(["n.md#1#fwd"]));
assert.deepEqual(st, { new: 0, learning: 1, young: 1, mature: 1 });
});
});
describe("a typed answer", () => {
it("forgives case, space, Unicode form and kana width", () => {
assert.equal(normaliseAnswer(" Ｔｏｋｙｏ "), "tokyo");
assert.equal(normaliseAnswer("ｶﾀｶﾅ"), "カタカナ");
assert.equal(diffAnswer("Tokyo ", "tokyo").ok, true);
});
it("marks what was typed wrongly and what was missed", () => {
const d = diffAnswer("tokio", "tokyo");
assert.equal(d.ok, false);
assert.deepEqual(
d.ops.map((o) => `${o.kind}:${o.text}`),
["same:tok", "drop:i", "add:y", "same:o"],
);
});
});
describe("the CSV reader", () => {
it("picks the delimiter from the first line and reads quoted fields", () => {
assert.equal(delimiterOf("a\tb\tc\n"), "\t");
assert.equal(delimiterOf("a,b\n"), ",");
assert.equal(delimiterOf("a;b\n", "x.csv"), ";");
assert.deepEqual(parseDelimited('"Hello, world",b\n"say ""hi""",c\r\n', ","), [
["Hello, world", "b"],
['say "hi"', "c"],
]);
});
it("skips Anki's #-header lines", () => {
assert.equal(stripAnkiHeader("#separator:tab\n#html:true\nfront\tback\n"), "front\tback\n");
});
});
// ── The client's queue over the machine (client/orbits/queue.ts) ─────────────
function twin(line: number, front: string, back: string, dir: "fwd" | "rev" = "fwd", schedule: DeckCard["schedule"] = null): DeckCard {
return { id: `n.md#${line}#${dir}`, path: "n.md", line, end: line, dir, kind: "qa", front, back, extra: null, section: null, tags: [], schedule };
}
const HEAD = { path: "n.md", steps: [1, 10], newPerDay: 10 };
describe("the session keys", () => {
it("tell two stars with the same faces apart by their order, and survive a shifted line", () => {
const first = [twin(3, "dog", "chien"), twin(4, "cat", "chat"), twin(9, "dog", "chien"), twin(3, "chien", "dog", "rev")];
const keys = keysOf(first);
assert.equal(new Set(keys).size, 4, "four distinct keys");
// A comment line written after the cat moves the second dog down one.
const later = [twin(3, "dog", "chien"), twin(4, "cat", "chat"), twin(10, "dog", "chien"), twin(3, "chien", "dog", "rev")];
assert.deepEqual(keysOf(later), keys);
});
it("the queue shows both twins and writes each grade to its own line", () => {
store.clear();
const stars = [twin(3, "dog", "chien"), twin(9, "dog", "perro")];
const q = new CardQueue(HEAD, stars, DAY, false, NOW);
const a = q.grade("easy", NOW)!;
const b = q.grade("easy", NOW)!;
assert.deepEqual([a.star.line, b.star.line], [3, 9]);
assert.notEqual(a.key, b.key);
assert.equal(q.next(NOW), null);
assert.equal(newIntroduced("n.md", DAY), 2);
});
it("a re-read after a write keeps the reader's place and hands the write the moved line", () => {
store.clear();
const stars = [twin(5, "a", "1"), twin(7, "b", "2"), twin(9, "c", "3")];
const q = new CardQueue(HEAD, stars, DAY, false, NOW);
const first = q.grade("easy", NOW)!;
assert.equal(first.star.line, 5);
// The write put a comment line under `a`; every star below moved.
q.refresh([twin(5, "a", "1", "fwd", first.write), twin(8, "b", "2"), twin(10, "c", "3")]);
const next = q.next(NOW)!;
assert.equal(next.star.front, "b");
assert.equal(next.star.line, 8);
const second = q.grade("easy", NOW)!;
assert.equal(q.cardOf(second.key)?.line, 8);
// A star that vanished between reads is dropped, not shown blank.
q.refresh([twin(5, "a", "1", "fwd", first.write), twin(8, "b", "2", "fwd", second.write)]);
assert.equal(q.next(NOW), null);
});
it("undo gives back the schedule, the counter and the log entry; skip leaves a due star due", () => {
store.clear();
const due = { due: "2026-09-10", interval: 3, ease: 2500 };
const stars = [twin(3, "x", "1", "fwd", due), twin(4, "y", "2", "fwd", due), twin(5, "z", "3")];
const q = new CardQueue(HEAD, stars, DAY, false, NOW);
const g = q.grade("again", NOW)!;
assert.equal(g.star.front, "x");
assert.deepEqual(g.write, { due: "2026-09-16", interval: 1, ease: 2300 });
assert.equal(readLog().length, 1);
const back = q.undoLast()!;
assert.equal(back.wrote, true);
assert.deepEqual(back.restore, due);
assert.equal(readLog().length, 0);
assert.equal(q.next(NOW)!.star.front, "x", "the undone star is back in front");
q.grade("good", NOW);
assert.equal(q.next(NOW)!.star.front, "y");
q.skip();
const z = q.grade("easy", NOW)!;
assert.equal(z.star.front, "z");
assert.equal(newIntroduced("n.md", DAY), 1);
assert.equal(q.next(NOW), null);
const s = q.summary(NOW + 65_000);
assert.equal(s.graded, 2);
assert.equal(s.dueLeft, 1, "the skipped y is still due today");
assert.equal(s.seconds, 65);
assert.equal(q.canUndo(), true);
q.undoLast();
assert.equal(newIntroduced("n.md", DAY), 0, "undoing a new star's grade gives the day its allowance back");
});
it("reads the fence's steps and limit from the shelf row, defaults when the row's are unusable", () => {
const row = { path: "n.md", title: "n", icon: null, kind: "basic" as const, tags: [], implicit: false, counts: { total: 0, new: 0, due: 0 }, sections: [], steps: [], newPerDay: -1 };
assert.deepEqual(headOf(row), { path: "n.md", steps: [1, 10], newPerDay: 10 });
assert.deepEqual(headOf({ ...row, steps: [2, 20, 60], newPerDay: 0 }), { path: "n.md", steps: [2, 20, 60], newPerDay: 0 });
});
});
describe("the device's log", () => {
it("narrows retention and the hardest list to one note, and buckets the series by local day", () => {
const at = (day: string, h = 12): number => new Date(`${day}T${String(h).padStart(2, "0")}:00:00`).getTime();
const log = [
{ path: "a.md", line: 1, grade: "again" as const, ts: at("2026-09-15") },
{ path: "a.md", line: 1, grade: "good" as const, ts: at("2026-09-15") },
{ path: "a.md", line: 2, grade: "again" as const, ts: at("2026-09-14", 23) },
{ path: "b.md", line: 1, grade: "easy" as const, ts: at("2026-09-01") },
{ path: "b.md", line: 1, grade: "easy" as const, ts: at("2026-07-01") },
];
assert.equal(deviceRetention(log, DAY, 30, "a.md"), 1 / 3);
assert.equal(deviceRetention(log, DAY, 30, "b.md"), 1, "July is outside the window");
assert.equal(deviceRetention(log, DAY, 30, "c.md"), null);
const series = retentionSeries(log, DAY, 30, "a.md");
assert.equal(series.length, 30);
assert.equal(series[29], 0.5);
assert.equal(series[28], 0, "eleven at night is still that day");
assert.deepEqual(hardest(log, "a.md").map((r) => [r.line, r.again]), [[1, 1], [2, 1]]);
assert.deepEqual(hardest(log, "b.md"), []);
});
});
describe("the modal's card lines", () => {
it("reads two and three segments, the plugin's :::, CRLF, and skips what is not a card", () => {
const cards = cardsOfText("to eat::食べる::taberu\r\nto drink:::飲む\r\nnot a card\r\n::nothing\r\nfront::\r\nあ：a\r\n spaced :: out :: \r\n");
assert.deepEqual(cards, [
{ front: "to eat", back: "食べる", extra: "taberu" },
{ front: "to drink", back: "飲む", extra: null },
{ front: "spaced", back: "out", extra: null },
]);
});
});
describe("the CSV reader, harder", () => {
it("survives a BOM, CRLF, a semicolon file and a newline inside quotes", () => {
const text = 'front;back\r\n"a;b";"line one\nline two"\r\n\r\nc;d\r\n';
assert.equal(delimiterOf(text), ";");
assert.deepEqual(parseDelimited(text, ";"), [["front", "back"], ["a;b", "line one\nline two"], ["c", "d"]]);
});
});
describe("a typed answer, harder", () => {
it("folds width and case for kana and romaji, and reads an empty answer as all missed", () => {
assert.equal(normaliseAnswer("ｶﾀｶﾅ"), normaliseAnswer("カタカナ"));
assert.equal(normaliseAnswer("ＫＡ "), "ka");
assert.equal(diffAnswer("か", "か").ok, true);
const empty = diffAnswer("", "ka");
assert.equal(empty.ok, false);
assert.deepEqual(empty.ops, [{ kind: "add", text: "ka" }]);
});
});