@agentshouse/mdmodel 0.1.0-c83456e1cebfb → 0.1.0-cabd61587647f

package/dist/definition.js

@@ -1,138 +1,705 @@
-import { jsValue, parseYamlMapping, YamlError } from './yaml.js';
+import { MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD, TYPE_FIELD } from './fields.js';
+import { equalValue, isRecord, jsValue, parseYamlMapping, YamlError } from './yaml.js';
+export const JSON_TYPES = [
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'object',
+    'array',
+    'null',
+];
+export const BUILT_IN_TYPE = 'any';
+export const ATTACHMENT = 'attachment';
+const SCALAR_TYPES = new Set(['string', 'number', 'integer', 'boolean']);
+const COMPOSITES = ['array', 'object'];
+const ANNOTATIONS = new Set([
+    '$comment',
+    'title',
+    'description',
+    'default',
+    'examples',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+]);
+const FIELD_RULES = ['change_roles', 'initial_roles', 'transitions'];
+const DEFS_REFERENCE = '#/$defs/';
+const UNRESOLVED = /[\u0000-\u001f\u007f%[\]\\^{|}]|\s$/u;
+export const ARRAY_INDEX = /^(?:0|[1-9][0-9]*)$/u;
+const HOUSE_KEYS = {
+    [TYPE_FIELD]: { prose: false },
+    [SITE_FIELD]: { prose: false },
+    [RECEIVED_FIELD]: { prose: false },
+};
 function refuse(rule, location) {
     return location === undefined ? { rule } : { rule, location };
 }
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
+export function escapePointer(key) {
+    return key.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-function requiredFlag(value) {
-    if (value === undefined)
+function unescapePointer(segment) {
+    return segment.replaceAll('~1', '/').replaceAll('~0', '~');
+}
+export function pointerSegments(pointer) {
+    return pointer.split('/').slice(1).map(unescapePointer);
+}
+export function refTarget(reference, defs) {
+    if (!reference.startsWith(DEFS_REFERENCE) || UNRESOLVED.test(reference))
+        return undefined;
+    const segments = reference.slice(DEFS_REFERENCE.length).split('/');
+    const [name = '', ...rest] = segments.map(unescapePointer);
+    if (segments.some((segment) => escapePointer(unescapePointer(segment)) !== segment))
+        return undefined;
+    if (!Object.hasOwn(defs, name))
+        return undefined;
+    let node = defs[name];
+    for (let index = 0; index < rest.length; index += 1) {
+        const keyword = rest[index];
+        if (!isRecord(node) || !Object.hasOwn(node, keyword) || !Object.hasOwn(KEYWORDS, keyword))
+            return undefined;
+        const check = KEYWORDS[keyword];
+        const held = node[keyword];
+        if (check === SCHEMA) {
+            node = held;
+            continue;
+        }
+        const key = rest[index + 1];
+        index += 1;
+        if (check === SCHEMA_LIST && Array.isArray(held) && key !== undefined && ARRAY_INDEX.test(key))
+            node = held[Number(key)];
+        else if (check === SCHEMA_MAP &&
+            isRecord(held) &&
+            key !== undefined &&
+            Object.hasOwn(held, key))
+            node = held[key];
+        else
+            return undefined;
+        if (node === undefined)
+            return undefined;
+    }
+    return { name, node };
+}
+function compiles(pattern) {
+    if (typeof pattern !== 'string')
+        return false;
+    try {
+        new RegExp(pattern, 'u');
+        return true;
+    }
+    catch {
         return false;
+    }
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function count(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function strings(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => typeof item === 'string') &&
+        new Set(value).size === value.length);
+}
+function schemaFailure(value, at, context) {
     if (typeof value === 'boolean')
-        return value;
+        return undefined;
+    if (!isRecord(value))
+        return refuse('schema', at);
+    for (const [key, held] of Object.entries(value)) {
+        const where = `${at}/${escapePointer(key)}`;
+        if (!Object.hasOwn(KEYWORDS, key))
+            return refuse('schema-keyword', where);
+        const check = KEYWORDS[key];
+        if (check === SCHEMA) {
+            const failure = schemaFailure(held, where, context);
+            if (failure !== undefined)
+                return failure;
+            continue;
+        }
+        if (check === SCHEMA_LIST) {
+            if (!Array.isArray(held) || held.length === 0)
+                return refuse(key, where);
+            for (const [index, item] of held.entries()) {
+                const failure = schemaFailure(item, `${where}/${index}`, context);
+                if (failure !== undefined)
+                    return failure;
+            }
+            continue;
+        }
+        if (check === SCHEMA_MAP) {
+            if (!isRecord(held))
+                return refuse(key, where);
+            for (const [name, item] of Object.entries(held)) {
+                if (key === 'patternProperties' && !compiles(name))
+                    return refuse(key, `${where}/${escapePointer(name)}`);
+                const failure = schemaFailure(item, `${where}/${escapePointer(name)}`, context);
+                if (failure !== undefined)
+                    return failure;
+            }
+            continue;
+        }
+        if (!check(held, where, value, context))
+            return refuse(key, where);
+    }
     return undefined;
 }
-function stringList(value) {
-    if (!Array.isArray(value) || value.length === 0)
+const SCHEMA = () => true;
+const SCHEMA_LIST = () => true;
+const SCHEMA_MAP = () => true;
+const ANY = () => true;
+const TEXT = (value) => typeof value === 'string';
+const FLAG = (value) => typeof value === 'boolean';
+const NUMBER = finite;
+const COUNT = count;
+const KEYWORDS = {
+    $comment: TEXT,
+    $ref: (value, _at, _node, context) => typeof value === 'string' && refTarget(value, context.defs) !== undefined,
+    $defs: SCHEMA_MAP,
+    allOf: SCHEMA_LIST,
+    anyOf: SCHEMA_LIST,
+    oneOf: SCHEMA_LIST,
+    prefixItems: SCHEMA_LIST,
+    not: SCHEMA,
+    if: SCHEMA,
+    then: SCHEMA,
+    else: SCHEMA,
+    items: SCHEMA,
+    contains: SCHEMA,
+    additionalProperties: SCHEMA,
+    unevaluatedProperties: SCHEMA,
+    unevaluatedItems: SCHEMA,
+    propertyNames: SCHEMA,
+    contentSchema: SCHEMA,
+    properties: SCHEMA_MAP,
+    patternProperties: SCHEMA_MAP,
+    dependentSchemas: SCHEMA_MAP,
+    type: (value) => (typeof value === 'string' && JSON_TYPES.includes(value)) ||
+        (Array.isArray(value) &&
+            value.length > 0 &&
+            strings(value) &&
+            value.every((item) => JSON_TYPES.includes(item))),
+    enum: (value) => Array.isArray(value) && value.length > 0,
+    const: ANY,
+    multipleOf: (value) => finite(value) && value > 0,
+    maximum: NUMBER,
+    exclusiveMaximum: NUMBER,
+    minimum: NUMBER,
+    exclusiveMinimum: NUMBER,
+    maxLength: COUNT,
+    minLength: COUNT,
+    maxItems: COUNT,
+    minItems: COUNT,
+    maxContains: COUNT,
+    minContains: COUNT,
+    maxProperties: COUNT,
+    minProperties: COUNT,
+    pattern: compiles,
+    uniqueItems: FLAG,
+    required: strings,
+    dependentRequired: (value) => isRecord(value) && Object.values(value).every(strings),
+    format: TEXT,
+    contentEncoding: TEXT,
+    contentMediaType: TEXT,
+    title: TEXT,
+    description: TEXT,
+    default: ANY,
+    examples: (value) => Array.isArray(value),
+    deprecated: FLAG,
+    readOnly: FLAG,
+    writeOnly: FLAG,
+    reference: (value, _at, node, context) => {
+        if (node.type !== 'string')
+            return false;
+        const named = typeof value === 'string' ? [value] : value;
+        return (Array.isArray(named) &&
+            named.length > 0 &&
+            strings(named) &&
+            named.every((name) => name === BUILT_IN_TYPE || name === ATTACHMENT || context.types.has(name)));
+    },
+};
+function sharedType(values) {
+    if (values.length === 0)
         return undefined;
-    if (!value.every((item) => typeof item === 'string' && item !== ''))
+    if (values.every((value) => typeof value === 'string'))
+        return 'string';
+    if (values.every((value) => typeof value === 'number'))
+        return 'number';
+    if (values.every((value) => typeof value === 'boolean'))
+        return 'boolean';
+    return undefined;
+}
+function singleType(type) {
+    if (typeof type === 'string')
+        return type;
+    if (!Array.isArray(type))
         return undefined;
-    return [...value];
-}
-const SCALAR_KINDS = new Set(['text', 'string', 'number', 'date', 'enum', 'reference']);
-function parseScalar(names, location, spec, required) {
-    const kind = spec.kind;
-    if (kind === 'text')
-        return { kind: 'text', required };
-    if (kind === 'string')
-        return { kind: 'string', required };
-    if (kind === 'number')
-        return { kind: 'number', required };
-    if (kind === 'date')
-        return { kind: 'date', required };
-    if (kind === 'enum') {
-        const values = stringList(spec.values);
-        if (values === undefined)
-            return refuse('definition-enum-values', location);
-        return { kind: 'enum', required, values };
-    }
-    if (kind === 'reference') {
-        if (typeof spec.to !== 'string' || (spec.to !== 'any' && !names.has(spec.to)))
-            return refuse('definition-reference-to', location);
-        return { kind: 'reference', required, to: spec.to };
-    }
-    return refuse('definition-field-kind', location);
-}
-function extraKeys(spec, allowed) {
-    return Object.keys(spec).some((key) => !allowed.includes(key));
-}
-function parseList(names, location, spec, required, malformed) {
-    if (typeof spec.of !== 'string' || !SCALAR_KINDS.has(spec.of)) {
-        return refuse('definition-list-of', location);
-    }
-    const allowed = spec.of === 'enum'
-        ? ['kind', 'required', 'of', 'values']
-        : spec.of === 'reference'
-            ? ['kind', 'required', 'of', 'to']
-            : ['kind', 'required', 'of'];
-    if (extraKeys(spec, allowed))
-        return refuse(malformed, location);
-    const inner = parseScalar(names, location, { ...spec, kind: spec.of }, false);
-    if ('rule' in inner)
-        return inner;
-    return { kind: 'list', required, of: inner };
-}
-function parseField(names, location, value) {
-    if (!isRecord(value) || typeof value.kind !== 'string')
-        return refuse('definition-field', location);
-    const required = requiredFlag(value.required);
-    if (required === undefined)
-        return refuse('definition-field', location);
-    if (value.kind === 'list')
-        return parseList(names, location, value, required, 'definition-field');
-    const allowed = value.kind === 'enum'
-        ? ['kind', 'required', 'values']
-        : value.kind === 'reference'
-            ? ['kind', 'required', 'to']
-            : ['kind', 'required'];
-    if (extraKeys(value, allowed))
-        return refuse('definition-field', location);
-    return parseScalar(names, location, value, required);
-}
-function parseSection(names, location, value) {
-    if (!isRecord(value) || (value.kind !== 'text' && value.kind !== 'list')) {
-        return refuse('definition-section-kind', location);
-    }
-    const required = requiredFlag(value.required);
-    if (required === undefined)
-        return refuse('definition-section', location);
-    if (value.kind === 'list')
-        return parseList(names, location, value, required, 'definition-section');
-    if (extraKeys(value, ['kind', 'required']))
-        return refuse('definition-section', location);
-    return { kind: 'text', required };
-}
-function readType(names, name, value) {
-    const location = `types.${name}`;
-    if (!isRecord(value))
-        return refuse('definition-shape', location);
-    for (const key of Object.keys(value)) {
-        if (key !== 'fields' && key !== 'sections' && key !== 'member_document') {
-            return refuse('definition-shape', `${location}.${key}`);
+    const kept = type.filter((one) => one !== 'null');
+    return kept.length === 1 ? kept[0] : undefined;
+}
+function firstOf(held, read) {
+    for (const node of held) {
+        const value = read(node);
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+function conjoined(nodes, defs, ancestry) {
+    const held = [];
+    const reached = new Set(ancestry);
+    const visit = (node) => {
+        if (!isRecord(node) || held.includes(node))
+            return;
+        held.push(node);
+        if (typeof node.$ref === 'string') {
+            const target = refTarget(node.$ref, defs)?.node;
+            if (target !== undefined && !reached.has(target)) {
+                reached.add(target);
+                visit(target);
+            }
         }
+        if (Array.isArray(node.allOf))
+            for (const one of node.allOf)
+                visit(one);
+    };
+    for (const node of nodes)
+        visit(node);
+    return { held, ancestry: reached };
+}
+function variantsOf(node) {
+    return [
+        ...(Array.isArray(node.anyOf) ? node.anyOf : []),
+        ...(Array.isArray(node.oneOf) ? node.oneOf : []),
+        node.then,
+        node.else,
+        ...(isRecord(node.dependentSchemas) ? Object.values(node.dependentSchemas) : []),
+    ].filter(isRecord);
+}
+function united(left, right) {
+    if (left === undefined || right === undefined)
+        return undefined;
+    return [...left, ...right.filter((value) => !left.some((held) => equalValue(held, value)))];
+}
+function both(left, right) {
+    return left !== undefined && right !== undefined ? joined(left, right) : undefined;
+}
+function joined(left, right) {
+    const type = left.type === right.type ? left.type : undefined;
+    const format = left.format === right.format ? left.format : undefined;
+    const values = united(left.values, right.values);
+    const reference = united(left.reference, right.reference);
+    const items = both(left.items, right.items);
+    const prefix = left.prefix === undefined && right.prefix === undefined
+        ? undefined
+        : Array.from({ length: Math.max(left.prefix?.length ?? 0, right.prefix?.length ?? 0) }, (_, index) => both(itemFacts(left, index), itemFacts(right, index)) ?? { prose: false });
+    const properties = Object.create(null);
+    for (const [name, facts] of Object.entries(left.properties ?? {})) {
+        const shared = both(facts, right.properties?.[name]);
+        if (shared !== undefined)
+            properties[name] = shared;
+    }
+    const patterns = (left.patterns ?? []).flatMap(({ pattern, facts }) => {
+        const shared = both(facts, right.patterns?.find((one) => one.pattern === pattern)?.facts);
+        return shared === undefined ? [] : [{ pattern, facts: shared }];
+    });
+    const additional = both(left.additional, right.additional);
+    return {
+        ...(type === undefined ? {} : { type }),
+        ...(format === undefined ? {} : { format }),
+        ...(values === undefined ? {} : { values }),
+        ...(reference === undefined ? {} : { reference }),
+        prose: left.prose && right.prose,
+        ...(prefix === undefined ? {} : { prefix }),
+        ...(items === undefined ? {} : { items }),
+        ...(Object.keys(properties).length === 0 ? {} : { properties }),
+        ...(patterns.length === 0 ? {} : { patterns }),
+        ...(additional === undefined ? {} : { additional }),
+    };
+}
+function propertiesOf(held, variants, defs, ancestry) {
+    const declared = new Map();
+    for (const node of held) {
+        if (!isRecord(node.properties))
+            continue;
+        for (const [name, schema] of Object.entries(node.properties))
+            declared.set(name, [...(declared.get(name) ?? []), schema]);
     }
-    const mark = value.member_document === undefined ? false : value.member_document;
-    if (typeof mark !== 'boolean')
-        return refuse('definition-shape', `${location}.member_document`);
-    const fieldsValue = value.fields;
-    const sectionsValue = value.sections;
-    if (fieldsValue !== undefined && !isRecord(fieldsValue))
-        return refuse('definition-fields', `${location}.fields`);
-    if (sectionsValue !== undefined && !isRecord(sectionsValue)) {
-        return refuse('definition-sections', `${location}.sections`);
-    }
-    const fields = Object.create(null);
-    for (const [fieldName, spec] of Object.entries(fieldsValue ?? {})) {
-        const parsed = parseField(names, `${location}.fields.${fieldName}`, spec);
-        if ('rule' in parsed)
-            return parsed;
-        fields[fieldName] = parsed;
+    const properties = Object.create(null);
+    for (const [name, schemas] of declared)
+        properties[name] = factsOf(schemas, defs, ancestry);
+    const conditional = Object.create(null);
+    for (const branch of variants.values()) {
+        for (const [name, facts] of Object.entries(branch.properties ?? {})) {
+            if (Object.hasOwn(properties, name))
+                continue;
+            conditional[name] = Object.hasOwn(conditional, name)
+                ? joined(conditional[name], facts)
+                : facts;
+        }
     }
+    for (const [name, facts] of Object.entries(conditional))
+        properties[name] = { ...facts, conditional: true };
+    return Object.keys(properties).length === 0 ? undefined : properties;
+}
+function nullOnly(facts) {
+    return facts.type === 'null' || (facts.values?.every((value) => value === null) ?? false);
+}
+function alternativesOf(held, variants) {
+    return held.flatMap((node) => [node.anyOf, node.oneOf].flatMap((branches) => {
+        if (!Array.isArray(branches))
+            return [];
+        const kept = branches
+            .flatMap((branch) => {
+            const facts = isRecord(branch) ? variants.get(branch) : undefined;
+            return facts === undefined ? [] : [facts];
+        })
+            .filter((facts) => !nullOnly(facts));
+        return kept.length === 0 ? [] : [kept];
+    }));
+}
+function inheritedOf(held) {
+    return held.flatMap((node) => {
+        const kept = Object.fromEntries(['type', 'items', 'prefixItems'].flatMap((key) => node[key] === undefined ? [] : [[key, node[key]]]));
+        return Object.keys(kept).length === 0 ? [] : [kept];
+    });
+}
+function factsOf(nodes, defs, ancestry) {
+    const { held, ancestry: reached } = conjoined(nodes, defs, ancestry);
+    const inherited = inheritedOf(held);
+    const variants = new Map(held
+        .flatMap(variantsOf)
+        .map((branch) => [branch, factsOf([branch, ...inherited], defs, reached)]));
+    const unions = alternativesOf(held, variants);
+    const alternatives = unions.map((kept) => kept.reduce(joined));
+    const listed = [
+        ...held.flatMap((node) => Array.isArray(node.enum) ? [node.enum] : node.const !== undefined ? [[node.const]] : []),
+        ...alternatives.flatMap((facts) => (facts.values === undefined ? [] : [facts.values])),
+    ];
+    const values = listed.length === 0
+        ? undefined
+        : listed.reduce((kept, list) => kept.filter((value) => list.some((other) => equalValue(other, value))));
+    const type = firstOf(held, (node) => singleType(node.type)) ??
+        (values === undefined ? undefined : sharedType(values)) ??
+        alternatives.find((facts) => facts.type !== undefined)?.type;
+    const reference = firstOf(held, (node) => typeof node.reference === 'string'
+        ? [node.reference]
+        : Array.isArray(node.reference)
+            ? node.reference
+            : undefined) ?? alternatives.find((facts) => facts.reference !== undefined)?.reference;
+    const format = firstOf(held, (node) => (typeof node.format === 'string' ? node.format : undefined)) ??
+        alternatives.find((facts) => facts.format !== undefined)?.format;
+    const prose = type === 'string' &&
+        values === undefined &&
+        format === undefined &&
+        reference === undefined &&
+        held.every((node) => node.pattern === undefined) &&
+        unions.every((kept) => kept.every((facts) => facts.type !== 'string' || facts.prose));
+    const listedItems = held.flatMap((node) => (node.items === undefined ? [] : [node.items]));
+    const items = type !== 'array'
+        ? undefined
+        : (alternatives.find((facts) => facts.items !== undefined)?.items ??
+            (listedItems.length > 0 ? factsOf(listedItems, defs, reached) : undefined));
+    const tuples = held.flatMap((node) => Array.isArray(node.prefixItems) ? [node.prefixItems] : []);
+    const prefix = type !== 'array'
+        ? undefined
+        : (alternatives.find((facts) => facts.prefix !== undefined)?.prefix ??
+            (tuples.length === 0
+                ? undefined
+                : Array.from({ length: Math.max(...tuples.map((tuple) => tuple.length)) }, (_, index) => factsOf(tuples.flatMap((tuple) => (index < tuple.length ? [tuple[index]] : [])), defs, reached))));
+    const mapped = type === 'object' || type === undefined;
+    const properties = mapped ? propertiesOf(held, variants, defs, reached) : undefined;
+    const patterns = mapped
+        ? held.flatMap((node) => Object.entries(isRecord(node.patternProperties) ? node.patternProperties : {}).map(([pattern, schema]) => ({ pattern, facts: factsOf([schema], defs, reached) })))
+        : [];
+    const opened = mapped
+        ? held.flatMap((node) => [node.additionalProperties, node.unevaluatedProperties].filter(isRecord))
+        : [];
+    const additional = opened.length === 0 ? undefined : factsOf(opened, defs, reached);
+    return {
+        ...(type === undefined ? {} : { type }),
+        ...(format === undefined ? {} : { format }),
+        ...(values === undefined ? {} : { values }),
+        ...(reference === undefined ? {} : { reference }),
+        prose,
+        ...(prefix === undefined ? {} : { prefix }),
+        ...(items === undefined ? {} : { items }),
+        ...(properties === undefined ? {} : { properties }),
+        ...(patterns.length === 0 ? {} : { patterns }),
+        ...(additional === undefined ? {} : { additional }),
+    };
+}
+export function valueFacts(node, defs) {
+    return factsOf([node], defs, new Set());
+}
+export function itemFacts(facts, index) {
+    return facts.prefix?.[index] ?? facts.items;
+}
+export function memberFacts(facts, key) {
+    if (facts.properties !== undefined && Object.hasOwn(facts.properties, key))
+        return facts.properties[key];
+    const pattern = facts.patterns?.find((one) => new RegExp(one.pattern, 'u').test(key));
+    return pattern === undefined ? facts.additional : pattern.facts;
+}
+export function crossedFacts(facts) {
+    if (facts.type !== 'array')
+        return [facts];
+    return [...(facts.prefix ?? []), ...(facts.items === undefined ? [] : [facts.items])].flatMap(crossedFacts);
+}
+export function fieldFacts(definition, key) {
+    if (Object.hasOwn(definition.fields, key))
+        return definition.fields[key];
+    if (Object.hasOwn(HOUSE_KEYS, key))
+        return undefined;
+    return memberFacts(definition.frontmatter, key);
+}
+function stepped({ facts, through, conditional }, token) {
+    if (facts.type === 'array' && ARRAY_INDEX.test(token)) {
+        const item = itemFacts(facts, Number(token));
+        return item === undefined ? [] : [{ facts: item, through, conditional }];
+    }
+    return crossedFacts(facts).flatMap((crossed) => {
+        const member = memberFacts(crossed, token);
+        return member === undefined
+            ? []
+            : [
+                {
+                    facts: member,
+                    through: through || facts.type === 'array',
+                    conditional: conditional || member.conditional === true,
+                },
+            ];
+    });
+}
+export function pointerFacts(definition, pointer) {
+    const [field, ...rest] = pointerSegments(pointer);
+    const declared = field === undefined ? undefined : fieldFacts(definition, field);
+    if (declared === undefined)
+        return undefined;
+    let reached = [
+        { facts: declared, through: false, conditional: declared.conditional === true },
+    ];
+    for (const token of rest)
+        reached = reached.flatMap((held) => stepped(held, token));
+    if (reached.length === 0)
+        return undefined;
+    return reached.reduce((kept, held) => ({
+        facts: joined(kept.facts, held.facts),
+        through: kept.through || held.through,
+        conditional: kept.conditional || held.conditional,
+    }));
+}
+function reachedDefs(value, defs, reached) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            reachedDefs(item, defs, reached);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    for (const [key, held] of Object.entries(value)) {
+        if (key === '$ref' && typeof held === 'string') {
+            const name = refTarget(held, defs)?.name;
+            if (name === undefined || Object.hasOwn(reached, name))
+                continue;
+            reached[name] = defs[name];
+            reachedDefs(defs[name], defs, reached);
+            continue;
+        }
+        reachedDefs(held, defs, reached);
+    }
+}
+function readSections(value, at, context) {
+    const failed = (rule, location) => ({ failure: refuse(rule, location) });
+    if (!isRecord(value))
+        return failed('sections', at);
     const sections = Object.create(null);
-    for (const [sectionName, spec] of Object.entries(sectionsValue ?? {})) {
-        const parsed = parseSection(names, `${location}.sections.${sectionName}`, spec);
-        if ('rule' in parsed)
-            return parsed;
-        sections[sectionName] = parsed;
+    for (const [name, spec] of Object.entries(value)) {
+        const where = `${at}/${escapePointer(name)}`;
+        if (!isRecord(spec) || (spec.kind !== 'text' && spec.kind !== 'list'))
+            return failed('sections', where);
+        const allowed = spec.kind === 'list' ? ['kind', 'required', 'items'] : ['kind', 'required'];
+        const extra = Object.keys(spec).find((key) => !allowed.includes(key));
+        if (extra !== undefined)
+            return failed('sections', `${where}/${escapePointer(extra)}`);
+        if (spec.required !== undefined && typeof spec.required !== 'boolean')
+            return failed('sections', `${where}/required`);
+        const required = spec.required === true;
+        if (spec.kind === 'text') {
+            sections[name] = { kind: 'text', required };
+            continue;
+        }
+        if (spec.items === undefined)
+            return failed('sections', `${where}/items`);
+        const failure = schemaFailure(spec.items, `${where}/items`, context);
+        if (failure !== undefined)
+            return { failure };
+        const items = valueFacts(spec.items, context.defs);
+        if (items.type === undefined || !SCALAR_TYPES.has(items.type))
+            return failed('sections', `${where}/items`);
+        sections[name] = { kind: 'list', required, items };
     }
-    return { name, memberDocument: mark, fields, sections };
+    return { sections };
 }
-function freezeSpec(spec) {
-    if (spec.kind === 'list')
-        freezeSpec(spec.of);
-    if (spec.kind === 'enum')
-        Object.freeze(spec.values);
-    Object.freeze(spec);
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const held of Object.values(value))
+            deepFreeze(held);
+    }
+    return value;
+}
+function ruleValue(value) {
+    return value === null || typeof value === 'string' || typeof value === 'boolean' || finite(value);
+}
+function roleNames(value) {
+    return strings(value) && value.every((name) => name !== '');
+}
+function compositesOf(value) {
+    return Array.isArray(value) ? ['array'] : isRecord(value) ? ['object'] : [];
+}
+function typed(type) {
+    const types = typeof type === 'string' ? [type] : type;
+    return Array.isArray(types) ? COMPOSITES.filter((kind) => types.includes(kind)) : undefined;
+}
+function admittedWhole(node) {
+    if (node === true)
+        return COMPOSITES;
+    if (!isRecord(node) || Object.keys(node).some((key) => key !== 'type' && !ANNOTATIONS.has(key)))
+        return [];
+    return typed(node.type) ?? COMPOSITES;
+}
+function composites(node, defs, seen) {
+    if (node === false)
+        return [];
+    if (!isRecord(node))
+        return COMPOSITES;
+    const each = (nodes) => Array.isArray(nodes) ? nodes.map((one) => composites(one, defs, seen)) : [];
+    const target = typeof node.$ref === 'string' ? refTarget(node.$ref, defs)?.node : undefined;
+    const conditioned = () => {
+        const met = composites(node.then ?? true, defs, seen);
+        return COMPOSITES.filter((kind) => (composites(node.if, defs, seen).includes(kind) && met.includes(kind)) ||
+            composites(node.else ?? true, defs, seen).includes(kind));
+    };
+    const bounds = [
+        typed(node.type),
+        Array.isArray(node.enum) ? node.enum.flatMap(compositesOf) : undefined,
+        Object.hasOwn(node, 'const') ? compositesOf(node.const) : undefined,
+        target === undefined || seen.has(target)
+            ? undefined
+            : composites(target, defs, new Set([...seen, target])),
+        ...each(node.allOf),
+        ...[node.anyOf, node.oneOf].filter(Array.isArray).map((branches) => each(branches).flat()),
+        Object.hasOwn(node, 'if') ? conditioned() : undefined,
+        Object.hasOwn(node, 'not')
+            ? COMPOSITES.filter((kind) => !admittedWhole(node.not).includes(kind))
+            : undefined,
+    ];
+    return COMPOSITES.filter((kind) => bounds.every((bound) => bound?.includes(kind) ?? true));
+}
+function transitionOf(value) {
+    if (!isRecord(value) || !Object.hasOwn(value, 'from') || !Object.hasOwn(value, 'to'))
+        return undefined;
+    const { from, to, roles, ...rest } = value;
+    if (Object.keys(rest).length > 0 || !ruleValue(from) || !ruleValue(to))
+        return undefined;
+    if (roles === undefined)
+        return { from, to };
+    return roleNames(roles) ? { from, to, roles } : undefined;
+}
+function fieldRules(written, field, at, defs) {
+    const { change_roles: changeRoles, initial_roles: initialRoles, transitions } = written;
+    if (changeRoles !== undefined && !roleNames(changeRoles))
+        return refuse('change_roles', `${at}/change_roles`);
+    if (initialRoles !== undefined && !roleNames(initialRoles))
+        return refuse('initial_roles', `${at}/initial_roles`);
+    if (transitions === undefined)
+        return {
+            ...(changeRoles === undefined ? {} : { changeRoles }),
+            ...(initialRoles === undefined ? {} : { initialRoles }),
+        };
+    if (!Array.isArray(transitions) || composites(field, defs, new Set()).length > 0)
+        return refuse('transitions', `${at}/transitions`);
+    const listed = [];
+    for (const [index, held] of transitions.entries()) {
+        const transition = transitionOf(held);
+        if (transition === undefined)
+            return refuse('transitions', `${at}/transitions/${index}`);
+        listed.push(transition);
+    }
+    return {
+        ...(changeRoles === undefined ? {} : { changeRoles }),
+        ...(initialRoles === undefined ? {} : { initialRoles }),
+        transitions: listed,
+    };
+}
+function unruled(schema) {
+    const written = new Map();
+    if (!isRecord(schema.properties))
+        return { schema, written };
+    const properties = Object.create(null);
+    for (const [field, node] of Object.entries(schema.properties)) {
+        if (!isRecord(node) || !FIELD_RULES.some((keyword) => Object.hasOwn(node, keyword))) {
+            properties[field] = node;
+            continue;
+        }
+        written.set(field, node);
+        properties[field] = Object.fromEntries(Object.entries(node).filter(([keyword]) => !FIELD_RULES.includes(keyword)));
+    }
+    return { schema: written.size === 0 ? schema : { ...schema, properties }, written };
+}
+function readType(name, value, context) {
+    const at = `/${escapePointer(name)}`;
+    if (!isRecord(value))
+        return refuse('schema', at);
+    const { sections: declared, member_document: mark, create_roles: createRoles, delete_roles: deleteRoles, ...ruled } = value;
+    if (mark !== undefined && typeof mark !== 'boolean')
+        return refuse('member_document', `${at}/member_document`);
+    if (createRoles !== undefined && !roleNames(createRoles))
+        return refuse('create_roles', `${at}/create_roles`);
+    if (deleteRoles !== undefined && !roleNames(deleteRoles))
+        return refuse('delete_roles', `${at}/delete_roles`);
+    const read = declared === undefined
+        ? { sections: Object.create(null) }
+        : readSections(declared, `${at}/sections`, context);
+    if ('failure' in read)
+        return read.failure;
+    const { schema, written } = unruled(ruled);
+    const failure = schemaFailure(schema, at, context);
+    if (failure !== undefined)
+        return failure;
+    const rules = Object.create(null);
+    for (const [field, keywords] of written) {
+        const properties = schema.properties;
+        const where = `${at}/properties/${escapePointer(field)}`;
+        const ruling = fieldRules(keywords, properties[field], where, context.defs);
+        if ('rule' in ruling)
+            return ruling;
+        rules[field] = ruling;
+    }
+    const memberDocument = mark === true;
+    const root = valueFacts(schema, context.defs);
+    const fields = Object.assign(Object.create(null), root.properties);
+    if (memberDocument && !Object.hasOwn(fields, MEMBER_FIELD))
+        fields[MEMBER_FIELD] = { type: 'string', prose: false };
+    const defs = Object.create(null);
+    reachedDefs(value, context.defs, defs);
+    const { create_roles: _create, delete_roles: _delete, ...shaped } = value;
+    return {
+        name,
+        memberDocument,
+        frontmatter: { ...root, properties: { ...HOUSE_KEYS, ...fields } },
+        fields,
+        sections: read.sections,
+        rules,
+        ...(createRoles === undefined ? {} : { createRoles }),
+        ...(deleteRoles === undefined ? {} : { deleteRoles }),
+        shape: {
+            schema: written.size === 0 ? shaped : { ...shaped, properties: schema.properties },
+            defs,
+        },
+    };
 }
 function lineAt(text, offset) {
     return text.slice(0, offset).split(/\r\n|\r|\n/).length;
@@ -147,34 +714,32 @@ export function readSchema(text) {
             return refuse('schema-yaml', `line ${lineAt(text, error.offset)}`);
         throw error;
     }
-    const schema = root;
-    for (const key of Object.keys(schema)) {
-        if (key !== 'types')
-            return refuse('schema-shape', key);
+    const defs = root.$defs ?? Object.create(null);
+    if (!isRecord(defs))
+        return refuse('$defs', '/$defs');
+    const names = Object.keys(root).filter((key) => key !== '$defs');
+    for (const name of names) {
+        if (name === '' || name.startsWith('$') || name === BUILT_IN_TYPE || name === ATTACHMENT)
+            return refuse('schema-type-name', `/${escapePointer(name)}`);
+    }
+    const context = { defs, types: new Set(names) };
+    for (const [name, def] of Object.entries(defs)) {
+        const failure = schemaFailure(def, `/$defs/${escapePointer(name)}`, context);
+        if (failure !== undefined)
+            return failure;
     }
-    if (!isRecord(schema.types))
-        return refuse('schema-shape', 'types');
-    const names = new Set(Object.keys(schema.types));
-    if (names.has(''))
-        return refuse('schema-shape', 'types');
     const types = Object.create(null);
     let marked = false;
-    for (const [name, value] of Object.entries(schema.types)) {
-        const definition = readType(names, name, value);
+    for (const name of names) {
+        const definition = readType(name, root[name], context);
         if ('rule' in definition)
             return definition;
         if (definition.memberDocument) {
             if (marked)
-                return refuse('schema-member-document', `types.${name}.member_document`);
+                return refuse('member_document', `/${escapePointer(name)}/member_document`);
             marked = true;
         }
-        for (const spec of Object.values(definition.fields))
-            freezeSpec(spec);
-        for (const spec of Object.values(definition.sections))
-            freezeSpec(spec);
-        Object.freeze(definition.fields);
-        Object.freeze(definition.sections);
-        types[name] = Object.freeze(definition);
+        types[name] = deepFreeze(definition);
     }
     return Object.freeze({ types: Object.freeze(types) });
 }