@agentshouse/mdmodel 0.1.0-c64dbada0730d → 0.1.0-c669bdbad8a03

package/dist/document.d.ts

@@ -1,13 +1,16 @@
 import { type Definition } from './definition.js';
-import type { ApplyResult, BodyResult, Change, Document, Link, ParseResult } from './types.js';
+import type { ApplyResult, BodyResult, FrontmatterResult, Change, Document, Link, LinkOccurrence, ParseResult } from './types.js';
 import { type YamlMap } from './yaml.js';
+export declare function parseFrontmatter(content: string, file?: string): FrontmatterResult;
 export declare function parse(content: string, file?: string): ParseResult;
 export declare function relativize(document: Document, file: string, handle: string, definition?: Definition): ApplyResult;
 export declare function relativizeBody(body: string, file: string, handle: string): BodyResult;
 export declare function relinkBody(body: string, file: string, moves: ReadonlyMap<string, string>): BodyResult;
 export declare function links(document: Document, file: string): readonly Link[];
+export declare function linkOccurrences(document: Document, file: string): readonly LinkOccurrence[];
 export declare function bodyLinks(body: string, file: string): readonly Link[];
-export declare function apply(document: Document, change: Change): ApplyResult;
+export declare function apply(document: Document, changes: readonly Change[]): ApplyResult;
 export declare function serialize(document: Document): string;
+export declare function fieldStart(document: Document, pointer: string): number | undefined;
 export declare function frontmatter(document: Document): YamlMap | null;
 //# sourceMappingURL=document.d.ts.map

package/dist/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAMhF,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,WAAW,EAEZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAYL,KAAK,OAAO,EAEb,MAAM,WAAW,CAAC;AAwCnB,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,WAAW,CAkD7D;AA2KD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,WAAW,CAYb;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAOrF;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,UAAU,CAeZ;AAeD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAEvE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAErE;AAED,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAerE;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,IAAI,CAE9D"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAehF,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,cAAc,EACd,WAAW,EAEZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAcL,KAAK,OAAO,EAEb,MAAM,WAAW,CAAC;AAmEnB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,iBAAiB,CAW9E;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,WAAW,CAgB7D;AAmED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,WAAW,CAoBb;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAUrF;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,UAAU,CAeZ;AAuBD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAEvE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,cAAc,EAAE,CAG3F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,IAAI,EAAE,CAErE;AA4LD,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CA4CjF;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGlF;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,IAAI,CAE9D"}

package/dist/document.js

@@ -1,10 +1,10 @@
 import { ARRAY_INDEX, pointerSegments } from './definition.js';
 import { hrefOccurrences } from './links.js';
-import { relative, retarget, SHELL_ROOMS, shellTarget, target } from './paths.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();
 function refuse(file, rule, location) {
     return location === undefined ? refusal(file, rule) : refusal(file, rule, { location });
@@ -28,19 +28,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 +40,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 +48,29 @@ export function parse(content, file = '') {
         throw error;
     }
 }
-function splice(content, start, end, insert) {
-    return content.slice(0, start) + insert + content.slice(end);
-}
-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 };
+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 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 +99,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 +141,33 @@ 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;
+    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;
+        if (path !== null)
+            changes.push({
+                kind: 'reference',
+                pointer,
+                value: retarget(value, relative(file, path)),
+                prior: value,
+            });
     }
-    return reparsed(held, shellRelinked(held.content, bodyStartOf(held.content), file, handle));
+    const body = document.content.slice(bodyStartOf(document.content));
+    for (const href of new Set(hrefOccurrences(body).map((occurrence) => occurrence.href))) {
+        const path = shellTarget(href, handle);
+        if (path !== null)
+            changes.push({ kind: 'link', href, to: relative(file, path) });
+    }
+    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 +176,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 : relative(file, to));
         const text = destinationText(written, match.bracketed);
         if (text === null)
             return { outcome: 'refuse', refusal: refuse(file, 'unwritable-link', written) };
@@ -270,48 +189,279 @@ export function relinkBody(body, file, moves) {
     }
     return { outcome: 'applied', body: rewritten + body.slice(cursor) };
 }
+function occurrencesIn(text, file, offset) {
+    const found = [];
+    for (const occurrence of hrefOccurrences(text)) {
+        const resolved = target(file, occurrence.href);
+        if (resolved !== null)
+            found.push({ href: occurrence.href, target: resolved, start: offset + occurrence.start });
+    }
+    return found;
+}
 function linksIn(text, file) {
     const found = [];
     const seen = new Set();
-    for (const occurrence of hrefOccurrences(text)) {
+    for (const occurrence of occurrencesIn(text, file, 0)) {
         if (seen.has(occurrence.href))
             continue;
-        const resolved = target(file, occurrence.href);
-        if (resolved === null)
-            continue;
         seen.add(occurrence.href);
-        found.push({ href: occurrence.href, target: resolved });
+        found.push({ href: occurrence.href, target: occurrence.target });
     }
     return found;
 }
 export function links(document, file) {
     return linksIn(document.content.slice(bodyStartOf(document.content)), file);
 }
+export function linkOccurrences(document, file) {
+    const bodyStart = bodyStartOf(document.content);
+    return occurrencesIn(document.content.slice(bodyStart), file, bodyStart);
+}
 export function bodyLinks(body, file) {
     return linksIn(body, file);
 }
-export function apply(document, change) {
+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),
+    };
+}
+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 hrefOccurrences(content.slice(internal.bodyStart))) {
+                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;
 }
+export function fieldStart(document, pointer) {
+    const root = internals.get(document)?.root;
+    return root === null || root === undefined ? undefined : nodeAt(root, pointer)?.start;
+}
 export function frontmatter(document) {
     return internals.get(document)?.root ?? null;
 }

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,
+];