explico 0.13.0 → 0.14.0

package/dist/rules/catalog.js

@@ -1,4 +1,5 @@
 const ELEMENTS = [
+  "slide",
   "prose",
   "math",
   "equation",
@@ -16,11 +17,16 @@ const COURSE_RULE_ID = /^X[1-9][0-9]?$/;
 function isCourseRuleId(id) {
   return COURSE_RULE_ID.test(id);
 }
+function appliesTo(entry, edition) {
+  const editions = entry.editions ?? "both";
+  return editions === "both" || editions === edition;
+}
 const GATE_MATH = { module: "src/reference/gate-math.ts", fn: "resolveInto" };
 const GLYPHS = { module: "src/reference/math-glyphs.mjs", fn: "resolveMathGlyphs" };
 const REGISTRY = { module: "src/reference/registry.ts", fn: "buildNotationRegistry" };
 const KEYED_FLOATS = { module: "src/reference/keyed-float-validate.ts", fn: "validateKeyedFloats" };
 const INDICES = { module: "src/reference/gate-indices.ts", fn: "gateIndices" };
+const DECKS = { module: "src/reference/decks-validate.ts", fn: "validateDecks" };
 function consistency(fn) {
   return { module: "src/reference/consistency.ts", fn };
 }
@@ -138,12 +144,14 @@ const RULES = [
     title: "One meaning per glyph per page; define once; introduce with `[[key]]` before the first math use.",
     elements: ["math", "notation"],
     doc: "notation.md#n4",
-    summary: "Every glyph in rendered math resolves to exactly one notation entry on the page: introduce it with `[[key]]` in prose before its first `$\u2026$`, 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.",
+    summary: "Every glyph in rendered math resolves to exactly one notation entry on the page: introduce it with `[[key]]` in prose before its first `$\u2026$`, 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 \u2014 a shared card unless the letter already means something else in the course, and only then `notation.local` or a gloss \u2014 and reference it everywhere else.",
     checks: [
       check("unresolved-glyph", "error", true, GATE_MATH),
       check("glyph-unique-in-corpus", "warning", false, consistency("checkGlyphUniqueness")),
       check("weak-local", "info", false, consistency("checkWeakLocal")),
-      check("gloss-wants-promoting", "info", false, consistency("checkGlossWantsPromoting")),
+      check("definition-repeated", "warning", false, consistency("checkDefinitionRepeated")),
+      check("meaning-repeated", "info", false, consistency("checkMeaningRepeated")),
+      check("explain-redundant", "info", true, GATE_MATH),
       check("card-wants-demoting", "info", false, consistency("checkCardWantsDemoting"))
     ],
     locked: "the notation layer is this rule \u2014 an unresolved glyph has no hover card and the render path needs every glyph bound."
@@ -489,6 +497,8 @@ const RULES = [
   {
     kind: "rule",
     id: "V7",
+    // Chapter-only: on a deck, rule D2 (a frame fits its canvas) says it of a frame.
+    editions: "chapter",
     short: "A figure\u2019s picture fits on one screen",
     title: "A figure\u2019s picture takes at most `maxPercent` of the screen height.",
     elements: ["plot"],
@@ -513,6 +523,8 @@ const RULES = [
   {
     kind: "rule",
     id: "V8",
+    // Chapter-only: on a deck, rule D7 (a float is the frame) says it of a frame.
+    editions: "chapter",
     short: "A diagram fits the lesson column",
     title: "A diagram is no wider than the lesson column.",
     elements: ["diagram"],
@@ -578,10 +590,32 @@ const RULES = [
     ],
     unchecked: "that the two edits landed in one commit \u2014 the build only ever sees the end state, so a release split across commits warns until the second half lands."
   },
+  {
+    kind: "rule",
+    id: "C5",
+    short: "Each chapter and part page carries the release its content last changed in; `content/versions.json` is generated and committed",
+    title: "Each chapter and part page carries the knowledge version its content last changed in, kept in `content/versions.json`, which `validate:content` writes and the course commits with the change.",
+    elements: ["changelog"],
+    doc: "versioning.md#c5",
+    summary: 'A page\u2019s 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\u2019s 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.',
+    checks: [
+      check("page-versions-stale", "error", false, {
+        module: "src/compiler/page-versions.ts",
+        fn: "syncPageVersions"
+      }),
+      check("page-versions-invalid", "warning", false, {
+        module: "src/compiler/page-versions.ts",
+        fn: "readPageVersions"
+      })
+    ],
+    unchecked: "which bullet of `## [Unreleased]` belongs to which page \u2014 every page changed while there is any bullet counts as not yet released; and a change to a lab, `content/domain/` or a part\u2019s label, which changes the page\u2019s PDF without changing its version."
+  },
   // ---- S — structure ----------------------------------------------------------
   {
     kind: "rule",
     id: "S1",
+    // Chapter-only: on a deck, rule D5 (a frame title fits one line) says it of a frame.
+    editions: "chapter",
     short: "No heading, short caption or short-note title over 65 characters",
     title: "No heading, no short caption (`short`, an equation\u2019s `\\caption{}`) and no short-note title runs past 65 characters.",
     elements: ["heading"],
@@ -686,6 +720,8 @@ const RULES = [
   {
     kind: "rule",
     id: "S6",
+    // Chapter-only: on a deck, rule D1 (sections of frames) says it of a frame.
+    editions: "chapter",
     short: "Headings descend one level at a time, from `##`",
     title: "Headings descend one level at a time: a lesson body starts at `##` and never skips a level on the way down.",
     elements: ["heading"],
@@ -707,6 +743,8 @@ const RULES = [
   {
     kind: "rule",
     id: "S7",
+    // Chapter-only: on a deck, rule D1 (sections of frames) says it of a frame.
+    editions: "chapter",
     short: "A heading is followed by body content, never by another heading",
     title: "A heading is followed by body content, never directly by another heading.",
     elements: ["heading"],
@@ -853,6 +891,165 @@ const RULES = [
     doc: "prose.md#p9",
     summary: "The sentence before a display equation names the quantity it yields and the step or law it follows from \u2014 not \u201Cwe have:\u201D.",
     checks: []
+  },
+  // ---- D — decks --------------------------------------------------------------
+  {
+    kind: "rule",
+    id: "D1",
+    editions: "deck",
+    short: "A deck is sections of frames: `##` a section, `###` a frame",
+    title: "A deck is sections of frames: `##` opens a section, `###` is a frame, and nothing is deeper or outside a frame.",
+    elements: ["slide", "heading"],
+    doc: "deck.md#d1",
+    summary: "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 `###`.",
+    checks: [
+      check("frame-depth", "error", true, DECKS),
+      check("deck-loose-content", "error", true, DECKS),
+      check("deck-empty", "error", false, DECKS)
+    ],
+    locked: "a frame is the unit the deck page, Present mode and the PDF are built from \u2014 content outside one has no frame to show in."
+  },
+  {
+    kind: "rule",
+    id: "D2",
+    editions: "deck",
+    short: "A frame fits its canvas in every step",
+    title: "A frame fits its canvas in every step, and never continues on the next frame.",
+    elements: ["slide"],
+    doc: "deck.md#d2",
+    summary: "Everything a frame shows \u2014 title, body, legend line, at its last step \u2014 fits the course\u2019s 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.",
+    checks: [
+      check("frame-dense", "warning", true, DECKS),
+      check("frame-overflow", "error", false, { module: "src/compiler/exports/deck-fit.ts", fn: "checkFrameFit" })
+    ],
+    unchecked: "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.",
+    settings: [
+      {
+        key: "maxWords",
+        title: "Most words on a frame",
+        description: "Words a frame may show (its prose, not its math or notes) before `content check` warns.",
+        schema: { type: "integer", minimum: 10, default: 70 }
+      },
+      {
+        key: "maxBullets",
+        title: "Most list items on a frame",
+        description: "List items a frame may show before `content check` warns.",
+        schema: { type: "integer", minimum: 1, default: 7 }
+      }
+    ]
+  },
+  {
+    kind: "rule",
+    id: "D3",
+    editions: "deck",
+    short: "A frame makes one claim, and its title states it",
+    title: "A frame makes one claim, and its title states the claim.",
+    elements: ["slide", "prose"],
+    doc: "deck.md#d3",
+    summary: "Title a frame with the sentence it shows to be true \u2014 \u201CRange is largest at a 45\xB0 launch angle\u201D, not \u201CRange\u201D. Everything on the frame serves that one claim; a second claim is a second frame.",
+    checks: []
+  },
+  {
+    kind: "rule",
+    id: "D4",
+    editions: "deck",
+    short: "A frame with text carries speaker notes",
+    title: "A frame with text carries speaker notes: the argument is in `<Notes>`, the frame shows its claims.",
+    elements: ["slide", "prose"],
+    doc: "deck.md#d4",
+    summary: "A `###` frame whose body has words carries a `<Notes>\u2026</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.",
+    checks: [check("frame-notes-missing", "warning", true, DECKS)]
+  },
+  {
+    kind: "rule",
+    id: "D5",
+    editions: "deck",
+    short: "A frame title fits one line",
+    title: "A frame title fits one line: at most `maxLength` characters.",
+    elements: ["slide", "heading"],
+    doc: "deck.md#d5",
+    summary: "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.",
+    checks: [check("frame-title-length", "error", true, DECKS)],
+    settings: [
+      {
+        key: "maxLength",
+        title: "Longest frame title",
+        description: "Characters a frame or section title may run to.",
+        schema: { type: "integer", minimum: 10, default: 50 }
+      }
+    ]
+  },
+  {
+    kind: "rule",
+    id: "D6",
+    editions: "deck",
+    short: "A frame shows in at most `maxSteps` steps, each adding to the last",
+    title: "A frame shows in at most `maxSteps` steps, and each step adds to what is shown.",
+    elements: ["slide"],
+    doc: "deck.md#d6",
+    summary: "`<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 \u2014 what the scroll view, the print and the PDF show. Keep to `maxSteps` steps; more is a second frame.",
+    checks: [check("frame-steps", "warning", true, DECKS)],
+    unchecked: "that a later step contradicts nothing already shown.",
+    settings: [
+      {
+        key: "maxSteps",
+        title: "Most steps in a frame",
+        description: "Steps a frame may show in (one more than its `<Pause />` marks).",
+        schema: { type: "integer", minimum: 1, default: 4 }
+      }
+    ]
+  },
+  {
+    kind: "rule",
+    id: "D7",
+    editions: "deck",
+    short: "A frame holds one figure, table or diagram",
+    title: "A frame holds at most one figure, table or diagram, and it is the frame\u2019s picture.",
+    elements: ["slide", "plot", "table", "diagram"],
+    doc: "deck.md#d7",
+    summary: "One `<Figure>`, `<Table>`, `<Diagram>` or recalled float per frame, laid out at the canvas width; a lab\u2019s controls are the frame\u2019s tools, live in Present mode. A second picture is a second frame.",
+    checks: [check("frame-floats", "warning", true, DECKS)]
+  },
+  {
+    kind: "rule",
+    id: "D8",
+    editions: "deck",
+    short: "Recall a chapter\u2019s result; never retype it",
+    title: "A result the chapter numbers is recalled with `<Recall>`, never retyped; the deck\u2019s own floats carry no number.",
+    elements: ["slide", "equation"],
+    doc: "deck.md#d8",
+    summary: 'Show the chapter\u2019s equation, figure, table or diagram with `<Recall ref="eq-range" />` (`fig-`, `tab-`, `dia-`): it renders as in the chapter, with the chapter\u2019s 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\u2019s figures, tables and diagrams are unnumbered.',
+    checks: [check("frame-retyped", "warning", true, DECKS)]
+  },
+  {
+    kind: "rule",
+    id: "D9",
+    editions: "deck",
+    short: "A frame introduces at most `maxNewSymbols` symbols",
+    title: "A frame introduces at most `maxNewSymbols` symbols the deck has not shown before.",
+    elements: ["slide", "math", "notation"],
+    doc: "deck.md#d9",
+    summary: "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.",
+    checks: [check("frame-new-symbols", "info", true, DECKS)],
+    settings: [
+      {
+        key: "maxNewSymbols",
+        title: "Most new symbols on a frame",
+        description: "Symbols a frame may show for the first time in its deck.",
+        schema: { type: "integer", minimum: 1, default: 4 }
+      }
+    ]
+  },
+  {
+    kind: "rule",
+    id: "D10",
+    editions: "deck",
+    short: "A deck opens on its title and closes on what the student can now do",
+    title: "A deck opens on its title frame and closes on what the student can now do.",
+    elements: ["slide"],
+    doc: "deck.md#d10",
+    summary: "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.",
+    checks: []
   }
 ];
 const RETIRED = [
@@ -1104,6 +1301,27 @@ const INVARIANTS = [
         fn: "gateMdxExpressions"
       })
     ]
+  },
+  {
+    kind: "invariant",
+    id: "decks",
+    editions: "deck",
+    title: "A deck belongs to a lesson or a part, and recalls what its chapters number.",
+    elements: ["slide"],
+    doc: "deck.md#the-deck-file",
+    summary: "A deck is `content/docs/<part>/<lesson>.deck.mdx`, or a part\u2019s `content/docs/<part>/index.deck.mdx`. Beside a chapter, and as a part\u2019s, it sets only `title` and `description` \u2014 the chapter holds the lesson\u2019s `teaches`, `assumptions`, `studyMinutes` and `notation`; alone, it is the lesson and carries them. On a part\u2019s deck, `## Title [chapter: <name>]` names the chapter a section covers: a chapter of the part, once, and only on a `##` of a part\u2019s deck. `<Recall ref>` names an equation, figure, table or diagram of the deck\u2019s own chapter, or of a chapter a part\u2019s deck covers; `<AssessmentSet>` on a part\u2019s deck sits in a section that names a chapter; `<Pause>` takes only `control`, `from`, `to`, `seconds` (a driven figure) or `highlight` (a spotlight).",
+    checks: [
+      check("deck-frontmatter", "error", false, DECKS),
+      check("deck-outside-part", "error", false, DECKS),
+      check("recall-unresolved", "error", true, DECKS),
+      check("pause-invalid", "error", true, DECKS),
+      check("deck-chapter-unknown", "error", true, DECKS),
+      check("deck-chapter-repeated", "error", true, DECKS),
+      check("deck-chapter-outside-part", "error", true, DECKS),
+      check("deck-marker-misplaced", "error", true, DECKS),
+      check("deck-check-no-chapter", "error", true, DECKS),
+      check("deck-route-taken", "error", false, DECKS)
+    ]
   }
 ];
 const CATALOG = [...RULES, ...INVARIANTS];
@@ -1160,6 +1378,7 @@ function ownedCodes() {
 export {
   CATALOG,
   ELEMENTS,
+  appliesTo,
   enforcementOf,
   entryById,
   invariants,

package/dist/rules/course-rules.d.ts

@@ -1,4 +1,4 @@
-import { CourseRuleId, Element, RuleEntry } from './catalog.js';
+import { CourseRuleId, Element, Editions, RuleEntry } from './catalog.js';
 
 /**
  * A course's own rules — `courseRules` in `course.settings.json`.
@@ -65,6 +65,8 @@ interface CourseRuleInput {
     readonly forbid?: readonly CourseRulePatternInput[];
     readonly unchecked?: string;
     readonly doc?: string;
+    /** `chapter`, `deck` or `both` (the default): the edition of a lesson the rule is about. */
+    readonly editions?: string;
 }
 /** `CourseConfig.courseRules` — an array, so the settings form can add and remove one. */
 type CourseRuleDefinitions = readonly CourseRuleInput[];
@@ -85,6 +87,8 @@ interface CourseRule {
     readonly forbid: readonly CourseRulePattern[];
     readonly unchecked?: string;
     readonly doc?: string;
+    /** The edition of a lesson the rule is about (`docs/authoring/deck.md`). */
+    readonly editions: Editions;
 }
 /**
  * Validate `config.courseRules` and apply the defaults. Throws on anything that

package/dist/rules/course-rules.js

@@ -97,7 +97,7 @@ function resolveCourseRules(config) {
       );
     }
     const raw = input;
-    const known = ["id", "title", "summary", "elements", "enabled", "severity", "forbid", "unchecked", "doc"];
+    const known = ["id", "title", "summary", "elements", "enabled", "severity", "forbid", "unchecked", "doc", "editions"];
     for (const key of Object.keys(raw)) {
       if (!known.includes(key)) {
         throw new Error(`${at(index)}: unknown key \`${key}\`. Takes: ${known.join(", ")}.`);
@@ -128,6 +128,11 @@ function resolveCourseRules(config) {
         `${where}.severity must be "error" or "warning"; received ${describe(raw.severity)}.`
       );
     }
+    if (raw.editions !== void 0 && raw.editions !== "both" && raw.editions !== "chapter" && raw.editions !== "deck") {
+      throw new Error(
+        `${where}.editions must be "both", "chapter" or "deck"; received ${describe(raw.editions)}.`
+      );
+    }
     const forbidInput = raw.forbid;
     if (forbidInput !== void 0 && !Array.isArray(forbidInput)) {
       throw new Error(`${where}.forbid must be an array of patterns; received ${describe(forbidInput)}.`);
@@ -149,7 +154,8 @@ function resolveCourseRules(config) {
       severity: raw.severity ?? "error",
       forbid,
       ...raw.unchecked === void 0 ? {} : { unchecked: requireString(raw.unchecked, `${where}.unchecked`) },
-      ...raw.doc === void 0 ? {} : { doc: requireString(raw.doc, `${where}.doc`) }
+      ...raw.doc === void 0 ? {} : { doc: requireString(raw.doc, `${where}.doc`) },
+      editions: raw.editions ?? "both"
     });
   });
   return out;
@@ -174,7 +180,8 @@ function courseRuleEntry(rule) {
     summary: rule.summary,
     checks,
     ...rule.unchecked === void 0 ? {} : { unchecked: rule.unchecked },
-    source: "course"
+    source: "course",
+    ...rule.editions === "both" ? {} : { editions: rule.editions }
   };
 }
 function courseRulesJsonSchema() {
@@ -216,6 +223,13 @@ function courseRulesJsonSchema() {
           default: ["prose"],
           items: { title: "Element", type: "string", enum: [...ELEMENTS] }
         },
+        editions: {
+          title: "Editions",
+          description: "The edition of a lesson the rule is about: its chapter, its deck (`<lesson>.deck.mdx`), or both. A rule about one edition is checked there only, and listed on that edition\u2019s rules-in-effect page.",
+          type: "string",
+          enum: ["both", "chapter", "deck"],
+          default: "both"
+        },
         enabled: {
           title: "Enabled",
           description: 'Off: the rule stays in this file and moves to the "Off" list on the rules-in-effect page \u2014 nothing runs, and an agent neither applies it nor flags it in review. Use it to park a rule that is drafted but not in force.',

package/dist/rules/course-rules.schema.json

@@ -45,6 +45,7 @@
           "title": "Element",
           "type": "string",
           "enum": [
+            "slide",
             "prose",
             "math",
             "equation",
@@ -60,6 +61,17 @@
           ]
         }
       },
+      "editions": {
+        "title": "Editions",
+        "description": "The edition of a lesson the rule is about: its chapter, its deck (`<lesson>.deck.mdx`), or both. A rule about one edition is checked there only, and listed on that edition’s rules-in-effect page.",
+        "type": "string",
+        "enum": [
+          "both",
+          "chapter",
+          "deck"
+        ],
+        "default": "both"
+      },
       "enabled": {
         "title": "Enabled",
         "description": "Off: the rule stays in this file and moves to the \"Off\" list on the rules-in-effect page — nothing runs, and an agent neither applies it nor flags it in review. Use it to park a rule that is drafted but not in force.",

package/dist/rules/in-effect.d.ts

@@ -1,5 +1,5 @@
-import { Element, Enforcement } from './catalog.js';
-import { M as ManifestRules } from '../course-config-rRtME5UV.js';
+import { Element, Enforcement, Editions, Edition } from './catalog.js';
+import { M as ManifestRules } from '../course-config-BLtIdkei.js';
 import './course-rules.js';
 
 /** The slice of a manifest the page needs. */
@@ -17,11 +17,15 @@ interface RulesInEffectInput {
             readonly version: string;
         };
     };
+    /** The course's decks (`manifest.decks`): with any, the deck page is written too. */
+    readonly decks?: readonly unknown[];
 }
 interface RulesFilter {
     /** Keep a rule whose elements (any, not just primary) include one of these. */
     readonly elements?: readonly Element[];
     readonly enforcement?: Enforcement | 'locked';
+    /** The edition the page is for: `chapter` (the default) or `deck`. */
+    readonly edition?: Edition;
 }
 /** One rule as `content rules --json` reports it. */
 interface RuleInEffect {
@@ -39,6 +43,8 @@ interface RuleInEffect {
     readonly settings: Readonly<Record<string, unknown>>;
     readonly summary: string;
     readonly doc: string;
+    /** The edition it is about: `chapter`, `deck`, or `both`. */
+    readonly editions: Editions;
 }
 declare function rulesInEffect(input: RulesInEffectInput, filter?: RulesFilter): RuleInEffect[];
 /**
@@ -47,7 +53,11 @@ declare function rulesInEffect(input: RulesInEffectInput, filter?: RulesFilter):
  * the reader knows what was left out on purpose.
  */
 declare function renderRulesInEffect(input: RulesInEffectInput, filter?: RulesFilter): string;
-/** Write `build/rules-in-effect.md` under `root` (the course package). Returns the path. */
+/**
+ * Write `build/rules-in-effect.md` under `root` (the course package), and
+ * `build/rules-in-effect-deck.md` when the course has a deck (a stale one goes
+ * when it has none). Returns the chapter page's path.
+ */
 declare function writeRulesInEffect(input: RulesInEffectInput, root?: string): string;
 
 export { type RuleInEffect, type RulesFilter, type RulesInEffectInput, renderRulesInEffect, rulesInEffect, writeRulesInEffect };

package/dist/rules/in-effect.js

@@ -1,7 +1,8 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   ELEMENTS,
+  appliesTo,
   enforcementOf,
   invariants,
   rules as catalogRules
@@ -19,6 +20,7 @@ function enforcementLabel(entry) {
   return entry.kind === "rule" && entry.locked !== void 0 ? "locked" : enforcementOf(entry);
 }
 function matches(entry, filter) {
+  if (!appliesTo(entry, filter.edition ?? "chapter")) return false;
   if (filter.elements && !entry.elements.some((e) => filter.elements.includes(e))) return false;
   if (filter.enforcement && enforcementLabel(entry) !== filter.enforcement) return false;
   return true;
@@ -38,7 +40,8 @@ function rulesInEffect(input, filter = {}) {
     codes: entry.checks.map((c) => c.code),
     settings: entry.kind === "rule" ? input.rules.settings[entry.id] ?? {} : {},
     summary: entry.summary,
-    doc: docLink(entry)
+    doc: docLink(entry),
+    editions: entry.editions ?? "both"
   }));
 }
 function settingValue(value) {
@@ -69,23 +72,33 @@ function ruleLine(rule, settings) {
   return `- ${head}${also} \u2014 ${rule.summary}${settingsText(rule, settings)}${unchecked} \u2192 [${rule.doc}](${docLink(rule)})`;
 }
 function renderRulesInEffect(input, filter = {}) {
+  const edition = filter.edition ?? "chapter";
   const off = new Set(input.rules.disabled);
-  const on = liveRules(input).filter((r) => !off.has(r.id));
+  const live = liveRules(input).filter((r) => appliesTo(r, edition));
+  const on = live.filter((r) => !off.has(r.id));
+  const offHere = [...off].filter((id) => live.some((r) => r.id === id));
   const ours = on.filter((r) => r.source === "course").length;
   const locked = on.filter((r) => r.locked !== void 0).map((r) => r.id);
   const filtered = filter.elements || filter.enforcement;
   const visible = on.filter((r) => matches(r, filter));
+  const editionInvariants = invariants().filter((i) => appliesTo(i, edition));
   const lines = [];
   lines.push(
-    `# Rules in effect \u2014 ${input.about.material.name} (knowledge ${input.about.knowledge.version}, ${input.about.engine.name} ${input.about.engine.version})`,
+    `# Rules in effect${edition === "deck" ? " for decks" : ""} \u2014 ${input.about.material.name} (knowledge ${input.about.knowledge.version}, ${input.about.engine.name} ${input.about.engine.version})`,
     "",
+    ...edition === "deck" ? [
+      "For a lesson\u2019s deck, `<lesson>.deck.mdx` (`docs/authoring/deck.md`): the `D` rules",
+      "lead, then every rule that holds for a deck as for a chapter. A chapter-only rule is",
+      'listed under "Chapter only" at the end; on a frame, a `D` rule says it instead.',
+      ""
+    ] : [],
     "Generated by `pnpm validate:content` (and `pnpm content rules`) from the rule",
     "catalog and `rules` / `courseRules` in `course.settings.json`. Do not edit. Read this before",
     "drafting, and open a rule page only when it is listed here and you need the",
     "example: a rule absent from this page is either off for this course or does",
     "not exist, and is neither applied nor flagged in review.",
     "",
-    `${on.length} rules on (${locked.length} locked${ours === 0 ? "" : `, ${ours} this course's own`}), ${off.size} off, ${invariants().length} invariants always on.` + (filtered ? ` Filtered: ${[
+    `${on.length} rules on (${locked.length} locked${ours === 0 ? "" : `, ${ours} this course's own`}), ${offHere.length} off, ${editionInvariants.length} invariants always on.` + (filtered ? ` Filtered: ${[
       filter.elements ? `element ${filter.elements.join(", ")}` : "",
       filter.enforcement ? `enforcement ${filter.enforcement}` : ""
     ].filter(Boolean).join("; ")} \u2014 ${visible.length} shown.` : ""),
@@ -108,7 +121,7 @@ function renderRulesInEffect(input, filter = {}) {
     lines.push("", `## ${element}`, "");
     for (const rule of here) lines.push(ruleLine(rule, input.rules.settings[rule.id] ?? {}));
   }
-  const visibleInvariants = invariants().filter((i) => matches(i, filter));
+  const visibleInvariants = editionInvariants.filter((i) => matches(i, filter));
   lines.push("", "## Always on (invariants)", "");
   if (visibleInvariants.length === 0) {
     lines.push("- (none match the filter)");
@@ -121,10 +134,17 @@ function renderRulesInEffect(input, filter = {}) {
   }
   lines.push("", "## Off", "");
   lines.push(
-    off.size === 0 ? "- Nothing \u2014 every rule is on." : `- ${[...off].join(", ")} \u2014 turned off in \`course.settings.json\` (\`rules\`, or \`courseRules\` for an \`X\` rule). Do not apply them; do not flag them in review.`
+    offHere.length === 0 ? "- Nothing \u2014 every rule is on." : `- ${offHere.join(", ")} \u2014 turned off in \`course.settings.json\` (\`rules\`, or \`courseRules\` for an \`X\` rule). Do not apply them; do not flag them in review.`
   );
   lines.push("", "## Locked", "");
   lines.push(`- ${locked.join(", ")} \u2014 cannot be turned off; listed above under their element.`);
+  if (edition === "deck") {
+    const chapterOnly = liveRules(input).filter((r) => !appliesTo(r, "deck")).map((r) => r.id);
+    lines.push("", "## Chapter only", "");
+    lines.push(
+      chapterOnly.length === 0 ? "- Nothing \u2014 every rule holds for a deck too." : `- ${chapterOnly.join(", ")} \u2014 about a chapter\u2019s page, not a frame. On a deck, neither apply them nor flag them; the \`D\` rules above say the same of a frame.`
+    );
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -133,6 +153,9 @@ function writeRulesInEffect(input, root = process.cwd()) {
   mkdirSync(dir, { recursive: true });
   const path = join(dir, "rules-in-effect.md");
   writeFileSync(path, renderRulesInEffect(input));
+  const deckPath = join(dir, "rules-in-effect-deck.md");
+  if ((input.decks?.length ?? 0) > 0) writeFileSync(deckPath, renderRulesInEffect(input, { edition: "deck" }));
+  else if (existsSync(deckPath)) rmSync(deckPath);
   return path;
 }
 export {