@agentshouse/mdmodel 0.1.0-c64dbada0730d → 0.1.0-c679f403bf3fb

package/dist/document.js

@@ -1,11 +1,20 @@
 import { ARRAY_INDEX, pointerSegments } from './definition.js';
-import { hrefOccurrences } from './links.js';
-import { relative, retarget, SHELL_ROOMS, shellTarget, target } from './paths.js';
+import { destinations, hrefOccurrences, linkInventory, } from './links.js';
+import { destinationPath, relative, retarget, roomPath, roomTarget, SHELL_ROOMS, shellTarget, target, } from './paths.js';
 import { references } from './references.js';
 import { headingSpans, sectionsRecord } from './sections.js';
 import { refusal } from './refuse.js';
-import { bodyStartAfterYaml, bodyStartOf, equalValue, extractFrontmatter, jsValue, lineEnding, mapEntry, parseYamlMapping, serializeJs, serializeKey, YamlError, } from './yaml.js';
+import { bodyStartAfterYaml, bodyStartOf, equalValue, extractFrontmatter, frontmatterValue, jsValue, lineEnding, mapEntry, parseYamlMapping, serializeJs, serializeKey, YamlError, } from './yaml.js';
 const internals = new WeakMap();
+const inventories = new WeakMap();
+export function inventoryOf(document) {
+    const held = inventories.get(document);
+    if (held !== undefined)
+        return held;
+    const inventory = linkInventory(document.content.slice(bodyStartOf(document.content)));
+    inventories.set(document, inventory);
+    return inventory;
+}
 function refuse(file, rule, location) {
     return location === undefined ? refusal(file, rule) : refusal(file, rule, { location });
 }
@@ -28,19 +37,10 @@ function declaredType(fields) {
         return undefined;
     return value;
 }
-export function parse(content, file = '') {
+function opened(content, file) {
     const fence = extractFrontmatter(content);
-    if (fence.kind === 'none') {
-        const spans = headingSpans(content, 0);
-        return {
-            ok: true,
-            document: freezeDocument(content, undefined, {}, content.slice(0, spans[0]?.headingStart), sectionsRecord(spans, content), {
-                root: null,
-                yamlEnd: 0,
-                bodyStart: 0,
-            }),
-        };
-    }
+    if (fence.kind === 'none')
+        return { ok: true, root: null, fields: {}, yamlEnd: 0 };
     if (fence.kind === 'unclosed')
         return { ok: false, refusal: refuse(file, 'frontmatter-fence') };
     try {
@@ -49,17 +49,7 @@ export function parse(content, file = '') {
         if (fields === null || typeof fields !== 'object' || Array.isArray(fields)) {
             return { ok: false, refusal: refuse(file, 'frontmatter-fence') };
         }
-        const bodyStart = bodyStartAfterYaml(content, fence.yamlEnd);
-        const spans = headingSpans(content, bodyStart);
-        const record = fields;
-        return {
-            ok: true,
-            document: freezeDocument(content, declaredType(record), record, content.slice(bodyStart, spans[0]?.headingStart), sectionsRecord(spans, content), {
-                root,
-                yamlEnd: fence.yamlEnd,
-                bodyStart,
-            }),
-        };
+        return { ok: true, root, fields: fields, yamlEnd: fence.yamlEnd };
     }
     catch (error) {
         if (error instanceof YamlError)
@@ -67,63 +57,29 @@ export function parse(content, file = '') {
         throw error;
     }
 }
-function splice(content, start, end, insert) {
-    return content.slice(0, start) + insert + content.slice(end);
+export function parseFrontmatter(content, file = '') {
+    const read = opened(content, file);
+    if (!read.ok)
+        return read;
+    return {
+        ok: true,
+        frontmatter: Object.freeze({
+            content,
+            type: declaredType(read.fields),
+            fields: Object.freeze(read.fields),
+        }),
+    };
 }
-function applyField(document, name, value, prior) {
-    const internal = internals.get(document);
-    if (internal === undefined || internal.root === null) {
-        return { outcome: 'refuse', refusal: refuse('', 'frontmatter-fence', name) };
-    }
-    if (!equalValue(document.fields[name], prior)) {
-        return { outcome: 'stale', document };
-    }
-    let nextContent;
-    const existing = mapEntry(internal.root, name);
-    if (existing !== undefined) {
-        nextContent = splice(document.content, existing.value.start, existing.value.end, serializeJs(value));
-    }
-    else if (document.content[internal.root.start] === '{') {
-        nextContent = splice(document.content, internal.root.end - 1, internal.root.end - 1, `${internal.root.entries.length === 0 ? '' : ', '}${serializeKey(name)}: ${serializeJs(value)}`);
-    }
-    else {
-        const nl = lineEnding(document.content);
-        const lineStart = document.content.lastIndexOf('\n', internal.root.start - 1) + 1;
-        const indent = document.content.slice(lineStart, internal.root.start);
-        const line = `${indent}${serializeKey(name)}: ${serializeJs(value)}${nl}`;
-        const before = document.content.slice(0, internal.yamlEnd);
-        const prefix = before.endsWith('\n') || before.endsWith('\r\n') ? '' : nl;
-        nextContent = splice(document.content, internal.yamlEnd, internal.yamlEnd, `${prefix}${line}`);
-    }
-    const parsed = parse(nextContent);
-    if (!parsed.ok)
-        return { outcome: 'refuse', refusal: parsed.refusal };
-    return { outcome: 'applied', document: parsed.document };
-}
-function applySection(document, name, value, prior) {
-    const internal = internals.get(document);
-    if (internal === undefined)
-        return { outcome: 'refuse', refusal: refuse('', 'required-section', name) };
-    const spans = headingSpans(document.content, internal.bodyStart);
-    const span = spans.find((item) => item.name === name);
-    if (span === undefined)
-        return { outcome: 'refuse', refusal: refuse('', 'required-section', name) };
-    const current = document.content.slice(span.bodyStart, span.bodyEnd);
-    if (current !== prior)
-        return { outcome: 'stale', document };
-    const parsed = parse(splice(document.content, span.bodyStart, span.bodyEnd, value));
-    if (!parsed.ok)
-        return { outcome: 'refuse', refusal: parsed.refusal };
-    return { outcome: 'applied', document: parsed.document };
-}
-function applyPreamble(document, value, prior) {
-    if (document.preamble !== prior)
-        return { outcome: 'stale', document };
-    const start = bodyStartOf(document.content);
-    const parsed = parse(splice(document.content, start, start + document.preamble.length, value));
-    if (!parsed.ok)
-        return { outcome: 'refuse', refusal: parsed.refusal };
-    return { outcome: 'applied', document: parsed.document };
+export function parse(content, file = '') {
+    const read = opened(content, file);
+    if (!read.ok)
+        return read;
+    const bodyStart = read.root === null ? 0 : bodyStartAfterYaml(content, read.yamlEnd);
+    const spans = headingSpans(content, bodyStart);
+    return {
+        ok: true,
+        document: freezeDocument(content, declaredType(read.fields), read.fields, content.slice(bodyStart, spans[0]?.headingStart), sectionsRecord(spans, content), { root: read.root, yamlEnd: read.yamlEnd, bodyStart }),
+    };
 }
 function fitsBare(to) {
     if (to === '' || to.startsWith('<'))
@@ -152,58 +108,34 @@ function destinationText(to, bracketed) {
         return `<${to}>`;
     return null;
 }
-function relinked(content, bodyStart, href, to) {
-    const written = retarget(href, to);
-    let rewritten = '';
-    let cursor = 0;
-    for (const match of hrefOccurrences(content.slice(bodyStart))) {
-        if (match.href !== href)
-            continue;
-        const text = destinationText(written, match.bracketed);
-        if (text === null)
-            return refuse('', 'unwritable-link', written);
-        rewritten += content.slice(cursor, bodyStart + match.start);
-        rewritten += text;
-        cursor = bodyStart + match.end;
-    }
-    return rewritten + content.slice(cursor);
-}
-function shellRelinked(content, bodyStart, file, handle) {
-    const hrefs = new Set(hrefOccurrences(content.slice(bodyStart)).map(({ href }) => href));
-    let held = content;
-    for (const href of hrefs) {
+function shellRelinked(body, file, handle) {
+    const occurrences = hrefOccurrences(body);
+    const written = new Map();
+    for (const href of new Set(occurrences.map((occurrence) => occurrence.href))) {
         const path = shellTarget(href, handle);
         if (path === null)
             continue;
-        const text = relinked(held, bodyStart, href, relative(file, path));
-        if (typeof text !== 'string')
-            return text;
-        held = text;
+        const to = retarget(href, relative(file, path));
+        if (destinationText(to, false) === null)
+            return refuse('', 'unwritable-link', to);
+        written.set(href, to);
     }
-    return held;
-}
-function reparsed(document, content) {
-    if (typeof content !== 'string')
-        return { outcome: 'refuse', refusal: content };
-    if (content === document.content)
-        return { outcome: 'applied', document };
-    const parsed = parse(content);
-    if (!parsed.ok)
-        return { outcome: 'refuse', refusal: parsed.refusal };
-    return { outcome: 'applied', document: parsed.document };
-}
-function applyLink(document, href, to) {
-    const content = document.content;
-    const bodyStart = bodyStartOf(content);
-    if (!hrefOccurrences(content.slice(bodyStart)).some((occurrence) => occurrence.href === href))
-        return { outcome: 'stale', document };
-    return reparsed(document, relinked(content, bodyStart, href, to));
+    let rewritten = '';
+    let cursor = 0;
+    for (const match of occurrences) {
+        const to = written.get(match.href);
+        if (to === undefined)
+            continue;
+        rewritten += body.slice(cursor, match.start) + destinationText(to, match.bracketed);
+        cursor = match.end;
+    }
+    return rewritten + body.slice(cursor);
 }
-function nodeAt(root, pointer) {
+function nodeAt(root, pointer, entryOf = mapEntry) {
     let node = root;
     for (const key of pointerSegments(pointer)) {
         if (node?.kind === 'map')
-            node = mapEntry(node, key)?.value;
+            node = entryOf(node, key)?.value;
         else if (node?.kind === 'seq' && ARRAY_INDEX.test(key))
             node = node.items[Number(key)];
         else
@@ -218,37 +150,36 @@ function scalarText(source, value) {
         return JSON.stringify(value);
     return serializeJs(value);
 }
-function applyReference(document, pointer, value, prior) {
-    const root = internals.get(document)?.root;
-    const node = root === null || root === undefined ? undefined : nodeAt(root, pointer);
-    if (node?.kind !== 'scalar' || node.value !== prior)
-        return { outcome: 'stale', document };
-    const text = scalarText(document.content[node.start], value);
-    const parsed = parse(splice(document.content, node.start, node.end, text));
-    if (!parsed.ok)
-        return { outcome: 'refuse', refusal: parsed.refusal };
-    return { outcome: 'applied', document: parsed.document };
-}
-export function relativize(document, file, handle, definition) {
-    let held = document;
+export function relativize(document, file, handle, definition, kept = new Set()) {
+    const relativized = (href) => {
+        const path = shellTarget(href, handle);
+        return path === null || kept.has(`${SHELL_ROOMS}${handle}/${path}`) ? null : path;
+    };
+    const changes = [];
     for (const { pointer, value } of definition === undefined
         ? []
         : references(document, definition)) {
-        const path = shellTarget(value, handle);
-        if (path === null)
-            continue;
-        const result = applyReference(held, pointer, retarget(value, relative(file, path)), value);
-        if (result.outcome !== 'applied')
-            return result;
-        held = result.document;
+        const path = relativized(value);
+        if (path !== null)
+            changes.push({
+                kind: 'reference',
+                pointer,
+                value: retarget(value, relative(file, path)),
+                prior: value,
+            });
+    }
+    for (const href of new Set(destinations(inventoryOf(document)).map(({ href }) => href))) {
+        const path = relativized(href);
+        if (path !== null)
+            changes.push({ kind: 'link', href, to: relative(file, path) });
     }
-    return reparsed(held, shellRelinked(held.content, bodyStartOf(held.content), file, handle));
+    return apply(document, changes);
 }
 export function relativizeBody(body, file, handle) {
-    const relinkedBody = shellRelinked(body, 0, file, handle);
+    const relinkedBody = shellRelinked(body, file, handle);
     if (typeof relinkedBody !== 'string')
         return { outcome: 'refuse', refusal: relinkedBody };
-    const elsewhere = hrefOccurrences(relinkedBody).find(({ href }) => href.startsWith(SHELL_ROOMS));
+    const elsewhere = hrefOccurrences(relinkedBody).find(({ href }) => destinationPath(href)?.startsWith(SHELL_ROOMS) === true && roomTarget(href) === null);
     if (elsewhere !== undefined)
         return { outcome: 'refuse', refusal: refuse(file, 'unresolved-link', elsewhere.href) };
     return { outcome: 'applied', body: relinkedBody };
@@ -257,11 +188,11 @@ export function relinkBody(body, file, moves) {
     let rewritten = '';
     let cursor = 0;
     for (const match of hrefOccurrences(body)) {
-        const from = target(file, match.href);
+        const from = target(file, match.href) ?? roomPath(match.href);
         const to = from === null ? undefined : moves.get(from);
         if (to === undefined)
             continue;
-        const written = retarget(match.href, relative(file, to));
+        const written = retarget(match.href, from.startsWith(SHELL_ROOMS) || to.startsWith(SHELL_ROOMS) ? to : relative(file, to));
         const text = destinationText(written, match.bracketed);
         if (text === null)
             return { outcome: 'refuse', refusal: refuse(file, 'unwritable-link', written) };
@@ -270,10 +201,10 @@ export function relinkBody(body, file, moves) {
     }
     return { outcome: 'applied', body: rewritten + body.slice(cursor) };
 }
-function linksIn(text, file) {
+function linksIn(occurrences, file) {
     const found = [];
     const seen = new Set();
-    for (const occurrence of hrefOccurrences(text)) {
+    for (const occurrence of occurrences) {
         if (seen.has(occurrence.href))
             continue;
         const resolved = target(file, occurrence.href);
@@ -285,29 +216,246 @@ function linksIn(text, file) {
     return found;
 }
 export function links(document, file) {
-    return linksIn(document.content.slice(bodyStartOf(document.content)), file);
+    return linksIn(destinations(inventoryOf(document)), file);
 }
 export function bodyLinks(body, file) {
-    return linksIn(body, file);
+    return linksIn(hrefOccurrences(body), file);
+}
+function internalOf(document) {
+    const held = internals.get(document);
+    if (held !== undefined)
+        return held;
+    const read = opened(document.content, '');
+    if (!read.ok)
+        return read.refusal;
+    return {
+        root: read.root,
+        yamlEnd: read.yamlEnd,
+        bodyStart: read.root === null ? 0 : bodyStartAfterYaml(document.content, read.yamlEnd),
+    };
 }
-export function apply(document, change) {
+function partOf(change) {
+    if (change.kind === 'field' || change.kind === 'section')
+        return `${change.kind} ${change.name}`;
     if (change.kind === 'link')
-        return applyLink(document, change.href, change.to);
+        return `link ${change.href}`;
     if (change.kind === 'reference')
-        return applyReference(document, change.pointer, change.value, change.prior);
-    if (change.kind === 'preamble')
-        return applyPreamble(document, change.value, change.prior);
-    try {
+        return `reference ${change.pointer}`;
+    return 'preamble';
+}
+function planner(document, internal) {
+    const content = document.content;
+    const keyed = new Map();
+    let spans;
+    let occurrences;
+    let ending;
+    let added = 0;
+    const entryOf = (map, key) => {
+        let index = keyed.get(map);
+        if (index === undefined) {
+            index = new Map();
+            for (const entry of map.entries)
+                if (!index.has(entry.key))
+                    index.set(entry.key, entry);
+            keyed.set(map, index);
+        }
+        return index.get(key);
+    };
+    const field = (name, value, prior, at) => {
+        const root = internal.root;
+        if (root === null)
+            return refuse('', 'frontmatter-fence', name);
+        if (!equalValue(document.fields[name], prior))
+            return 'stale';
+        if (!frontmatterValue(value))
+            return refuse('', 'frontmatter-fence', name);
+        const existing = entryOf(root, name);
+        if (existing !== undefined) {
+            const held = existing.value;
+            const inline = held.start > existing.after && !/[\r\n]/.test(content.slice(existing.after, held.start));
+            return inline
+                ? [{ start: held.start, end: held.end, text: serializeJs(value), at }]
+                : [{ start: existing.after, end: held.end, text: ` ${serializeJs(value)}`, at }];
+        }
+        const entry = `${serializeKey(name)}: ${serializeJs(value)}`;
+        added += 1;
+        if (content[root.start] === '{') {
+            const separator = root.entries.length === 0 && added === 1 ? '' : ', ';
+            return [{ start: root.end - 1, end: root.end - 1, text: `${separator}${entry}`, at }];
+        }
+        const lineStart = content.lastIndexOf('\n', root.start - 1) + 1;
+        ending ??= lineEnding(content);
+        const line = `${content.slice(lineStart, root.start)}${entry}${ending}`;
+        return [{ start: internal.yamlEnd, end: internal.yamlEnd, text: line, at, entry: true }];
+    };
+    const section = (name, value, prior, at) => {
+        if (spans === undefined) {
+            spans = new Map();
+            for (const span of headingSpans(content, internal.bodyStart))
+                if (!spans.has(span.name))
+                    spans.set(span.name, span);
+        }
+        const span = spans.get(name);
+        if (span === undefined)
+            return refuse('', 'required-section', name);
+        if (content.slice(span.bodyStart, span.bodyEnd) !== prior)
+            return 'stale';
+        return [{ start: span.bodyStart, end: span.bodyEnd, text: value, at }];
+    };
+    const link = (href, to, at) => {
+        if (occurrences === undefined) {
+            occurrences = new Map();
+            for (const occurrence of destinations(inventoryOf(document))) {
+                const same = occurrences.get(occurrence.href);
+                if (same === undefined)
+                    occurrences.set(occurrence.href, [occurrence]);
+                else
+                    same.push(occurrence);
+            }
+        }
+        const found = occurrences.get(href);
+        if (found === undefined)
+            return 'stale';
+        const written = retarget(href, to);
+        if (destinationText(written, false) === null)
+            return refuse('', 'unwritable-link', written);
+        return found.map((occurrence) => ({
+            start: internal.bodyStart + occurrence.start,
+            end: internal.bodyStart + occurrence.end,
+            text: destinationText(written, occurrence.bracketed),
+            at,
+        }));
+    };
+    const reference = (pointer, value, prior, at) => {
+        const node = internal.root === null ? undefined : nodeAt(internal.root, pointer, entryOf);
+        if (node?.kind !== 'scalar' || node.value !== prior)
+            return 'stale';
+        return [
+            { start: node.start, end: node.end, text: scalarText(content[node.start], value), at },
+        ];
+    };
+    return (change, at) => {
         if (change.kind === 'field')
-            return applyField(document, change.name, change.value, change.prior);
-        return applySection(document, change.name, change.value, change.prior);
+            return field(change.name, change.value, change.prior, at);
+        if (change.kind === 'section')
+            return section(change.name, change.value, change.prior, at);
+        if (change.kind === 'link')
+            return link(change.href, change.to, at);
+        if (change.kind === 'reference')
+            return reference(change.pointer, change.value, change.prior, at);
+        if (document.preamble !== change.prior)
+            return 'stale';
+        const start = internal.bodyStart;
+        return [{ start, end: start + document.preamble.length, text: change.value, at }];
+    };
+}
+function overlapping(edits, stale) {
+    let reach = -1;
+    let owner = -1;
+    for (const edit of edits) {
+        if (edit.start < reach)
+            stale.add(Math.max(edit.at, owner));
+        if (edit.end > reach) {
+            reach = edit.end;
+            owner = edit.at;
+        }
     }
-    catch (error) {
-        if (error instanceof YamlError) {
-            return { outcome: 'refuse', refusal: refuse('', 'frontmatter-fence', change.name) };
+}
+function firstHeadings(content, bodyStart) {
+    const first = new Map();
+    for (const span of headingSpans(content, bodyStart)) {
+        if (!first.has(span.name))
+            first.set(span.name, span.headingStart);
+    }
+    return first;
+}
+function hidden(before, bodyStart, after, shifts) {
+    const placed = firstHeadings(after, bodyStartOf(after));
+    let shift = 0;
+    let index = 0;
+    for (const [name, at] of firstHeadings(before, bodyStart)) {
+        while (index < shifts.length && shifts[index][0] <= at) {
+            shift += shifts[index][1];
+            index += 1;
         }
-        throw error;
+        if (placed.get(name) !== at + shift)
+            return name;
     }
+    return undefined;
+}
+function spliced(source, edits) {
+    const shifts = [];
+    const pieces = [];
+    let cursor = 0;
+    let entered = false;
+    let ended = false;
+    for (const edit of edits) {
+        const kept = source.slice(cursor, edit.start);
+        pieces.push(kept);
+        if (kept !== '')
+            ended = kept.endsWith('\n');
+        let text = edit.text;
+        if (edit.entry === true && !entered) {
+            entered = true;
+            if (!ended)
+                text = `${lineEnding(source)}${text}`;
+        }
+        pieces.push(text);
+        if (text !== '')
+            ended = text.endsWith('\n');
+        shifts.push([edit.start, text.length - (edit.end - edit.start)]);
+        cursor = edit.end;
+    }
+    pieces.push(source.slice(cursor));
+    return { content: pieces.join(''), shifts };
+}
+export function apply(document, changes) {
+    const internal = internalOf(document);
+    if (!('bodyStart' in internal))
+        return { outcome: 'refuse', refusal: internal };
+    const plan = planner(document, internal);
+    const edits = [];
+    const stale = new Set();
+    const named = new Set();
+    for (const [at, change] of changes.entries()) {
+        const planned = plan(change, at);
+        if (planned === 'stale') {
+            stale.add(at);
+            continue;
+        }
+        if (!Array.isArray(planned))
+            return { outcome: 'refuse', refusal: planned };
+        const part = partOf(change);
+        if (named.has(part)) {
+            stale.add(at);
+            continue;
+        }
+        named.add(part);
+        for (const edit of planned)
+            edits.push(edit);
+    }
+    edits.sort((left, right) => left.start - right.start || left.end - right.end || left.at - right.at);
+    overlapping(edits, stale);
+    if (stale.size > 0)
+        return { outcome: 'stale', document, stale: [...stale].sort((left, right) => left - right) };
+    const source = document.content;
+    const { content } = spliced(source, edits);
+    if (content === source)
+        return { outcome: 'applied', document };
+    const replaced = edits.filter((edit) => {
+        const kind = changes[edit.at].kind;
+        return kind === 'section' || kind === 'preamble';
+    });
+    if (replaced.length > 0) {
+        const checked = spliced(source, replaced);
+        const name = hidden(source, internal.bodyStart, checked.content, checked.shifts);
+        if (name !== undefined)
+            return { outcome: 'refuse', refusal: refuse('', 'overlapping-section', name) };
+    }
+    const parsed = parse(content);
+    if (!parsed.ok)
+        return { outcome: 'refuse', refusal: parsed.refusal };
+    return { outcome: 'applied', document: parsed.document };
 }
 export function serialize(document) {
     return document.content;

package/dist/fields.d.ts

@@ -1,4 +1,6 @@
+export declare const TYPE_FIELD = "type";
 export declare const MEMBER_FIELD = "member";
 export declare const SITE_FIELD = "site";
 export declare const RECEIVED_FIELD = "received";
+export declare const HOUSE_FIELDS: readonly string[];
 //# sourceMappingURL=fields.d.ts.map

package/dist/fields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC,eAAO,MAAM,UAAU,SAAS,CAAC;AAEjC,eAAO,MAAM,cAAc,aAAa,CAAC"}
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,SAAS,CAAC;AAEjC,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC,eAAO,MAAM,UAAU,SAAS,CAAC;AAEjC,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAKzC,CAAC"}

package/dist/fields.js

@@ -1,3 +1,10 @@
+export const TYPE_FIELD = 'type';
 export const MEMBER_FIELD = 'member';
 export const SITE_FIELD = 'site';
 export const RECEIVED_FIELD = 'received';
+export const HOUSE_FIELDS = [
+    TYPE_FIELD,
+    SITE_FIELD,
+    RECEIVED_FIELD,
+    MEMBER_FIELD,
+];

package/dist/index.d.ts

@@ -1,15 +1,21 @@
-export { dated, factKind, facts, fires, holds, instant, itemFires, pointed, prosePaths, WRITE_DOORS, } from './condition.js';
-export type { Actor, Condition, ConditionScope, ConditionTest, ConditionValue, CronCondition, DateCondition, DocumentCondition, DocumentEvent, DocumentFacts, Fact, FactKind, ItemCondition, ItemFacts, Resolved, WriteDoor, } from './condition.js';
+export { ACTOR_PATHS, actorOperators, changeFields, CONDITION_OPERATORS, dated, datePointers, DOCUMENT_PATHS, factKind, facts, fires, holds, instant, ITEM_PATHS, itemFires, itemKind, itemOperators, memberPointers, members, pointed, prosePaths, testOperators, valuedChange, WRITE_DOORS, } from './condition.js';
+export type { Actor, Condition, ConditionOperator, ConditionScope, ConditionTest, ConditionValue, CronCondition, DateCondition, DocumentCondition, DocumentEvent, DocumentFacts, Fact, FactKind, ItemCondition, ItemFacts, Resolved, WriteDoor, } from './condition.js';
+export { headingLines } from './blocks.js';
+export type { HeadingLine } from './blocks.js';
 export { divide } from './divide.js';
-export { apply, bodyLinks, links, parse, relativize, relativizeBody, relinkBody, serialize, } from './document.js';
-export { MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD } from './fields.js';
-export { relative, retarget, target } from './paths.js';
+export { apply, bodyLinks, links, parse, parseFrontmatter, relativize, relativizeBody, relinkBody, serialize, } from './document.js';
+export { HOUSE_FIELDS, MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD, TYPE_FIELD } from './fields.js';
+export { relative, retarget, roomPath, roomTarget, target } from './paths.js';
+export type { RoomTarget } from './paths.js';
 export { MARKDOWN_SYNTAX_PROFILE } from './profile.js';
 export { project } from './project.js';
 export { references } from './references.js';
 export { ARRAY_INDEX, ATTACHMENT, crossedFacts, escapePointer, itemFacts, memberFacts, pointerFacts, pointerSegments, } from './definition.js';
-export type { Definition, JsonType, PatternFacts, PointerFacts, SectionSpec, Shape, ValueFacts, } from './definition.js';
-export type { ApplyResult, BodyResult, Change, Division, DivisionContext, Document, Library, ModelVerification, Link, ParseResult, Projection, ProjectionContext, Reference, Refusal, Span, Validation, ValidationContext, VerifiedModel, } from './types.js';
-export { validate, verify } from './validate.js';
+export type { Definition, FieldRules, JsonType, PatternFacts, PointerFacts, RuleValue, SectionSpec, Shape, Transition, ValueFacts, } from './definition.js';
+export type { ApplyResult, BodyResult, Change, Division, DivisionContext, Document, DocumentCheck, Frontmatter, FrontmatterResult, Library, ModelVerification, Link, ParseResult, Projection, ProjectionContext, Reached, Reference, Refusal, RoomReference, Span, Validation, ValidationContext, ValidationStep, VerifiedModel, } from './types.js';
+export { assess, bodyRoomLinks, checkDocument, resolves, roomReferences, sectionReferences, validate, validating, verdicts, verify, } from './validate.js';
+export type { Assessment, Verdicts } from './validate.js';
 export { VERSION } from './version.js';
+export { bodyAfterFrontmatter, equalValue, frontmatterValue } from './yaml.js';
+export type { FrontmatterValue } from './yaml.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,QAAQ,EACR,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,SAAS,EACT,OAAO,EACP,UAAU,EACV,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,KAAK,EACL,SAAS,EACT,cAAc,EACd,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,SAAS,EACT,QAAQ,EACR,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EACL,KAAK,EACL,SAAS,EACT,KAAK,EACL,KAAK,EACL,UAAU,EACV,cAAc,EACd,UAAU,EACV,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,WAAW,EACX,UAAU,EACV,YAAY,EACZ,aAAa,EACb,SAAS,EACT,WAAW,EACX,YAAY,EACZ,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,KAAK,EACL,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,WAAW,EACX,UAAU,EACV,MAAM,EACN,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,OAAO,EACP,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,KAAK,EACL,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,UAAU,EACV,SAAS,EACT,QAAQ,EACR,aAAa,EACb,cAAc,EACd,OAAO,EACP,OAAO,EACP,UAAU,EACV,aAAa,EACb,YAAY,EACZ,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,KAAK,EACL,SAAS,EACT,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,SAAS,EACT,QAAQ,EACR,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EACL,KAAK,EACL,SAAS,EACT,KAAK,EACL,KAAK,EACL,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,UAAU,EACV,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACjG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAC9E,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,WAAW,EACX,UAAU,EACV,YAAY,EACZ,aAAa,EACb,SAAS,EACT,WAAW,EACX,YAAY,EACZ,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,UAAU,EACV,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,WAAW,EACX,KAAK,EACL,UAAU,EACV,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,WAAW,EACX,UAAU,EACV,MAAM,EACN,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,OAAO,EACP,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,OAAO,EACP,SAAS,EACT,OAAO,EACP,aAAa,EACb,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,MAAM,EACN,aAAa,EACb,aAAa,EACb,QAAQ,EACR,cAAc,EACd,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC/E,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}