@agentshouse/mdmodel 0.1.0-ccf1367190878 → 0.1.0-cd90851746292

package/dist/pattern.js

@@ -0,0 +1,355 @@
+const NativeRegExp = RegExp;
+export const PATTERN_STATES = 1_000;
+const VISIT_BUDGET = 100_000_000;
+const HELD_PATTERNS = 512;
+export class PatternTooCostly extends Error {
+}
+let scope = null;
+const ASCII = 128;
+class Unsupported extends Error {
+}
+const ATOM = 0;
+const SPLIT = 1;
+const ASSERT = 2;
+const MATCH = 3;
+class Atom {
+    literal;
+    ascii = new Int8Array(ASCII);
+    matcher;
+    constructor(source, literal) {
+        this.literal = literal;
+        this.matcher = new NativeRegExp(`^(?:${source})$`, 'u');
+    }
+    holds(point) {
+        if (this.literal !== null)
+            return point === this.literal;
+        if (point >= ASCII)
+            return this.matcher.test(String.fromCodePoint(point));
+        const known = this.ascii[point];
+        if (known !== 0)
+            return known > 0;
+        const held = this.matcher.test(String.fromCharCode(point));
+        this.ascii[point] = held ? 1 : -1;
+        return held;
+    }
+}
+class Reader {
+    source;
+    at = 0;
+    constructor(source) {
+        this.source = source;
+    }
+    peek(offset = 0) {
+        return this.source[this.at + offset];
+    }
+    starts(text) {
+        return this.source.startsWith(text, this.at);
+    }
+}
+function digits(reader) {
+    const from = reader.at;
+    while (/[0-9]/.test(reader.peek() ?? ''))
+        reader.at += 1;
+    return reader.at === from ? null : Number(reader.source.slice(from, reader.at));
+}
+function escapeEnd(source, at) {
+    const next = source[at + 1];
+    if (next === 'c')
+        return at + 3;
+    if (next === 'x')
+        return at + 4;
+    if ((next === 'u' && source[at + 2] === '{') || next === 'p' || next === 'P')
+        return source.indexOf('}', at + 2) + 1;
+    if (next !== 'u')
+        return at + 2;
+    const end = at + 6;
+    const lead = Number.parseInt(source.slice(at + 2, end), 16);
+    const trail = /^\\u([0-9a-fA-F]{4})$/.exec(source.slice(end, end + 6))?.[1];
+    const paired = lead >= 0xd800 &&
+        lead <= 0xdbff &&
+        trail !== undefined &&
+        Number.parseInt(trail, 16) >= 0xdc00 &&
+        Number.parseInt(trail, 16) <= 0xdfff;
+    return paired ? end + 6 : end;
+}
+function classEnd(source, at) {
+    let i = at + 1;
+    while (source[i] !== ']')
+        i += source[i] === '\\' ? 2 : 1;
+    return i + 1;
+}
+function escaped(reader) {
+    const next = reader.peek(1);
+    if (next === 'b' || next === 'B') {
+        reader.at += 2;
+        return { kind: 'assert', assertion: next === 'b' ? 'boundary' : 'inside' };
+    }
+    if (/[1-9k]/.test(next))
+        throw new Unsupported();
+    const end = escapeEnd(reader.source, reader.at);
+    const source = reader.source.slice(reader.at, end);
+    reader.at = end;
+    return { kind: 'atom', source, literal: false };
+}
+function group(reader) {
+    reader.at += 1;
+    if (reader.starts('?:'))
+        reader.at += 2;
+    else if (reader.starts('?<') && !reader.starts('?<=') && !reader.starts('?<!'))
+        reader.at = reader.source.indexOf('>', reader.at) + 1;
+    else if (reader.peek() === '?')
+        throw new Unsupported();
+    const alternatives = disjunction(reader);
+    reader.at += 1;
+    return { kind: 'group', alternatives };
+}
+function atom(reader) {
+    const character = reader.peek();
+    if (character === '^' || character === '$') {
+        reader.at += 1;
+        return { kind: 'assert', assertion: character === '^' ? 'start' : 'end' };
+    }
+    if (character === '\\')
+        return escaped(reader);
+    if (character === '(')
+        return group(reader);
+    if (character === '[' || character === '.') {
+        const end = character === '[' ? classEnd(reader.source, reader.at) : reader.at + 1;
+        const source = reader.source.slice(reader.at, end);
+        reader.at = end;
+        return { kind: 'atom', source, literal: false };
+    }
+    const source = String.fromCodePoint(reader.source.codePointAt(reader.at));
+    reader.at += source.length;
+    return { kind: 'atom', source, literal: true };
+}
+function quantified(reader, node) {
+    const sign = reader.peek();
+    let least = 1;
+    let most = 1;
+    if (sign === '*' || sign === '+' || sign === '?') {
+        reader.at += 1;
+        least = sign === '+' ? 1 : 0;
+        most = sign === '?' ? 1 : Infinity;
+    }
+    else if (sign === '{') {
+        reader.at += 1;
+        least = digits(reader);
+        most = least;
+        if (reader.peek() === ',') {
+            reader.at += 1;
+            most = digits(reader) ?? Infinity;
+        }
+        reader.at += 1;
+    }
+    else
+        return { node, least, most };
+    if (reader.peek() === '?')
+        reader.at += 1;
+    if (least > PATTERN_STATES || (Number.isFinite(most) && most > PATTERN_STATES))
+        throw new Unsupported();
+    return { node, least, most };
+}
+function disjunction(reader) {
+    const alternatives = [[]];
+    while (reader.at < reader.source.length && reader.peek() !== ')') {
+        if (reader.peek() === '|') {
+            reader.at += 1;
+            alternatives.push([]);
+            continue;
+        }
+        alternatives.at(-1).push(quantified(reader, atom(reader)));
+    }
+    return alternatives;
+}
+class Machine {
+    kinds = [];
+    outs = [];
+    alternates = [];
+    atoms = [];
+    assertions = [];
+    atomed = new Map();
+    state(kind, out, alternate = -1) {
+        if (this.kinds.length >= PATTERN_STATES)
+            throw new Unsupported();
+        this.kinds.push(kind);
+        this.outs.push(out);
+        this.alternates.push(alternate);
+        return this.kinds.length - 1;
+    }
+    atom(source, literal) {
+        const known = this.atomed.get(source);
+        if (known !== undefined)
+            return known;
+        this.atoms.push(new Atom(source, literal ? source.codePointAt(0) : null));
+        this.atomed.set(source, this.atoms.length - 1);
+        return this.atoms.length - 1;
+    }
+    node(node, next) {
+        if (node.kind === 'atom')
+            return this.state(ATOM, next, this.atom(node.source, node.literal));
+        if (node.kind === 'assert') {
+            this.assertions.push(node.assertion);
+            return this.state(ASSERT, next, this.assertions.length - 1);
+        }
+        return this.alternatives(node.alternatives, next);
+    }
+    alternatives(alternatives, next) {
+        let entry = this.sequence(alternatives.at(-1), next);
+        for (let index = alternatives.length - 2; index >= 0; index -= 1)
+            entry = this.state(SPLIT, this.sequence(alternatives[index], next), entry);
+        return entry;
+    }
+    sequence(terms, next) {
+        let entry = next;
+        for (let index = terms.length - 1; index >= 0; index -= 1)
+            entry = this.term(terms[index], entry);
+        return entry;
+    }
+    term({ node, least, most }, next) {
+        if (least === 1 && most === 1)
+            return this.node(node, next);
+        let entry = next;
+        if (most === Infinity) {
+            const loop = this.state(SPLIT, -1, next);
+            const body = this.node(node, loop);
+            if (body === loop)
+                return next;
+            this.outs[loop] = body;
+            entry = loop;
+        }
+        else
+            for (let copy = least; copy < most; copy += 1) {
+                const body = this.node(node, entry);
+                if (body === entry)
+                    return next;
+                entry = this.state(SPLIT, body, entry);
+            }
+        for (let copy = 0; copy < least; copy += 1) {
+            const body = this.node(node, entry);
+            if (body === entry)
+                return next;
+            entry = body;
+        }
+        return entry;
+    }
+}
+function word(point) {
+    return ((point >= 0x30 && point <= 0x39) ||
+        (point >= 0x41 && point <= 0x5a) ||
+        (point >= 0x61 && point <= 0x7a) ||
+        point === 0x5f);
+}
+function holds(assertion, at, point, across) {
+    if (assertion === 'start')
+        return at === 0;
+    if (assertion === 'end')
+        return point === -1;
+    return assertion === 'boundary' ? across : !across;
+}
+class Linear {
+    machine;
+    start;
+    marks;
+    generation = 0;
+    constructor(machine, start) {
+        this.machine = machine;
+        this.start = start;
+        this.marks = new Float64Array(machine.kinds.length);
+    }
+    test(text) {
+        const { kinds, outs, alternates, atoms, assertions } = this.machine;
+        const marks = this.marks;
+        const budget = scope ?? { left: VISIT_BUDGET };
+        let seeds = [];
+        let previous = -1;
+        for (let at = 0;;) {
+            const point = at < text.length ? text.codePointAt(at) : -1;
+            const across = word(previous) !== word(point);
+            const generation = (this.generation += 1);
+            const active = [];
+            seeds.push(this.start);
+            while (seeds.length > 0) {
+                const state = seeds.pop();
+                if (marks[state] === generation)
+                    continue;
+                marks[state] = generation;
+                if ((budget.left -= 1) < 0)
+                    throw new PatternTooCostly();
+                const kind = kinds[state];
+                if (kind === MATCH)
+                    return true;
+                if (kind === ATOM)
+                    active.push(state);
+                else if (kind === SPLIT)
+                    seeds.push(alternates[state], outs[state]);
+                else if (holds(assertions[alternates[state]], at, point, across))
+                    seeds.push(outs[state]);
+            }
+            if (point === -1)
+                return false;
+            for (const state of active)
+                if (atoms[alternates[state]].holds(point))
+                    seeds.push(outs[state]);
+            previous = point;
+            at += point > 0xffff ? 2 : 1;
+        }
+    }
+}
+function compiled(source) {
+    try {
+        new NativeRegExp(source, 'u');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const alternatives = disjunction(new Reader(source));
+        const machine = new Machine();
+        const start = machine.alternatives(alternatives, machine.state(MATCH, -1));
+        return new Linear(machine, start);
+    }
+    catch (error) {
+        if (error instanceof Unsupported)
+            return null;
+        throw error;
+    }
+}
+const held = new Map();
+export function linearPattern(source) {
+    if (held.has(source))
+        return held.get(source);
+    const made = compiled(source);
+    if (held.size >= HELD_PATTERNS)
+        held.delete(held.keys().next().value);
+    held.set(source, made);
+    return made;
+}
+export function withLinearRegExp(run) {
+    const native = globalThis.RegExp;
+    function LinearRegExp(source) {
+        new NativeRegExp(source, 'u');
+        return {
+            test(text) {
+                const pattern = linearPattern(source);
+                if (pattern === null)
+                    throw new SyntaxError(`the pattern ${source} is not linear`);
+                return pattern.test(text);
+            },
+        };
+    }
+    globalThis.RegExp = LinearRegExp;
+    try {
+        return run();
+    }
+    finally {
+        globalThis.RegExp = native;
+    }
+}
+export function openPatternBudget() {
+    const outer = scope;
+    scope = outer ?? { left: VISIT_BUDGET };
+    return () => {
+        scope = outer;
+    };
+}

package/dist/project.d.ts

@@ -15,6 +15,7 @@ export type InputResult = {
     readonly ok: false;
     readonly refusal: Refusal;
 };
+export declare function firstEditFrom(edits: readonly Edit[], start: number): number;
 export declare function rangeText(content: string, range: Extent, edits: readonly Edit[]): string;
 export declare function projectionInput(document: Document, file: string, context: ProjectionContext): InputResult;
 export declare function project(document: Document, file: string, context?: ProjectionContext): Projection;

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG3F,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC;AAEzB,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAC5C;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAmCtD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,CASxF;AA4BD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,GACzB,WAAW,CAyBb;AAED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAA2C,GACnD,UAAU,CAMZ"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG3F,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC;AAEzB,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAC5C;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AA0CtD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAS3E;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,CAWxF;AA4BD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,GACzB,WAAW,CA+Bb;AAED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAA2C,GACnD,UAAU,CAMZ"}

package/dist/project.js

@@ -1,24 +1,32 @@
 import { memberFacts } from './definition.js';
-import { frontmatter } from './document.js';
-import { linkInventory } from './links.js';
-import { target } from './paths.js';
+import { frontmatter, inventoryOf } from './document.js';
+import { roomTarget, target } from './paths.js';
 import { refusal } from './refuse.js';
 import { headingSpans } from './sections.js';
 import { bodyStartOf } from './yaml.js';
-function internalEdits(content, bodyStart, file, documentTargets) {
-    const inventory = linkInventory(content.slice(bodyStart));
+function internalEdits(content, inventory, bodyStart, file, documentTargets) {
     const internal = new Set();
-    const edits = [];
-    const uses = [...inventory.uses].sort((left, right) => left.end - left.start - (right.end - right.start));
-    for (const use of uses) {
+    const uses = inventory.uses
+        .filter((use) => {
         const resolved = target(file, use.destination.href);
-        if (resolved === null || !documentTargets.has(resolved))
-            continue;
+        return resolved === null
+            ? roomTarget(use.destination.href) !== null
+            : documentTargets.has(resolved);
+    })
+        .sort((left, right) => left.start - right.start);
+    const edits = [];
+    for (let index = uses.length - 1; index >= 0; index -= 1) {
+        const use = uses[index];
         internal.add(use.destination.start);
         const label = { start: bodyStart + use.labelStart, end: bodyStart + use.labelEnd };
-        const inner = edits
-            .filter((edit) => edit.start >= label.start && edit.end <= label.end)
-            .sort((left, right) => left.start - right.start);
+        const inner = [];
+        for (let nested = index + 1; nested < uses.length; nested += 1) {
+            const edit = edits[uses.length - 1 - nested];
+            if (edit.start >= label.end)
+                break;
+            if (edit.start >= label.start && edit.end <= label.end)
+                inner.push(edit);
+        }
         edits.push({
             start: bodyStart + use.start,
             end: bodyStart + use.end,
@@ -32,10 +40,25 @@ function internalEdits(content, bodyStart, file, documentTargets) {
     }
     return edits.sort((left, right) => left.start - right.start);
 }
+export function firstEditFrom(edits, start) {
+    let low = 0;
+    let high = edits.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (edits[middle].start < start)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
 export function rangeText(content, range, edits) {
     let text = '';
     let cursor = range.start;
-    for (const edit of edits) {
+    for (let index = firstEditFrom(edits, range.start); index < edits.length; index += 1) {
+        const edit = edits[index];
+        if (edit.start > range.end)
+            break;
         if (edit.start < cursor || edit.end > range.end)
             continue;
         text += content.slice(cursor, edit.start) + edit.text;
@@ -73,7 +96,7 @@ function freeTextValues(definition, document) {
 export function projectionInput(document, file, context) {
     const content = document.content;
     const bodyStart = bodyStartOf(content);
-    const edits = internalEdits(content, bodyStart, file, new Set(context.documentTargets));
+    const edits = internalEdits(content, inventoryOf(document), bodyStart, file, new Set(context.documentTargets));
     const declared = document.type;
     if (declared === undefined || declared === 'any') {
         return {

package/dist/references.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../src/references.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAwBzD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EACrC,UAAU,EAAE,UAAU,GACrB,SAAS,SAAS,EAAE,CAItB"}
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../src/references.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA8BzD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EACrC,UAAU,EAAE,UAAU,GACrB,SAAS,SAAS,EAAE,CAItB"}

package/dist/references.js

@@ -5,7 +5,12 @@ function collect(value, facts, pointer, found) {
         return;
     if (typeof value === 'string') {
         if (facts.reference !== undefined)
-            found.push({ pointer, value, to: facts.reference });
+            found.push({
+                pointer,
+                value,
+                to: facts.reference,
+                ...(facts.crossRoom === true ? { crossRoom: true } : {}),
+            });
         return;
     }
     if (Array.isArray(value)) {

package/dist/schema.d.ts

@@ -4,5 +4,6 @@ export type SchemaRefusal = {
     readonly location: string;
 };
 export declare function frontmatterRefusal(definition: Definition, fields: Readonly<Record<string, unknown>>): SchemaRefusal | undefined;
+export declare function conditionedSections(definition: Definition, fields: Readonly<Record<string, unknown>>): readonly string[];
 export declare function fitsItem(definition: Definition, section: string, text: string): boolean;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAS5E,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AA2KjF,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,aAAa,GAAG,SAAS,CAG3B;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMvF"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA0B5E,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AA6NjF,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,aAAa,GAAG,SAAS,CAI3B;AAYD,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,SAAS,MAAM,EAAE,CAGnB;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMvF"}

package/dist/schema.js

@@ -1,6 +1,7 @@
 import { Validator } from '@cfworker/json-schema';
 import { escapePointer, refTarget } from './definition.js';
 import { MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD, TYPE_FIELD } from './fields.js';
+import { withLinearRegExp } from './pattern.js';
 import { interpretPlain, isRecord } from './yaml.js';
 const STANDING_MAPS = ['properties', 'patternProperties'];
 const STANDING = [
@@ -95,10 +96,49 @@ function closed(node, inPlace, defs, always = false) {
 function copied(value) {
     return JSON.parse(JSON.stringify(value));
 }
+function asks(asked) {
+    return asked.sections.length > 0 || asked.conditions.length > 0;
+}
+function branchOf(node, defs, closedDefs) {
+    if (!isRecord(node))
+        return { schema: node, asked: { sections: [], conditions: [] } };
+    const { sections, ...rest } = node;
+    const read = unconditioned(rest, defs, closedDefs);
+    const required = Object.entries(isRecord(sections) ? sections : {}).flatMap(([name, spec]) => isRecord(spec) && spec.required === true ? [name] : []);
+    return { schema: read.schema, asked: { sections: required, conditions: read.conditions } };
+}
+function unconditioned(node, defs, closedDefs) {
+    if (!isRecord(node))
+        return { schema: node, conditions: [] };
+    const schema = { ...node };
+    const conditions = [];
+    if (Array.isArray(node.allOf))
+        schema.allOf = node.allOf.map((entry) => {
+            const read = unconditioned(entry, defs, closedDefs);
+            conditions.push(...read.conditions);
+            return read.schema;
+        });
+    if (node.if === undefined)
+        return { schema, conditions };
+    const met = branchOf(node.then, defs, closedDefs);
+    const unmet = branchOf(node.else, defs, closedDefs);
+    if (node.then !== undefined)
+        schema.then = met.schema;
+    if (node.else !== undefined)
+        schema.else = unmet.schema;
+    if (!asks(met.asked) && !asks(unmet.asked))
+        return { schema, conditions };
+    const test = new Validator(isRecord(node.if)
+        ? { ...closed(node.if, true, defs), $defs: closedDefs }
+        : node.if === true, '2020-12', false);
+    return { schema, conditions: [...conditions, { test, met: met.asked, unmet: unmet.asked }] };
+}
 function compile(definition) {
     const defs = copied(definition.shape.defs);
-    const { sections, member_document: _mark, ...root } = copied(definition.shape.schema);
+    const { sections, member_document: _mark, ...written } = copied(definition.shape.schema);
     const closedDefs = mapped(defs, (held) => closed(held, true, defs));
+    const read = unconditioned(written, defs, closedDefs);
+    const root = read.schema;
     const declared = isRecord(root.properties) ? root.properties : {};
     const properties = {
         [TYPE_FIELD]: true,
@@ -114,7 +154,7 @@ function compile(definition) {
             continue;
         lists.set(name, new Validator({ ...closed(spec.items, false, defs), $defs: closedDefs }, '2020-12', false));
     }
-    return { frontmatter, sections: lists };
+    return { frontmatter, sections: lists, conditions: read.conditions };
 }
 function compiledOf(definition) {
     const held = compiled.get(definition);
@@ -150,14 +190,25 @@ function refusalOf(errors) {
     return { rule: 'schema', location: '' };
 }
 export function frontmatterRefusal(definition, fields) {
-    const result = compiledOf(definition).frontmatter.validate(fields);
+    const { frontmatter } = compiledOf(definition);
+    const result = withLinearRegExp(() => frontmatter.validate(fields));
     return result.valid ? undefined : refusalOf(result.errors);
 }
+function askedOf(conditions, fields) {
+    return conditions.flatMap((condition) => {
+        const asked = condition.test.validate(fields).valid ? condition.met : condition.unmet;
+        return [...asked.sections, ...askedOf(asked.conditions, fields)];
+    });
+}
+export function conditionedSections(definition, fields) {
+    const { conditions } = compiledOf(definition);
+    return withLinearRegExp(() => askedOf(conditions, fields));
+}
 export function fitsItem(definition, section, text) {
     const spec = definition.sections[section];
     const validator = compiledOf(definition).sections.get(section);
     if (spec?.kind !== 'list' || validator === undefined)
         return false;
     const typed = spec.items.type === 'string' ? text : interpretPlain(text);
-    return validator.validate(typed).valid;
+    return withLinearRegExp(() => validator.validate(typed).valid);
 }

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import type { Definition } from './definition.js';
 export type Library = Readonly<Record<string, string>>;
 export type VerifiedModel = {
     readonly types: Readonly<Record<string, Definition>>;
+    readonly nameable?: readonly string[];
 };
 export type ModelVerification = {
     readonly verdict: 'accept';
@@ -13,13 +14,14 @@ export type ModelVerification = {
 };
 export type ValidationContext = {
     readonly binaryTargets: readonly string[];
+    readonly anyRoom?: true;
 };
 export type ProjectionContext = {
     readonly documentTargets: readonly string[];
     readonly definition?: Definition;
 };
 export type DivisionContext = ProjectionContext & {
-    readonly budget: number;
+    readonly bound: number;
 };
 export type Extent = {
     readonly start: number;
@@ -60,6 +62,10 @@ export type Validation = {
 } | ({
     readonly verdict: 'refuse';
 } & Refusal);
+export type ValidationStep = {
+    readonly path: string;
+    readonly resolved: number;
+};
 export type Projection = {
     readonly ok: true;
     readonly text: string;
@@ -92,14 +98,31 @@ export type Link = {
     readonly href: string;
     readonly target: string;
 };
-export type LinkOccurrence = Link & {
-    readonly start: number;
-};
 export type Reference = {
     readonly pointer: string;
     readonly value: string;
     readonly to: readonly string[];
+    readonly crossRoom?: true;
 };
+export type RoomReference = {
+    readonly handle: string;
+    readonly path: string;
+} & ({
+    readonly kind: 'link';
+    readonly href: string;
+} | {
+    readonly kind: 'field';
+    readonly pointer: string;
+    readonly value: string;
+    readonly to: readonly string[];
+    readonly crossRoom?: true;
+} | {
+    readonly kind: 'item';
+    readonly section: string;
+    readonly href: string;
+    readonly to: readonly string[];
+    readonly crossRoom?: true;
+});
 export type Change = {
     readonly kind: 'field';
     readonly name: string;
@@ -130,6 +153,7 @@ export type ApplyResult = {
 } | {
     readonly outcome: 'stale';
     readonly document: Document;
+    readonly stale: readonly number[];
 } | {
     readonly outcome: 'refuse';
     readonly refusal: Refusal;