@agentshouse/mdmodel 0.1.0-ccf1367190878 → 0.1.0-cdbd463e01dc2

package/dist/validate.js

@@ -1,15 +1,62 @@
 import { ATTACHMENT, BUILT_IN_TYPE, readSchema } from './definition.js';
-import { parse } from './document.js';
+import { links, parse } from './document.js';
+import { MEMBER_FIELD } from './fields.js';
 import { hrefOccurrences, linkInventory } from './links.js';
-import { classifyHref } from './paths.js';
+import { classifyHref, roomTarget } from './paths.js';
 import { references } from './references.js';
+import { isDocumentPath, ROOM_DESCRIPTION } from './reserved.js';
 import { refusal } from './refuse.js';
-import { fitsItem, frontmatterRefusal } from './schema.js';
+import { conditionedSections, fitsItem, frontmatterRefusal } from './schema.js';
+import { openPatternBudget, PatternTooCostly } from './pattern.js';
 import { headingSpans, listItems } from './sections.js';
 import { bodyAfterFrontmatter, bodyStartOf } from './yaml.js';
 function refuse(file, rule, extra) {
     return { verdict: 'refuse', ...refusal(file, rule, extra) };
 }
+function unmarkedMember(file, document, definition) {
+    return Object.hasOwn(document.fields, MEMBER_FIELD) && definition?.memberDocument !== true
+        ? refuse(file, 'undeclared-field', { location: `/${MEMBER_FIELD}` })
+        : null;
+}
+function reservedLink(file, document) {
+    return (document.type !== undefined &&
+        isDocumentPath(file) &&
+        links(document, file).some((link) => !isDocumentPath(link.target)));
+}
+function describedRoom(file, document) {
+    return file === ROOM_DESCRIPTION && document.type !== undefined
+        ? refuse(file, 'room-md-type', { location: '/type' })
+        : null;
+}
+function nameFits(pattern, name) {
+    const at = pattern.indexOf('*');
+    if (at === -1)
+        return pattern === name;
+    const head = pattern.slice(0, at);
+    const tail = pattern.slice(at + 1);
+    return name.length > head.length + tail.length && name.startsWith(head) && name.endsWith(tail);
+}
+function typedPathOf(file, typedPaths = []) {
+    const names = file.split('/');
+    return typedPaths.find(({ path }) => {
+        const patterns = path.split('/');
+        return (patterns.length === names.length &&
+            patterns.every((pattern, at) => nameFits(pattern, names[at])));
+    });
+}
+const HELD_TEXT = /\S/u;
+function typedPathRefusal(file, content, document, typedPath) {
+    if (typedPath === undefined)
+        return null;
+    if (document.type !== (typedPath.named ? typedPath.type : undefined))
+        return refuse(file, 'unknown-type', { location: '/type' });
+    return typedPath.body && !HELD_TEXT.test(bodyAfterFrontmatter(content))
+        ? refuse(file, 'required-body')
+        : null;
+}
+function kindOf(document, typedPath) {
+    return typedPath !== undefined && !typedPath.named ? typedPath.type : instanceType(document);
+}
 function instanceType(document) {
     const raw = document.fields.type;
     if (raw === undefined || raw === null)
@@ -60,8 +107,8 @@ function itemHrefs(content, items, uses) {
     }
     return hrefs;
 }
-export function verify(schema) {
-    const read = readSchema(schema);
+export function verify(schema, provided) {
+    const read = readSchema(schema, provided);
     if ('types' in read)
         return { verdict: 'accept', model: read };
     return {
@@ -70,6 +117,12 @@ export function verify(schema) {
         ...(read.location === undefined ? {} : { location: read.location }),
     };
 }
+export function readTypes(schema, provided) {
+    const read = readSchema(schema, provided, false);
+    if ('types' in read)
+        return read;
+    throw new Error(`the schema reads as no types: ${read.rule} ${read.location ?? ''}`.trim());
+}
 function structure(file, content, document, definition) {
     if (definition === undefined)
         return { refusal: refuse(file, 'unknown-type', { location: '/type' }) };
@@ -80,10 +133,14 @@ function structure(file, content, document, definition) {
     const spans = headingSpans(content, bodyStartOf(content));
     const uses = usesIn(content);
     const sections = [];
+    const conditioned = conditionedSections(definition, document.fields);
     for (const [name, spec] of Object.entries(definition.sections)) {
         const occurrences = spans.filter((one) => one.name === name);
         if (occurrences.length === 0 && spec.required)
             return { refusal: refuse(file, 'required-section', { location: name }) };
+        if (conditioned.includes(name) &&
+            occurrences.every((span) => content.slice(span.bodyStart, span.bodyEnd).trim() === ''))
+            return { refusal: refuse(file, 'conditional-section', { location: name }) };
         if (spec.kind !== 'list')
             continue;
         for (const span of occurrences) {
@@ -96,10 +153,16 @@ function structure(file, content, document, definition) {
             const hrefs = itemHrefs(content, items, uses);
             if (hrefs === null)
                 return { refusal: refuse(file, 'structured-section', { location: name }) };
-            sections.push({ section: name, to: spec.items.reference, hrefs });
+            sections.push({
+                section: name,
+                to: spec.items.reference,
+                crossRoom: spec.items.crossRoom === true,
+                hrefs,
+            });
         }
     }
-    return { sections };
+    const member = unmarkedMember(file, document, definition);
+    return member === null ? { sections } : { refusal: member };
 }
 function linked(file, content) {
     return hrefOccurrences(bodyAfterFrontmatter(content)).every((occurrence) => classifyHref(file, occurrence.href).kind !== 'invalid');
@@ -108,19 +171,39 @@ function reached(file, href, to) {
     const resolved = classifyHref(file, href);
     return { target: resolved.kind === 'path' ? resolved.path : null, to };
 }
-function definitionOf(document, model) {
-    const kind = instanceType(document);
+function referred(file, href, to) {
+    const reference = reached(file, href, to);
+    return reference.target !== null &&
+        isDocumentPath(file) &&
+        !isDocumentPath(reference.target) &&
+        !to.includes(ATTACHMENT)
+        ? { target: null, to }
+        : reference;
+}
+function crossing(file, href, crossRoom) {
+    return crossRoom === true && classifyHref(file, href).kind === 'room';
+}
+function definitionOf(kind, model) {
     return kind === null || !Object.hasOwn(model.types, kind) ? undefined : model.types[kind];
 }
-export function checkDocument(file, content, model) {
+export function checkDocument(file, content, model, context = {}) {
+    const anyRoom = context.anyRoom === true;
     const parsed = parse(content, file);
     if (!parsed.ok)
         return { ok: false };
     const document = parsed.document;
     const type = document.type ?? BUILT_IN_TYPE;
-    if (instanceType(document) === BUILT_IN_TYPE)
-        return { ok: true, type, typed: false, references: [] };
-    const definition = definitionOf(document, model);
+    const typedPath = typedPathOf(file, context.typedPaths);
+    if (describedRoom(file, document) !== null ||
+        typedPathRefusal(file, content, document, typedPath) !== null ||
+        reservedLink(file, document))
+        return { ok: false };
+    const kind = kindOf(document, typedPath);
+    if (kind === BUILT_IN_TYPE)
+        return unmarkedMember(file, document, undefined) === null
+            ? { ok: true, type, typed: false, references: [] }
+            : { ok: false };
+    const definition = definitionOf(kind, model);
     const read = structure(file, content, document, definition);
     if ('refusal' in read || definition === undefined || !linked(file, content))
         return { ok: false };
@@ -129,92 +212,225 @@ export function checkDocument(file, content, model) {
         type,
         typed: true,
         references: [
-            ...references(document, definition).map(({ value, to }) => reached(file, value, to)),
-            ...read.sections.flatMap(({ to, hrefs }) => hrefs.map((href) => reached(file, href, to))),
+            ...references(document, definition).flatMap(({ value, to, crossRoom }) => crossing(file, value, anyRoom || crossRoom) ? [] : [referred(file, value, to)]),
+            ...read.sections.flatMap(({ to, crossRoom, hrefs }) => hrefs.flatMap((href) => crossing(file, href, anyRoom || crossRoom) ? [] : [referred(file, href, to)])),
         ],
     };
 }
-export function sectionReferences(file, content, definition) {
-    const referring = (name) => {
-        const spec = Object.hasOwn(definition.sections, name) ? definition.sections[name] : undefined;
-        return spec?.kind === 'list' ? spec.items.reference : undefined;
-    };
-    if (!Object.keys(definition.sections).some((name) => referring(name) !== undefined))
-        return [];
-    const uses = usesIn(content);
+export function bodyRoomLinks(body) {
     const found = [];
+    for (const href of new Set(hrefOccurrences(body).map((occurrence) => occurrence.href))) {
+        const room = roomTarget(href);
+        if (room !== null)
+            found.push({ kind: 'link', href, ...room });
+    }
+    return found;
+}
+export function roomReferences(file, content, definition) {
+    const found = bodyRoomLinks(bodyAfterFrontmatter(content));
+    if (definition === undefined)
+        return found;
+    const parsed = parse(content, file);
+    if (!parsed.ok)
+        return found;
+    for (const { pointer, value, to, crossRoom } of references(parsed.document, definition)) {
+        const room = roomTarget(value);
+        if (room !== null)
+            found.push({
+                kind: 'field',
+                pointer,
+                value,
+                to,
+                ...room,
+                ...(crossRoom ? { crossRoom } : {}),
+            });
+    }
+    const uses = usesIn(content);
     for (const span of headingSpans(content, bodyStartOf(content))) {
-        const to = referring(span.name);
-        if (to === undefined)
+        const spec = Object.hasOwn(definition.sections, span.name)
+            ? definition.sections[span.name]
+            : undefined;
+        if (spec?.kind !== 'list' || spec.items.reference === undefined)
             continue;
-        const items = listItems(content, span.bodyStart, span.bodyEnd);
-        const hrefs = items === null ? null : itemHrefs(content, items, uses);
-        for (const href of hrefs ?? [])
-            found.push(reached(file, href, to));
+        const listed = listItems(content, span.bodyStart, span.bodyEnd);
+        for (const href of (listed === null ? null : itemHrefs(content, listed, uses)) ?? []) {
+            const room = roomTarget(href);
+            if (room !== null)
+                found.push({
+                    kind: 'item',
+                    section: span.name,
+                    href,
+                    to: spec.items.reference,
+                    ...room,
+                    ...(spec.items.crossRoom === true ? { crossRoom: true } : {}),
+                });
+        }
     }
     return found;
 }
-export function validate(library, context = { binaryTargets: [] }, model = { types: {} }) {
+function least(refused, file, verdict) {
+    return refused === undefined || file < refused.file ? { file, verdict } : refused;
+}
+export function assess(file, content, binary, model = { types: {} }, context = {}) {
+    const unread = { file, type: undefined, targets: [], structured: null, fields: [], sections: [] };
+    if (binary)
+        return { ...unread, read: refuse(file, 'binary-target-document'), linked: true };
+    const parsed = parse(content, file);
+    if (!parsed.ok)
+        return { ...unread, read: { verdict: 'refuse', ...parsed.refusal }, linked: true };
+    const document = parsed.document;
+    const type = document.type ?? BUILT_IN_TYPE;
+    const typed = { file, type, read: null, structured: null };
+    const typedPath = typedPathOf(file, context.typedPaths);
+    const described = describedRoom(file, document) ?? typedPathRefusal(file, content, document, typedPath);
+    if (described !== null)
+        return { ...typed, targets: [], structured: described, fields: [], linked: true, sections: [] };
+    const kind = kindOf(document, typedPath);
+    if (kind === BUILT_IN_TYPE) {
+        const structured = unmarkedMember(file, document, undefined);
+        return {
+            ...typed,
+            targets: [],
+            structured,
+            fields: [],
+            linked: !reservedLink(file, document),
+            sections: [],
+        };
+    }
+    const definition = definitionOf(kind, model);
+    try {
+        return structured(file, content, typed, document, definition, context);
+    }
+    catch (error) {
+        if (!(error instanceof PatternTooCostly))
+            throw error;
+        return {
+            ...typed,
+            targets: [],
+            structured: refuse(file, 'pattern', { location: '' }),
+            fields: [],
+            linked: true,
+            sections: [],
+        };
+    }
+}
+function structured(file, content, typed, document, definition, context) {
+    const read = structure(file, content, document, definition);
+    if ('refusal' in read || definition === undefined) {
+        return {
+            ...typed,
+            targets: [],
+            structured: 'refusal' in read ? read.refusal : null,
+            fields: [],
+            linked: true,
+            sections: [],
+        };
+    }
+    const anyRoom = context.anyRoom === true;
+    const fields = references(document, definition).flatMap(({ pointer, value, to, crossRoom }) => crossing(file, value, anyRoom || crossRoom)
+        ? []
+        : [{ reference: referred(file, value, to), location: pointer }]);
+    const sections = read.sections.flatMap(({ section, to, crossRoom, hrefs }) => hrefs.flatMap((href) => crossing(file, href, anyRoom || crossRoom)
+        ? []
+        : [{ reference: referred(file, href, to), location: section }]));
+    const targets = new Set();
+    for (const { reference } of [...fields, ...sections]) {
+        if (reference.target !== null)
+            targets.add(reference.target);
+    }
+    return {
+        ...typed,
+        targets: [...targets],
+        fields,
+        linked: linked(file, content) && !reservedLink(file, document),
+        sections,
+    };
+}
+export function verdicts() {
+    let read;
+    let structured;
+    let referred;
+    let missed;
+    const unreached = (placed, typeOf, binary) => placed.find(({ reference }) => !reaches(reference, typeOf, binary));
+    return {
+        add(assessment, typeOf, binary) {
+            const { file } = assessment;
+            if (assessment.read !== null) {
+                read = least(read, file, assessment.read);
+                return 0;
+            }
+            if (assessment.structured !== null) {
+                structured = least(structured, file, assessment.structured);
+                return 0;
+            }
+            const field = unreached(assessment.fields, typeOf, binary);
+            if (field !== undefined) {
+                referred = least(referred, file, refuse(file, 'unresolved-reference', { location: field.location }));
+                return 0;
+            }
+            if (!assessment.linked) {
+                referred = least(referred, file, refuse(file, 'unresolved-link'));
+                return 0;
+            }
+            const section = unreached(assessment.sections, typeOf, binary);
+            if (section !== undefined) {
+                referred = least(referred, file, refuse(file, 'unresolved-reference', { location: section.location }));
+                return 0;
+            }
+            const all = [...assessment.fields, ...assessment.sections];
+            for (const { reference } of all) {
+                if (!missing(reference, typeOf, binary))
+                    continue;
+                const path = reference.target;
+                if (missed === undefined || path < missed.path)
+                    missed = { path, referrers: [] };
+                if (path === missed.path && missed.referrers.at(-1) !== file)
+                    missed.referrers.push(file);
+            }
+            return all.length;
+        },
+        verdict() {
+            const refused = read ?? structured ?? referred;
+            if (refused !== undefined)
+                return refused.verdict;
+            if (missed !== undefined) {
+                return refuse(missed.path, 'referenced-missing-file', {
+                    referrers: [...missed.referrers].sort(),
+                });
+            }
+            return { verdict: 'accept' };
+        },
+    };
+}
+export function* validating(library, context = { binaryTargets: [] }, model = { types: {} }) {
     const binaryTargets = new Set(context.binaryTargets);
     const binary = (path) => binaryTargets.has(path);
-    const files = Object.keys(library).sort();
     const types = new Map();
-    const typeOf = (path) => types.get(path);
-    const documents = new Map();
-    for (const file of files) {
-        if (binaryTargets.has(file))
-            return refuse(file, 'binary-target-document');
-        const parsed = parse(library[file], file);
-        if (!parsed.ok)
-            return { verdict: 'refuse', ...parsed.refusal };
-        types.set(file, parsed.document.type ?? BUILT_IN_TYPE);
-        if (instanceType(parsed.document) !== BUILT_IN_TYPE)
-            documents.set(file, parsed.document);
-    }
-    const sectionReferences = new Map();
-    for (const [file, document] of documents) {
-        const read = structure(file, library[file], document, definitionOf(document, model));
-        if ('refusal' in read)
-            return read.refusal;
-        sectionReferences.set(file, read.sections);
-    }
-    const named = new Map();
-    for (const [file, document] of documents) {
-        const definition = definitionOf(document, model);
-        const fields = references(document, definition).map(({ pointer, value, to }) => ({
-            reference: reached(file, value, to),
-            location: pointer,
-        }));
-        for (const { reference, location } of fields) {
-            if (!reaches(reference, typeOf, binary))
-                return refuse(file, 'unresolved-reference', { location });
-        }
-        if (!linked(file, library[file]))
-            return refuse(file, 'unresolved-link');
-        const sections = sectionReferences
-            .get(file)
-            .flatMap(({ section, to, hrefs }) => hrefs.map((href) => ({ reference: reached(file, href, to), location: section })));
-        for (const { reference, location } of sections) {
-            if (!reaches(reference, typeOf, binary))
-                return refuse(file, 'unresolved-reference', { location });
+    const assessments = [];
+    const closeBudget = openPatternBudget();
+    try {
+        for (const [file, content] of library) {
+            const assessment = assess(file, content, binary(file), model, context);
+            if (assessment.type !== undefined)
+                types.set(file, assessment.type);
+            assessments.push(assessment);
+            yield { path: file, resolved: 0 };
         }
-        named.set(file, [...fields, ...sections]);
-    }
-    const absent = new Map();
-    for (const [file, references] of named) {
-        for (const { reference } of references) {
-            if (!missing(reference, typeOf, binary))
-                continue;
-            const referrers = absent.get(reference.target) ?? [];
-            referrers.push(file);
-            absent.set(reference.target, referrers);
+        const judged = verdicts();
+        for (const assessment of assessments) {
+            const resolved = judged.add(assessment, (path) => types.get(path), binary);
+            yield { path: assessment.file, resolved };
         }
+        return judged.verdict();
     }
-    const missingPaths = [...absent.keys()].sort();
-    if (missingPaths.length > 0) {
-        const path = missingPaths[0];
-        const referrers = [...new Set(absent.get(path) ?? [])].sort();
-        return refuse(path, 'referenced-missing-file', { referrers });
+    finally {
+        closeBudget();
     }
-    return { verdict: 'accept' };
+}
+export function validate(library, context = { binaryTargets: [] }, model = { types: {} }) {
+    const steps = validating(new Map(Object.entries(library)), context, model);
+    let step = steps.next();
+    while (step.done !== true)
+        step = steps.next();
+    return step.value;
 }

package/dist/yaml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"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"}

package/dist/yaml.js

@@ -6,6 +6,18 @@ export class YamlError extends Error {
         this.name = 'YamlError';
     }
 }
+const YAML_DEPTH_MAX = 64;
+function nested(c, parse) {
+    if (c.depth >= YAML_DEPTH_MAX)
+        throw new YamlError(c.i);
+    c.depth += 1;
+    try {
+        return parse();
+    }
+    finally {
+        c.depth -= 1;
+    }
+}
 function peek(c) {
     return c.i < c.end ? c.text[c.i] : '';
 }
@@ -70,7 +82,10 @@ function indentAt(c) {
     }
     return n;
 }
+const UNHELD_TEXT = /[\0\ud800-\udfff]/u;
 function scalar(value, start, end) {
+    if (typeof value === 'string' && UNHELD_TEXT.test(value))
+        throw new YamlError(start);
     return { kind: 'scalar', value, start, end };
 }
 export function interpretPlain(text) {
@@ -202,6 +217,9 @@ function parseFlowValue(c) {
     return parseScalar(c, true);
 }
 function parseFlowMap(c) {
+    return nested(c, () => flowMap(c));
+}
+function flowMap(c) {
     const start = c.i;
     if (peek(c) !== '{')
         throw new YamlError(c.i);
@@ -240,6 +258,9 @@ function parseFlowMap(c) {
     throw new YamlError(c.i);
 }
 function parseFlowSeq(c) {
+    return nested(c, () => flowSeq(c));
+}
+function flowSeq(c) {
     const start = c.i;
     if (peek(c) !== '[')
         throw new YamlError(c.i);
@@ -336,6 +357,9 @@ function parseSeqItem(c, indent) {
     return parseValue(c, indent);
 }
 function parseBlockSeq(c, indent) {
+    return nested(c, () => blockSeq(c, indent));
+}
+function blockSeq(c, indent) {
     const start = c.i;
     const items = [];
     let end = start;
@@ -355,6 +379,9 @@ function parseBlockSeq(c, indent) {
     return { kind: 'seq', items, start, end };
 }
 function parseBlockMap(c, indent, inline = false) {
+    return nested(c, () => blockMap(c, indent, inline));
+}
+function blockMap(c, indent, inline) {
     const start = c.i;
     const entries = [];
     const seen = new Set();
@@ -387,7 +414,7 @@ function parseBlockMap(c, indent, inline = false) {
     return { kind: 'map', entries, start, end };
 }
 export function parseYamlMapping(text, start, end) {
-    const c = { text, i: start, end };
+    const c = { text, i: start, end, depth: 0 };
     skipBlankAndComments(c);
     if (c.i >= end)
         return { kind: 'map', entries: [], start, end };
@@ -439,17 +466,23 @@ function listed(value) {
     return keys.length === value.length && keys.every((key, index) => key === String(index));
 }
 function heldWithin(value, within) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+    if (typeof value === 'string')
+        return !UNHELD_TEXT.test(value);
+    if (value === null || typeof value === 'boolean')
         return true;
     if (typeof value === 'number')
         return Number.isFinite(value);
     if (typeof value !== 'object' || within.includes(value))
         return false;
+    if (within.length + 1 >= YAML_DEPTH_MAX)
+        return false;
     const path = [...within, value];
     const held = (item) => heldWithin(item, path);
     if (Array.isArray(value))
         return listed(value) && value.every(held);
-    return plain(value) && Object.values(value).every(held);
+    return (plain(value) &&
+        Object.keys(value).every((key) => !UNHELD_TEXT.test(key)) &&
+        Object.values(value).every(held));
 }
 export function frontmatterValue(value) {
     return heldWithin(value, []);

package/fixtures/README.md

@@ -51,8 +51,8 @@ change to a value that is not prose leaves the projection alone.
 
 `division.json` exercises the public `divide` seam separately from the
 validation Libraries. It carries `schema` and `cases` like `projection.json`,
-and each case adds the `budget` the division runs under. Parse the source, call
-`divide(document, file, context)` with `{ documentTargets, definition, budget }`,
+and each case adds the `bound` the division runs under. Parse the source, call
+`divide(document, file, context)` with `{ documentTargets, definition, bound }`,
 and compare against `expected`: either `{ "ok": true, "spans": [...] }`, where
 each span carries the exact `text` to embed and the exact `source` the returned
 `start` and `end` address in that case's source, or `{ "ok": false, "refusal": ... }`. Then
@@ -65,6 +65,19 @@ value one span carries part of. `start` and `end` are UTF-8 byte offsets into th
 source; every source in this corpus is ASCII, so a consumer compares the
 addressed `source` with an ordinary string slice.
 
+## Queries
+
+`queries.json` is the one table of cases both query evaluators answer. It carries `schema`,
+one schema text; `documents`, each named and carrying its `path`, the `type` a collection
+stores for it (`any` for an untyped Markdown Document, `null` for one that is not Markdown),
+its `fileId`, the `text` the device holds or `null`, and its `fields`; and `cases`, each with a
+`name`, a `query` of filter parts, the `document` it names and whether it `matches`. Verify
+the schema and plan `{ ...query, select: {} }` with `planOf` against its types. Then
+`matches(plan, candidate)` over the named Document, given its type's definition, and the
+condition `sql.tests` writes over a collection holding every Document of the table with the
+values `indexed` derives from it must both answer `matches`. A new operator adds its cases
+here first.
+
 ## Verdict format
 
 Acceptance:
@@ -107,6 +120,7 @@ schema text. The model's own rules:
 | `frontmatter-fence`       | A present frontmatter fence does not parse as the accepted YAML subset            |
 | `schema-yaml`             | A schema text is not a mapping in the accepted YAML subset                        |
 | `schema-type-name`        | A type name is empty, starts with `$`, or is `any` or `attachment`                |
+| `provided-type`           | A schema names a type its caller provides with a key but its two role keywords    |
 | `schema`                  | A type or subschema is neither a mapping nor a boolean                            |
 | `schema-keyword`          | A schema carries a key that is no JSON Schema 2020-12 keyword the model admits    |
 | `$defs`                   | `$defs` is not a mapping                                                          |
@@ -114,17 +128,23 @@ schema text. The model's own rules:
 | `reference`               | `reference` is not on a string or names something but a type, `any`, `attachment` |
 | `sections`                | A section is not `{ kind: text }` or `{ kind: list, items }` over one scalar      |
 | `member_document`         | The mark is not a boolean, or a second type carries it                            |
-| `unknown-type`            | A file declares a type absent from the governing schema                           |
+| `unknown-type`            | A file declares a type absent from the governing schema, or other than its typed path requires it to name |
 | `undeclared-field`        | A closed object carries a key it does not declare                                 |
 | `required-section`        | A required section heading is missing                                             |
+| `conditional-section`     | A section its type's `if` branch requires is absent or holds no text              |
 | `unresolved-reference`    | A reference at any depth or a section item reaches no member it admits            |
-| `unresolved-link`         | A body link is an absolute path or leaves the collection                          |
+| `unresolved-link`         | A body link is an absolute path, leaves the collection or, from a typed Document at a document path, reaches a reserved name |
+| `room-md-type`            | `ROOM.md` declares a type                                                         |
+| `required-body`           | A file at a typed path that requires a body has a body holding no text            |
 | `structured-section`      | A declared list section is not a list of values of its item schema                |
 | `referenced-missing-file` | Remaining files still reference an absent path                                    |
 | `unwritable-link`         | No Markdown destination form can carry a new link destination                     |
-| `division-budget`         | A division budget is not a whole number of at least 2                             |
+| `division-bound`         | A division bound is not a whole number of at least 2                             |
+
+A `then` or `else` of an `if` on a type, in its `allOf` or in such a branch may hold
+`sections`, naming sections the type declares as the type declares them, else `sections`.
 
-`unwritable-link` is refused by `apply` and `division-budget` by `divide`, not
+`unwritable-link` is refused by `apply` and `division-bound` by `divide`, not
 by `validate`, so no case under `cases/` carries either.
 
 A reference that admits `attachment` reaches any path in the same Library, so

package/fixtures/cases/conditional-section/context.json

@@ -0,0 +1 @@
+{ "binaryTargets": [] }

package/fixtures/cases/conditional-section/expected.json

@@ -0,0 +1,6 @@
+{
+  "verdict": "refuse",
+  "file": "questions/payments.md",
+  "location": "Answer",
+  "rule": "conditional-section"
+}

package/fixtures/cases/conditional-section/library/questions/hosting.md

@@ -0,0 +1,9 @@
+---
+type: question
+title: Where does it run
+status: open
+---
+
+## Question
+
+Which host runs the shop?