explico 0.13.1 → 0.15.0

package/dist/rules/rules.schema.json

@@ -6,6 +6,265 @@
   "type": "object",
   "additionalProperties": false,
   "properties": {
+    "D1": {
+      "title": "D1 — A deck is sections of frames: `##` a section, `###` a frame",
+      "description": "In a `<lesson>.deck.mdx`, `##` opens a section, a divider frame that shows only its title, and `###` is a frame whose title is the heading. Write every line of content inside a `###` frame: no `#`, no `####` or deeper, nothing before the first heading and nothing between a `##` and its first `###`. Locked — a frame is the unit the deck page, Present mode and the PDF are built from — content outside one has no frame to show in.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "heading"
+      ],
+      "x-enforcement": "locked",
+      "x-doc": "docs/authoring/deck.md#d1",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {}
+    },
+    "D2": {
+      "title": "D2 — A frame fits its canvas in every step",
+      "description": "Everything a frame shows — title, body, legend line, at its last step — fits the course’s canvas (`deck.aspectRatio`). `content check` warns when a frame passes `maxWords` words or `maxBullets` list items. A frame that does not fit is two frames; never shrink its type. Not checked by the build: the paper: a frame that fits its canvas on the web can still run over in the PDF, which the export reports as a warning naming the frame.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide"
+      ],
+      "x-enforcement": "partial",
+      "x-doc": "docs/authoring/deck.md#d2",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        },
+        "maxWords": {
+          "title": "Most words on a frame",
+          "description": "Words a frame may show (its prose, not its math or notes) before `content check` warns.",
+          "type": "integer",
+          "minimum": 10,
+          "default": 70
+        },
+        "maxBullets": {
+          "title": "Most list items on a frame",
+          "description": "List items a frame may show before `content check` warns.",
+          "type": "integer",
+          "minimum": 1,
+          "default": 7
+        }
+      }
+    },
+    "D3": {
+      "title": "D3 — A frame makes one claim, and its title states it",
+      "description": "Title a frame with the sentence it shows to be true — “Range is largest at a 45° launch angle”, not “Range”. Everything on the frame serves that one claim; a second claim is a second frame.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "prose"
+      ],
+      "x-enforcement": "guide",
+      "x-doc": "docs/authoring/deck.md#d3",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the rule leaves the rules-in-effect page and an agent neither applies it nor flags it in review.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "D4": {
+      "title": "D4 — A frame with text carries speaker notes",
+      "description": "A `###` frame whose body has words carries a `<Notes>…</Notes>` block with what the speaker says: the reasoning, the transitions, the question to ask the room. A frame that shows only a picture, an equation or a question needs none. The prose rules hold for the notes.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "prose"
+      ],
+      "x-enforcement": "script",
+      "x-doc": "docs/authoring/deck.md#d4",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "D5": {
+      "title": "D5 — A frame title fits one line",
+      "description": "A `##` or `###` heading in a deck runs to at most `maxLength` characters as the reader sees it (math as it reads, a `[[key]]` term as its label), so it stays on one line of the canvas. Move the rest into the frame.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "heading"
+      ],
+      "x-enforcement": "script",
+      "x-doc": "docs/authoring/deck.md#d5",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        },
+        "maxLength": {
+          "title": "Longest frame title",
+          "description": "Characters a frame or section title may run to.",
+          "type": "integer",
+          "minimum": 10,
+          "default": 50
+        }
+      }
+    },
+    "D6": {
+      "title": "D6 — A frame shows in at most `maxSteps` steps, each adding to the last",
+      "description": "`<Pause />` is the one step mark: what follows it appears on the next key press, and nothing shown earlier changes or goes, so the last step is the whole frame — what the scroll view, the print and the PDF show. Keep to `maxSteps` steps; more is a second frame. Not checked by the build: that a later step contradicts nothing already shown.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide"
+      ],
+      "x-enforcement": "partial",
+      "x-doc": "docs/authoring/deck.md#d6",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        },
+        "maxSteps": {
+          "title": "Most steps in a frame",
+          "description": "Steps a frame may show in (one more than its `<Pause />` marks).",
+          "type": "integer",
+          "minimum": 1,
+          "default": 4
+        }
+      }
+    },
+    "D7": {
+      "title": "D7 — A frame holds one figure, table or diagram",
+      "description": "One `<Figure>`, `<Table>`, `<Diagram>` or recalled float per frame, laid out at the canvas width; a lab’s controls are the frame’s tools, live in Present mode. A second picture is a second frame.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "plot",
+        "table",
+        "diagram"
+      ],
+      "x-enforcement": "script",
+      "x-doc": "docs/authoring/deck.md#d7",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "D8": {
+      "title": "D8 — Recall a chapter’s result; never retype it",
+      "description": "Show the chapter’s equation, figure, table or diagram with `<Recall ref=\"eq-range\" />` (`fig-`, `tab-`, `dia-`): it renders as in the chapter, with the chapter’s number, and links back to it. A display equation retyped from the chapter is a warning. An equation the deck labels itself numbers (1), (2) within the deck; the deck’s figures, tables and diagrams are unnumbered.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "equation"
+      ],
+      "x-enforcement": "script",
+      "x-doc": "docs/authoring/deck.md#d8",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "D9": {
+      "title": "D9 — A frame introduces at most `maxNewSymbols` symbols",
+      "description": "The room reads a frame once. Count the symbols it shows for the first time in the deck and keep them to `maxNewSymbols`; the legend line under the frame names them. More than that is a frame of its own.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "math",
+        "notation"
+      ],
+      "x-enforcement": "script",
+      "x-doc": "docs/authoring/deck.md#d9",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        },
+        "maxNewSymbols": {
+          "title": "Most new symbols on a frame",
+          "description": "Symbols a frame may show for the first time in its deck.",
+          "type": "integer",
+          "minimum": 1,
+          "default": 4
+        }
+      }
+    },
+    "D10": {
+      "title": "D10 — A deck opens on its title and closes on what the student can now do",
+      "description": "The title frame (the lesson, the course, its authors and version) and the closing frame (the outcomes of the competencies the lesson teaches, `deck.outcomesFrame`) are generated: do not write them. With `deck.outcomesFrame` off, end on a `###` frame that says what the student can now do.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide"
+      ],
+      "x-enforcement": "guide",
+      "x-doc": "docs/authoring/deck.md#d10",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the rule leaves the rules-in-effect page and an agent neither applies it nor flags it in review.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
+    "D11": {
+      "title": "D11 — A deck is flagged when its chapter changed after it did",
+      "description": "No authoring action by itself: two files mean the chapter and the deck can drift apart with nothing to notice it. `deck-stale` is an info diagnostic naming a lesson’s own deck whose chapter’s rule C5 version is newer than the deck’s; read the chapter’s change and judge whether the deck needs it too. Scoped to a lesson’s own deck — a part’s deck covers more than one chapter, so it has none to compare against.",
+      "x-element": "slide",
+      "x-elements": [
+        "slide",
+        "changelog"
+      ],
+      "x-enforcement": "script",
+      "x-doc": "docs/authoring/deck.md#d11",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        }
+      }
+    },
     "N9": {
       "title": "N9 — A quantity/unit/operator is typeset in `$…$`, never as plain text",
       "description": "Never write `45 m/s`, `t (s)`, `vx` or `KE/m` as plain text, and never spell a stated quantity's unit out: \"4 seconds\", \"2 meters per second squared\", \"30 degrees\", \"$x = 3$ meters\" are `$4\\ \\text{s}$`, `$2\\ \\text{m/s}^2$`, `$30^{\\circ}$`, `$x = 3\\ \\text{m}$`. A unit inside math is `\\text{}`-wrapped, short form, in the same span as its number or symbol. A unit named on its own (\"measured in meters\") stays a word; a sentence that defines a unit is waived. JSX prop strings (`caption=\"…\"`) render no math, so N9 does not apply there; nor does it apply to an assessment choice label, which may still hold math (`$30^{\\circ}$`).",
@@ -324,7 +583,7 @@
     },
     "N4": {
       "title": "N4 — One meaning per glyph; define once; `[[key]]` before first math",
-      "description": "Every glyph in rendered math resolves to exactly one notation entry on the page: introduce it with `[[key]]` in prose before its first `$…$`, define a page-local one in `notation.local`, or bind a compound with `\\explain{key}{latex}`. Do not reuse a glyph for a second meaning on the same page. Locked — the notation layer is this rule — an unresolved glyph has no hover card and the render path needs every glyph bound.",
+      "description": "Every glyph in rendered math resolves to exactly one notation entry on the page: introduce it with `[[key]]` in prose before its first `$…$`, define a page-local one in `notation.local`, or bind a compound with `\\explain{key}{latex}`. Do not reuse a glyph for a second meaning on the same page. Declare a meaning once — a shared card unless the letter already means something else in the course, and only then `notation.local` or a gloss — and reference it everywhere else. Locked — the notation layer is this rule — an unresolved glyph has no hover card and the render path needs every glyph bound.",
       "x-element": "math",
       "x-elements": [
         "math",
@@ -1140,6 +1399,26 @@
           "default": true
         }
       }
+    },
+    "C5": {
+      "title": "C5 — Each chapter and part page carries the release its content last changed in; `content/versions.json` is generated and committed",
+      "description": "A page’s PDF, Markdown and `[?]` panel say \"unchanged since version 0.2.0\", the release its content last changed in, or \"with changes after version 0.4.0, not yet released\" while `## [Unreleased]` holds its change. The record is `content/versions.json`: `validate:content` works it out from the committed file and the content, writes it on a developer’s machine, and in CI fails when the committed file is not the one it would write. Never edit it by hand; commit what `validate:content` wrote with the content change, and with a release. Not checked by the build: which bullet of `## [Unreleased]` belongs to which page — every page changed while there is any bullet counts as not yet released; and a change to a lab, `content/domain/` or a part’s label, which changes the page’s PDF without changing its version.",
+      "x-element": "changelog",
+      "x-elements": [
+        "changelog"
+      ],
+      "x-enforcement": "partial",
+      "x-doc": "docs/authoring/versioning.md#c5",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "title": "Enabled",
+          "description": "Off: the check does not run, and the rule leaves the rules-in-effect page.",
+          "type": "boolean",
+          "default": true
+        }
+      }
     }
   }
 }

package/dist/rules/settings.d.ts

@@ -1,3 +1,3 @@
 import './catalog.js';
 import './course-rules.js';
-export { d as ConfigDiagnostic, j as CourseRulesConfig, M as ManifestRules, R as ResolvedRules, k as RuleSettingsInput, l as catalogIds, m as disabledCodes, n as dropDisabled, p as partPageLimits, r as resolveRules, o as rulesJsonSchema, q as rulesSnapshot } from '../course-config-rRtME5UV.js';
+export { h as ConfigDiagnostic, n as CourseRulesConfig, M as ManifestRules, o as ResolvedRules, p as RuleSettingsInput, q as catalogIds, r as disabledCodes, s as dropDisabled, t as partPageLimits, u as resolveRules, v as rulesJsonSchema, w as rulesSnapshot } from '../course-config-BLtIdkei.js';

package/dist/session/PreferenceStore.d.ts

@@ -22,6 +22,12 @@ interface PreferenceStore {
      * fits; a caller without it writes an empty value instead.
      */
     remove?(key: string): void;
+    /**
+     * Every key the store holds. Optional like `remove`; the reading-memory
+     * question (`reading-memory.ts`) uses it to forget a course's per-page
+     * entries, whose names it cannot list otherwise.
+     */
+    keys?(): string[];
 }
 /**
  * A `localStorage`-backed store. Every call is wrapped: storage can be absent

package/dist/session/PreferenceStore.js

@@ -18,6 +18,14 @@ function createBrowserPreferenceStore() {
         window.localStorage.removeItem(key);
       } catch {
       }
+    },
+    keys() {
+      try {
+        const storage = window.localStorage;
+        return Array.from({ length: storage.length }, (_, index) => storage.key(index) ?? "").filter(Boolean);
+      } catch {
+        return [];
+      }
     }
   };
 }
@@ -41,6 +49,14 @@ function createSessionPreferenceStore() {
         window.sessionStorage.removeItem(key);
       } catch {
       }
+    },
+    keys() {
+      try {
+        const storage = window.sessionStorage;
+        return Array.from({ length: storage.length }, (_, index) => storage.key(index) ?? "").filter(Boolean);
+      } catch {
+        return [];
+      }
     }
   };
 }
@@ -56,7 +72,8 @@ function createMemoryPreferenceStore() {
     },
     remove: (key) => {
       map.delete(key);
-    }
+    },
+    keys: () => [...map.keys()]
   };
 }
 export {

package/dist/session/deck-memory.d.ts

@@ -0,0 +1,116 @@
+/**
+ * What a reader's decks remember (`docs/authoring/deck.md`, "Present mode and
+ * the study page"): for each deck, the frame and the step Present mode last
+ * stood on, and every frame it showed them, as it was. A frame's content is
+ * named by its id (`ManifestDeckFrame.id`, 12 hex digits of a hash over what
+ * it shows), so a frame that changed since the reader was shown it is told
+ * from one they were never shown, as `page-marks.ts` tells pages apart.
+ *
+ * One small JSON map per course,
+ * `{ "v": 2, "decks": { slug: { at, step, seen } } }`, kept through the
+ * `PreferenceStore` under `deckPositionsKey(base)`. It is reading memory
+ * (`reading-memory.ts`): with the reader's yes it is kept
+ * across visits; before an answer it is kept for the tab, as kept cards are;
+ * after a no, only where each deck stopped is, for the tab. Version 1,
+ * `{ slug: number }`, held the stopping place alone, and reads as version 2
+ * with no frame shown.
+ *
+ * Pure: `components/deck/deck-controller.ts` does the DOM and the storage on
+ * a deck's page, the sidebar's script (`LayoutSidebar.astro`) its two
+ * actions, which cover every deck, `reading-memory.ts` what the reader's
+ * answer does to the tab's record, and `tests/unit/deck-memory.test.ts`
+ * checks this in Node.
+ */
+/** A frame as the page knows it: its number in the deck, and its content's id. */
+interface DeckFrameId {
+    readonly number: number;
+    readonly id: string;
+}
+/** A frame as the study page knows it, with the steps it has (`data-steps`). */
+interface DeckFrameSteps extends DeckFrameId {
+    readonly steps: number;
+}
+/** A deck as the sidebar's two actions need it. */
+interface DeckFrames {
+    /** Its route, as `.deck[data-deck]` names it: `motion/position-and-coordinates/slides`. */
+    readonly slug: string;
+    readonly frames: readonly DeckFrameId[];
+}
+/** What one deck remembers. */
+interface DeckRecord {
+    /** The frame Present mode last stood on, by number. */
+    readonly at?: number;
+    /** The step of that frame it stood on: none in a record kept before steps were. */
+    readonly step?: number;
+    /** The frames Present mode showed, by number: the id each had then. */
+    readonly seen: ReadonlyMap<number, string>;
+}
+/** Where "Continue" presents from (`resumeAt`). */
+interface Resume {
+    /** The frame, by its number now; the first frame for "Present again". */
+    readonly number: number;
+    /** The reader was shown every step of the deck's last frame: "Present again". */
+    readonly again: boolean;
+}
+/** Every deck's record, by its slug. */
+type DeckMemory = ReadonlyMap<string, DeckRecord>;
+/** A frame's mark on the study page: not shown in Present mode yet, or changed since it was. */
+type FrameMark = 'unseen' | 'changed';
+/**
+ * Told on a page after deck memory was written there, so the deck's page and
+ * the sidebar read it again; another tab hears the `storage` event.
+ */
+declare const DECK_MEMORY_EVENT = "explico:deck-memory";
+/**
+ * Every deck's record, from the stored text. Version 1 becomes version 2,
+ * each deck's place kept and no frame shown. Anything else, and any entry
+ * that is not a frame number or a frame's id, is dropped, never trusted.
+ */
+declare function decodeDeckMemory(raw: string | null): DeckMemory;
+/** The stored text: decks sorted by slug, frames by number, so the same state is always the same string. */
+declare function encodeDeckMemory(memory: DeckMemory): string;
+/**
+ * The record after Present mode stood on step `step` of frame `number` of
+ * `slug`, while the frames shown are not kept: the place alone, the frames
+ * shown left as they were.
+ */
+declare function withPosition(memory: DeckMemory, slug: string, number: number, step: number): Map<string, DeckRecord>;
+/**
+ * The record after Present mode showed `frame` of `slug` at step `step`, in
+ * the room's window or the presenter's (D8): the reader stands there, and has
+ * seen the frame as it is now, whichever of its steps they saw.
+ */
+declare function withShown(memory: DeckMemory, slug: string, frame: DeckFrameId, step: number): Map<string, DeckRecord>;
+/** "Mark all as seen" on a deck's page: every frame of `slug` seen as it is now. Where it stopped stays. */
+declare function withAllSeen(memory: DeckMemory, slug: string, frames: readonly DeckFrameId[]): Map<string, DeckRecord>;
+/** "Mark all as unseen" on a deck's page: no frame of `slug` seen. Where it stopped stays. */
+declare function withNoneSeen(memory: DeckMemory, slug: string): Map<string, DeckRecord>;
+/**
+ * Two records as one, for the reader's yes (`reading-memory.ts`): what the
+ * tab kept before it (`newer`) joins what the browser kept from an earlier
+ * visit (`older`). Each deck stops where `newer` says, when it says; a frame
+ * shown in both is as `newer` saw it.
+ */
+declare function mergeDeckMemory(older: DeckMemory, newer: DeckMemory): Map<string, DeckRecord>;
+/** The sidebar's "Mark all as seen" (D9): every frame of every deck seen as it is now. */
+declare function withEveryDeckSeen(memory: DeckMemory, decks: readonly DeckFrames[]): Map<string, DeckRecord>;
+/** The sidebar's "Mark all as unseen" (D9): no frame of any deck seen. Where each stopped stays. */
+declare function withEveryDeckUnseen(memory: DeckMemory): Map<string, DeckRecord>;
+/**
+ * A frame's mark for a reader whose record of its deck is `record`: none
+ * when they were shown it as it is now, whatever its number was then (a
+ * frame added before it moves it, and it is still the frame they saw);
+ * `changed` when its place showed them something else; else `unseen`.
+ */
+declare function frameMark(frame: DeckFrameId, record: DeckRecord | undefined): FrameMark | undefined;
+/**
+ * Where "Continue at slide N" presents from (D7): the frame the reader
+ * stopped at, unless they were shown its every step, then the frame after it
+ * — or, after the last frame, "Present again" from the first. The frame is
+ * followed to its number now when frames were added or taken out before it,
+ * by the id it had. None when nothing is remembered or the deck no longer
+ * has that frame. A record kept before steps were counts as stopped partway.
+ */
+declare function resumeAt(record: DeckRecord | undefined, frames: readonly DeckFrameSteps[]): Resume | undefined;
+
+export { DECK_MEMORY_EVENT, type DeckFrameId, type DeckFrameSteps, type DeckFrames, type DeckMemory, type DeckRecord, type FrameMark, type Resume, decodeDeckMemory, encodeDeckMemory, frameMark, mergeDeckMemory, resumeAt, withAllSeen, withEveryDeckSeen, withEveryDeckUnseen, withNoneSeen, withPosition, withShown };

package/dist/session/deck-memory.js

@@ -0,0 +1,143 @@
+const DECK_MEMORY_EVENT = "explico:deck-memory";
+const VERSION = 2;
+const ID = /^[0-9a-f]{12}$/u;
+const NUMBER = /^[1-9][0-9]*$/u;
+function isFrameNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function place(at, step) {
+  if (at === void 0) return {};
+  return step === void 0 ? { at } : { at, step };
+}
+function byText(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function readRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const { at, step, seen } = value;
+  const frames = /* @__PURE__ */ new Map();
+  if (seen && typeof seen === "object" && !Array.isArray(seen)) {
+    for (const [number, id] of Object.entries(seen)) {
+      if (NUMBER.test(number) && isFrameNumber(Number(number)) && typeof id === "string" && ID.test(id)) {
+        frames.set(Number(number), id);
+      }
+    }
+  }
+  if (!isFrameNumber(at) && frames.size === 0) return void 0;
+  return { ...isFrameNumber(at) ? place(at, isFrameNumber(step) ? step : void 0) : {}, seen: frames };
+}
+function decodeDeckMemory(raw) {
+  const memory = /* @__PURE__ */ new Map();
+  if (!raw) return memory;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return memory;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return memory;
+  const stored = parsed;
+  if (!("v" in stored)) {
+    for (const [slug, at] of Object.entries(stored)) {
+      if (slug.length > 0 && isFrameNumber(at)) memory.set(slug, { at, seen: /* @__PURE__ */ new Map() });
+    }
+    return memory;
+  }
+  const { v, decks } = stored;
+  if (v !== VERSION || !decks || typeof decks !== "object" || Array.isArray(decks)) return memory;
+  for (const [slug, value] of Object.entries(decks)) {
+    const record = slug.length > 0 ? readRecord(value) : void 0;
+    if (record) memory.set(slug, record);
+  }
+  return memory;
+}
+function encodeDeckMemory(memory) {
+  const decks = [...memory].sort(([a], [b]) => byText(a, b)).map(([slug, record]) => [
+    slug,
+    {
+      ...place(record.at, record.step),
+      seen: Object.fromEntries([...record.seen].sort(([a], [b]) => a - b).map(([number, id]) => [String(number), id]))
+    }
+  ]);
+  return JSON.stringify({ v: VERSION, decks: Object.fromEntries(decks) });
+}
+function withRecord(memory, slug, record) {
+  const next = new Map(memory);
+  if (record && (record.at !== void 0 || record.seen.size > 0)) next.set(slug, record);
+  else next.delete(slug);
+  return next;
+}
+function withPosition(memory, slug, number, step) {
+  return withRecord(memory, slug, { ...place(number, step), seen: memory.get(slug)?.seen ?? /* @__PURE__ */ new Map() });
+}
+function withShown(memory, slug, frame, step) {
+  const seen = new Map(memory.get(slug)?.seen);
+  seen.set(frame.number, frame.id);
+  return withRecord(memory, slug, { ...place(frame.number, step), seen });
+}
+function withAllSeen(memory, slug, frames) {
+  const record = memory.get(slug);
+  return withRecord(memory, slug, {
+    ...place(record?.at, record?.step),
+    seen: new Map(frames.map((frame) => [frame.number, frame.id]))
+  });
+}
+function withNoneSeen(memory, slug) {
+  const record = memory.get(slug);
+  return withRecord(memory, slug, record?.at === void 0 ? void 0 : { ...place(record.at, record.step), seen: /* @__PURE__ */ new Map() });
+}
+function mergeDeckMemory(older, newer) {
+  const merged = new Map(older);
+  for (const [slug, record] of newer) {
+    const before = older.get(slug);
+    const at = record.at ?? before?.at;
+    merged.set(slug, {
+      ...place(at, record.at === void 0 ? before?.step : record.step),
+      seen: new Map([...before?.seen ?? [], ...record.seen])
+    });
+  }
+  return merged;
+}
+function withEveryDeckSeen(memory, decks) {
+  let next = new Map(memory);
+  for (const deck of decks) next = withAllSeen(next, deck.slug, deck.frames);
+  return next;
+}
+function withEveryDeckUnseen(memory) {
+  let next = new Map(memory);
+  for (const slug of memory.keys()) next = withNoneSeen(next, slug);
+  return next;
+}
+function frameMark(frame, record) {
+  const seen = record?.seen;
+  if (!seen || seen.size === 0) return "unseen";
+  if (seen.get(frame.number) === frame.id) return void 0;
+  for (const id of seen.values()) if (id === frame.id) return void 0;
+  return seen.has(frame.number) ? "changed" : "unseen";
+}
+function resumeAt(record, frames) {
+  const at = record?.at;
+  if (at === void 0) return void 0;
+  const id = record?.seen.get(at);
+  const there = frames.find((frame) => frame.number === at);
+  const moved = id === void 0 || there?.id === id ? void 0 : frames.find((frame) => frame.id === id);
+  const stopped = moved ?? there;
+  if (!stopped) return void 0;
+  if (record?.step === void 0 || record.step < stopped.steps) return { number: stopped.number, again: false };
+  const after = frames[frames.indexOf(stopped) + 1];
+  return after ? { number: after.number, again: false } : { number: frames[0].number, again: true };
+}
+export {
+  DECK_MEMORY_EVENT,
+  decodeDeckMemory,
+  encodeDeckMemory,
+  frameMark,
+  mergeDeckMemory,
+  resumeAt,
+  withAllSeen,
+  withEveryDeckSeen,
+  withEveryDeckUnseen,
+  withNoneSeen,
+  withPosition,
+  withShown
+};