explico 0.12.0 → 0.13.0

package/dist/compiler/content-schemas.d.ts

@@ -0,0 +1,422 @@
+import { z } from 'astro/zod';
+
+/**
+ * The content collections' schemas, one definition for both readers of
+ * `content/`: Astro's collections (`src/content-config.ts`, which wraps each
+ * in `defineCollection`) and the manifest walk, which checks every record
+ * against the same schema (`content-schema.ts`, `validateContentSchemas`) so
+ * `pnpm validate:content` rejects what `astro build` would.
+ *
+ * Plain zod only — no `astro:content` — so the manifest can import it outside
+ * Vite.
+ */
+
+declare const contentId: z.ZodString;
+/**
+ * Notation `meaning` / `summary`: plain prose (no `$`, `\`, backticks), and —
+ * the C1b safeguard — substantive, not a placeholder. A short or blocklisted
+ * phrase fails the build so a local symbol cannot get a glossary-style panel
+ * for a throwaway definition.
+ */
+declare const notationProse: z.ZodString;
+/** An index entry's latex: a subscript on an empty group, `{}_0`. */
+declare function isIndexEntryLatex(latex: string): boolean;
+declare const notationEntryShape: z.ZodObject<{
+    key: z.ZodString;
+    latex: z.ZodString;
+    meaning: z.ZodString;
+    formula: z.ZodOptional<z.ZodString>;
+    units: z.ZodOptional<z.ZodString>;
+    dimensionless: z.ZodOptional<z.ZodLiteral<true>>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        locator: z.ZodString;
+    }, z.core.$strip>]>>>;
+    alignment: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"competency">;
+        introducedByCompetency: z.ZodString;
+        introducedInLesson: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"general">;
+        rationale: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    label: z.ZodOptional<z.ZodString>;
+    glosses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        latex: z.ZodString;
+        name: z.ZodString;
+        units: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    reads: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodString>;
+    fixedIndex: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>;
+/**
+ * Lesson frontmatter — reduced shape (Phase C1 schema, C2 codemod applied):
+ * the fields explico adds to Starlight's own (`title`, `description`, …).
+ *
+ * Authored:  `teaches` (ordered — the curriculum contract, never derived),
+ *            `assumptions`, `studyMinutes` (optional reader-facing estimate),
+ *            `notation.local` (page-local symbols only).
+ * Derived (in `compiler/collections.ts` + `compiler/lesson-derivation.ts`,
+ *            never authored): `lessonId` (doc slug), `requires` (direct
+ *            competency-DAG prerequisites of `teaches`, minus `teaches`),
+ *            `sources` (`[@…]` occurrences), `assessments` (colocated
+ *            `<lesson>.checks.yml`), `sidebar` order (track order).
+ * Dropped:   `aiAssisted`, `lastReviewed`, `riskTier` (git history carries
+ *            provenance); `editorialStatus`, the draft / in-review / reviewed
+ *            flag, because lessons are reviewed continuously and never earn a
+ *            one-time stamp (a file that still sets it fails the build, see
+ *            `reference/gate-retired-keys.ts`); `estimatedMinutes`, whose
+ *            reader-facing half returned as the optional `studyMinutes` once
+ *            part pages had somewhere to total it; `notation.uses` (D3 — a
+ *            shared symbol is imported by using it).
+ */
+declare const lessonFrontmatterSchema: z.ZodObject<{
+    teaches: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    studyMinutes: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+    notation: z.ZodDefault<z.ZodObject<{
+        local: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            latex: z.ZodString;
+            meaning: z.ZodString;
+            formula: z.ZodOptional<z.ZodString>;
+            units: z.ZodOptional<z.ZodString>;
+            dimensionless: z.ZodOptional<z.ZodLiteral<true>>;
+            seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                id: z.ZodString;
+                locator: z.ZodString;
+            }, z.core.$strip>]>>>;
+            alignment: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"competency">;
+                introducedByCompetency: z.ZodString;
+                introducedInLesson: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"general">;
+                rationale: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            label: z.ZodOptional<z.ZodString>;
+            glosses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                latex: z.ZodString;
+                name: z.ZodString;
+                units: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            reads: z.ZodOptional<z.ZodString>;
+            range: z.ZodOptional<z.ZodString>;
+            fixedIndex: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strip>>>;
+        suspend: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            operator: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const competencySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    domain: z.ZodString;
+    facet: z.ZodEnum<{
+        knowledge: "knowledge";
+        calculation: "calculation";
+        interpretation: "interpretation";
+        convention: "convention";
+        risk: "risk";
+    }>;
+    outcome: z.ZodString;
+    prerequisites: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evidence: z.ZodObject<{
+        minimumIndependentItems: z.ZodNumber;
+        requiresTransfer: z.ZodBoolean;
+        requiresUnassistedPass: z.ZodBoolean;
+    }, z.core.$strip>;
+    misconceptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const assessmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        competencyId: z.ZodString;
+        evidenceKind: z.ZodEnum<{
+            direct: "direct";
+            transfer: "transfer";
+        }>;
+        prompt: z.ZodString;
+        explanation: z.ZodString;
+        type: z.ZodLiteral<"numeric">;
+        answer: z.ZodObject<{
+            value: z.ZodNumber;
+            tolerance: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        competencyId: z.ZodString;
+        evidenceKind: z.ZodEnum<{
+            direct: "direct";
+            transfer: "transfer";
+        }>;
+        prompt: z.ZodString;
+        explanation: z.ZodString;
+        type: z.ZodLiteral<"single-choice">;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        correctOptionId: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+declare const trackSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    audience: z.ZodString;
+    entryAssumptions: z.ZodArray<z.ZodString>;
+    lessons: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const sourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        primary: "primary";
+        "official-guidance": "official-guidance";
+        paper: "paper";
+        book: "book";
+        secondary: "secondary";
+    }>;
+    title: z.ZodString;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    organization: z.ZodOptional<z.ZodString>;
+    edition: z.ZodOptional<z.ZodString>;
+    publisher: z.ZodOptional<z.ZodString>;
+    year: z.ZodOptional<z.ZodNumber>;
+    isbn: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodURL>;
+    locator: z.ZodOptional<z.ZodString>;
+    accessed: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    licenseNotes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Standalone notation collection — the one `notationEntry` shape plus the
+ * shared-only extras: `domain`, `aliases`, and a Markdown body.
+ */
+declare const notationSchema: z.ZodObject<{
+    key: z.ZodString;
+    latex: z.ZodString;
+    meaning: z.ZodString;
+    formula: z.ZodOptional<z.ZodString>;
+    units: z.ZodOptional<z.ZodString>;
+    dimensionless: z.ZodOptional<z.ZodLiteral<true>>;
+    seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        locator: z.ZodString;
+    }, z.core.$strip>]>>>;
+    alignment: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"competency">;
+        introducedByCompetency: z.ZodString;
+        introducedInLesson: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"general">;
+        rationale: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    label: z.ZodOptional<z.ZodString>;
+    glosses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        latex: z.ZodString;
+        name: z.ZodString;
+        units: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    reads: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodString>;
+    fixedIndex: z.ZodOptional<z.ZodLiteral<true>>;
+    domain: z.ZodString;
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aiAssisted: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Abbreviations table (rule N14) — deliberately a lighter tier than a
+ * `notation` card: just a name resolution, no `formula`, `units`, or
+ * curriculum `alignment`. `abbr` is the canonical written form (`OLS`);
+ * `aliases` are other written forms of the same abbreviation that should
+ * resolve the same way (`w.r.t.` might alias `wrt`).
+ */
+declare const abbreviationSchema: z.ZodObject<{
+    key: z.ZodString;
+    abbr: z.ZodString;
+    expansion: z.ZodString;
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    domain: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Each collection's directory under `content/` and the schema a record there
+ * must satisfy. `docs` checks only the fields explico adds; Starlight's own
+ * (`title`, `description`, …) are Starlight's schema's to judge.
+ */
+declare const CONTENT_SCHEMAS: {
+    readonly docs: z.ZodObject<{
+        teaches: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        assumptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        studyMinutes: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+        notation: z.ZodDefault<z.ZodObject<{
+            local: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                latex: z.ZodString;
+                meaning: z.ZodString;
+                formula: z.ZodOptional<z.ZodString>;
+                units: z.ZodOptional<z.ZodString>;
+                dimensionless: z.ZodOptional<z.ZodLiteral<true>>;
+                seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                    locator: z.ZodString;
+                }, z.core.$strip>]>>>;
+                alignment: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"competency">;
+                    introducedByCompetency: z.ZodString;
+                    introducedInLesson: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"general">;
+                    rationale: z.ZodString;
+                }, z.core.$strip>], "kind">>;
+                label: z.ZodOptional<z.ZodString>;
+                glosses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    latex: z.ZodString;
+                    name: z.ZodString;
+                    units: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                reads: z.ZodOptional<z.ZodString>;
+                range: z.ZodOptional<z.ZodString>;
+                fixedIndex: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strip>>>;
+            suspend: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                operator: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly competencies: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        domain: z.ZodString;
+        facet: z.ZodEnum<{
+            knowledge: "knowledge";
+            calculation: "calculation";
+            interpretation: "interpretation";
+            convention: "convention";
+            risk: "risk";
+        }>;
+        outcome: z.ZodString;
+        prerequisites: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        evidence: z.ZodObject<{
+            minimumIndependentItems: z.ZodNumber;
+            requiresTransfer: z.ZodBoolean;
+            requiresUnassistedPass: z.ZodBoolean;
+        }, z.core.$strip>;
+        misconceptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    readonly assessments: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            competencyId: z.ZodString;
+            evidenceKind: z.ZodEnum<{
+                direct: "direct";
+                transfer: "transfer";
+            }>;
+            prompt: z.ZodString;
+            explanation: z.ZodString;
+            type: z.ZodLiteral<"numeric">;
+            answer: z.ZodObject<{
+                value: z.ZodNumber;
+                tolerance: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            competencyId: z.ZodString;
+            evidenceKind: z.ZodEnum<{
+                direct: "direct";
+                transfer: "transfer";
+            }>;
+            prompt: z.ZodString;
+            explanation: z.ZodString;
+            type: z.ZodLiteral<"single-choice">;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            correctOptionId: z.ZodString;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>;
+    readonly tracks: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        audience: z.ZodString;
+        entryAssumptions: z.ZodArray<z.ZodString>;
+        lessons: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    readonly sources: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            primary: "primary";
+            "official-guidance": "official-guidance";
+            paper: "paper";
+            book: "book";
+            secondary: "secondary";
+        }>;
+        title: z.ZodString;
+        authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        organization: z.ZodOptional<z.ZodString>;
+        edition: z.ZodOptional<z.ZodString>;
+        publisher: z.ZodOptional<z.ZodString>;
+        year: z.ZodOptional<z.ZodNumber>;
+        isbn: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodURL>;
+        locator: z.ZodOptional<z.ZodString>;
+        accessed: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+        licenseNotes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly notation: z.ZodObject<{
+        key: z.ZodString;
+        latex: z.ZodString;
+        meaning: z.ZodString;
+        formula: z.ZodOptional<z.ZodString>;
+        units: z.ZodOptional<z.ZodString>;
+        dimensionless: z.ZodOptional<z.ZodLiteral<true>>;
+        seeAlso: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            locator: z.ZodString;
+        }, z.core.$strip>]>>>;
+        alignment: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"competency">;
+            introducedByCompetency: z.ZodString;
+            introducedInLesson: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"general">;
+            rationale: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        label: z.ZodOptional<z.ZodString>;
+        glosses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            latex: z.ZodString;
+            name: z.ZodString;
+            units: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        reads: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodString>;
+        fixedIndex: z.ZodOptional<z.ZodLiteral<true>>;
+        domain: z.ZodString;
+        aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aiAssisted: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly abbreviations: z.ZodObject<{
+        key: z.ZodString;
+        abbr: z.ZodString;
+        expansion: z.ZodString;
+        aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+
+export { CONTENT_SCHEMAS, abbreviationSchema, assessmentSchema, competencySchema, contentId, isIndexEntryLatex, lessonFrontmatterSchema, notationEntryShape, notationProse, notationSchema, sourceSchema, trackSchema };

package/dist/compiler/content-schemas.js

@@ -0,0 +1,229 @@
+import { z } from "astro/zod";
+import { isSubstantiveMeaning } from "../reference/prose.js";
+import { glossKeySegment } from "../reference/gloss.js";
+import { BASE_PLACEHOLDER } from "../reference/derived-notation.mjs";
+const contentId = z.string().regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/);
+const id = contentId;
+const notationProse = z.string().min(1).refine((value) => !/[\\$`]/.test(value), {
+  message: 'Notation meaning/summary must be plain prose: no `$`, `\\` or backtick. Put a symbol or formula in its own field (`latex`, `formula`), and write an amount of money in words or with its currency code ("USD 5").'
+}).refine(isSubstantiveMeaning, {
+  message: "Notation meaning must be substantive prose (at least four words, not a placeholder)."
+});
+const notationAlignment = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("competency"),
+    introducedByCompetency: id,
+    introducedInLesson: id
+  }),
+  z.object({
+    kind: z.literal("general"),
+    rationale: z.string().min(1)
+  })
+]);
+const notationAlignmentDefault = notationAlignment.default({
+  kind: "general",
+  rationale: "General notation."
+});
+const notationSource = z.union([
+  id,
+  z.object({ id, locator: z.string().min(1) })
+]);
+const notationGloss = z.object({
+  latex: z.string().min(1),
+  name: z.string().min(1).refine((value) => glossKeySegment(value) !== void 0, {
+    message: "A gloss name must contain letters or digits so a key can be derived from it."
+  }).refine((value) => !/[\\$`\n]/.test(value), {
+    message: "A gloss name is a plain noun phrase; put the symbol in `latex`, not in the name."
+  }),
+  units: z.string().min(1).optional()
+});
+function isIndexEntryLatex(latex) {
+  return /^\s*\{\s*\}\s*_/.test(latex);
+}
+const notationEntryObject = z.object({
+  key: id,
+  latex: z.string().min(1),
+  meaning: notationProse,
+  formula: z.string().min(1).optional(),
+  units: z.string().min(1).optional(),
+  dimensionless: z.literal(true).optional(),
+  seeAlso: z.array(id).default([]),
+  sources: z.array(notationSource).default([]),
+  alignment: notationAlignmentDefault,
+  label: z.string().min(1).optional(),
+  glosses: z.array(notationGloss).default([]),
+  /**
+   * An index entry's title for the symbol it indexes (rule N23):
+   * `"{base} evaluated at t = 0"`. Defaults to `"<label> of {base}"`.
+   */
+  reads: z.string().min(1).refine((value) => value.includes(BASE_PLACEHOLDER), {
+    message: `reads names the indexed symbol with ${BASE_PLACEHOLDER}, e.g. "${BASE_PLACEHOLDER} evaluated at t = 0".`
+  }).refine((value) => !/[\\$`]/.test(value), {
+    message: "reads is plain prose: no `$`, `\\` or backtick."
+  }).optional(),
+  /** The set a running index letter runs over (rule N23): `1, \dots, n`. */
+  range: z.string().min(1).optional(),
+  /** As an index, this letter (or this entry's own index) is a fixed label. */
+  fixedIndex: z.literal(true).optional()
+});
+function refineIndexFields(entry, context) {
+  const index = isIndexEntryLatex(entry.latex);
+  if (entry.reads !== void 0 && !index) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["reads"],
+      message: "reads belongs on an index entry, whose latex is a subscript on an empty group ({}_0)."
+    });
+  }
+  for (const field of ["range", "fixedIndex", "units", "dimensionless"]) {
+    if (index && entry[field] !== void 0) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [field],
+        message: `An index entry ({}_\u2026) takes no ${field}: a derived card takes its units from the symbol it indexes, and the index it names is fixed already.`
+      });
+    }
+  }
+}
+const notationEntryShape = notationEntryObject.superRefine(refineIndexFields);
+const notationSuspension = z.object({
+  operator: z.string().min(1),
+  reason: z.string().min(1).optional()
+});
+const lessonNotation = z.object({
+  // `notation.uses` is retired (D3): a lesson pulls a shared key into scope
+  // by referencing it in prose (`[[key]]`) or math (`\explain`).
+  local: z.array(notationEntryShape).default([]),
+  suspend: z.array(notationSuspension).default([])
+}).default({ local: [], suspend: [] });
+const studyMinutes = z.union([
+  z.number().int().positive(),
+  z.tuple([z.number().int().positive(), z.number().int().positive()])
+]).refine((value) => !Array.isArray(value) || value[0] <= value[1], {
+  message: "studyMinutes as a range is [low, high]; the low end cannot exceed the high end."
+});
+const lessonFrontmatterSchema = z.object({
+  teaches: z.array(id).default([]),
+  assumptions: z.array(z.string().min(1)).default([]),
+  studyMinutes: studyMinutes.optional(),
+  notation: lessonNotation
+});
+const competencySchema = z.object({
+  id,
+  title: z.string().min(1),
+  domain: id,
+  facet: z.enum([
+    "knowledge",
+    "calculation",
+    "interpretation",
+    "convention",
+    "risk"
+  ]),
+  outcome: z.string().min(1),
+  prerequisites: z.array(id).default([]),
+  evidence: z.object({
+    minimumIndependentItems: z.number().int().min(1),
+    requiresTransfer: z.boolean(),
+    requiresUnassistedPass: z.boolean()
+  }),
+  misconceptions: z.array(z.string().min(1)).default([])
+});
+const assessmentItemBase = z.object({
+  id,
+  competencyId: id,
+  evidenceKind: z.enum(["direct", "transfer"]),
+  prompt: z.string().min(1),
+  explanation: z.string().min(1)
+});
+const assessmentTitle = z.string().min(1).refine((value) => !/^knowledge check\b/i.test(value), {
+  message: 'Assessment title must not start with "Knowledge check" \u2014 AssessmentSet already renders "Knowledge check {number} \u2014 {title}", so a title with the same prefix duplicates it. Use just the topic, e.g. "AIC and KL risk".'
+});
+const assessmentSchema = z.object({
+  id,
+  title: assessmentTitle,
+  items: z.array(
+    z.discriminatedUnion("type", [
+      assessmentItemBase.extend({
+        type: z.literal("numeric"),
+        answer: z.object({
+          value: z.number(),
+          tolerance: z.number().positive()
+        })
+      }),
+      assessmentItemBase.extend({
+        type: z.literal("single-choice"),
+        options: z.array(
+          z.object({
+            id,
+            label: z.string().min(1)
+          })
+        ).min(2),
+        correctOptionId: id
+      })
+    ])
+  ).min(1)
+});
+const trackSchema = z.object({
+  id,
+  title: z.string().min(1),
+  description: z.string().min(1),
+  audience: z.string().min(1),
+  entryAssumptions: z.array(z.string().min(1)),
+  lessons: z.array(id).min(1)
+});
+const sourceSchema = z.object({
+  id,
+  type: z.enum([
+    "primary",
+    "official-guidance",
+    "paper",
+    "book",
+    "secondary"
+  ]),
+  title: z.string().min(1),
+  authors: z.array(z.string().min(1)).optional(),
+  organization: z.string().min(1).optional(),
+  edition: z.string().optional(),
+  publisher: z.string().optional(),
+  year: z.number().int().optional(),
+  isbn: z.string().optional(),
+  url: z.url().optional(),
+  locator: z.string().optional(),
+  accessed: z.coerce.date().optional(),
+  licenseNotes: z.string().optional()
+});
+const notationSchema = notationEntryObject.extend({
+  domain: id,
+  aliases: z.array(z.string().min(1)).default([]),
+  aiAssisted: z.boolean().default(false)
+}).superRefine(refineIndexFields);
+const abbreviationSchema = z.object({
+  key: id,
+  abbr: z.string().min(1),
+  expansion: notationProse,
+  aliases: z.array(z.string().min(1)).default([]),
+  domain: id.optional()
+});
+const CONTENT_SCHEMAS = {
+  docs: lessonFrontmatterSchema,
+  competencies: competencySchema,
+  assessments: assessmentSchema,
+  tracks: trackSchema,
+  sources: sourceSchema,
+  notation: notationSchema,
+  abbreviations: abbreviationSchema
+};
+export {
+  CONTENT_SCHEMAS,
+  abbreviationSchema,
+  assessmentSchema,
+  competencySchema,
+  contentId,
+  isIndexEntryLatex,
+  lessonFrontmatterSchema,
+  notationEntryShape,
+  notationProse,
+  notationSchema,
+  sourceSchema,
+  trackSchema
+};

package/dist/compiler/course-config.d.ts

@@ -1,3 +1,3 @@
-export { s as BLOCK_LABELS_DEFAULT, B as BlockLabels, a as CourseAbbreviations, t as CourseAbout, i as CourseAccents, u as CourseAuthor, C as CourseConfig, f as CourseConventions, v as CourseDisclosure, w as CourseHeadingDisclosure, x as CourseNumbering, y as CourseOpenDefault, g as CourseOperators, z as CoursePart, h as CourseRomanLabels, A as CourseSection, D as DISCLOSURE_DEFAULTS, L as LessonExportsConfig, c as NormalizedDisclosure, b as NormalizedLessonExports, d as NormalizedNumbering, N as NormalizedPartPages, E as coursePartsOf, F as normalizeBlockLabels, G as normalizeDisclosure, H as normalizeLessonExports, I as normalizeNumbering } from '../course-config-Dsnri9Tk.js';
+export { s as BLOCK_LABELS_DEFAULT, B as BlockLabels, t as CARDS_DEFAULTS, h as CourseAbbreviations, u as CourseAbout, g as CourseAccents, v as CourseAuthor, w as CourseCards, C as CourseConfig, x as CourseDisclosure, y as CourseHeadingDisclosure, z as CourseNumbering, A as CourseOpenDefault, e as CourseOperators, D as CoursePart, f as CourseRomanLabels, E as CourseSection, F as DISCLOSURE_DEFAULTS, L as LessonExportsConfig, c as NormalizedCards, a as NormalizedDisclosure, N as NormalizedLessonExports, b as NormalizedNumbering, i as NormalizedPartPages, G as coursePartsOf, H as normalizeBlockLabels, I as normalizeCards, J as normalizeDisclosure, K as normalizeLessonExports, O as normalizeNumbering } from '../course-config-rRtME5UV.js';
 import '../rules/course-rules.js';
 import '../rules/catalog.js';