@agentshouse/mdmodel 0.1.0-alpha.9 → 0.1.0-c04c0d681d2d4

package/dist/document.js

@@ -1,13 +1,22 @@
-import { hrefOccurrences } from './links.js';
-import { classifyHref, hrefSuffix } from './paths.js';
+import { ARRAY_INDEX, pointerSegments } from './definition.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
-    });
+    return location === undefined ? refusal(file, rule) : refusal(file, rule, { location });
 }
 function freezeDocument(content, type, fields, preamble, sections, internal) {
     const document = Object.freeze({
@@ -15,151 +24,75 @@ function freezeDocument(content, type, fields, preamble, sections, internal) {
         type,
         fields: Object.freeze(fields),
         preamble,
-        sections: Object.freeze(sections)
+        sections: Object.freeze(sections),
     });
     internals.set(document, internal);
     return document;
 }
 function declaredType(fields) {
     const value = fields.type;
-    if (value === undefined || value === null) return undefined;
-    if (typeof value !== 'string' || value === '') return undefined;
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || value === '')
+        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 === 'unclosed') return {
-        ok: false,
-        refusal: refuse(file, 'frontmatter-fence')
-    };
+    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 {
         const root = parseYamlMapping(content, fence.yamlStart, fence.yamlEnd);
         const fields = jsValue(root);
         if (fields === null || typeof fields !== 'object' || Array.isArray(fields)) {
-            return {
-                ok: false,
-                refusal: refuse(file, 'frontmatter-fence')
-            };
+            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
-            })
-        };
-    } catch (error) {
-        if (error instanceof YamlError) return {
-            ok: false,
-            refusal: refuse(file, 'frontmatter-fence')
-        };
+        return { ok: true, root, fields: fields, yamlEnd: fence.yamlEnd };
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return { ok: false, refusal: refuse(file, 'frontmatter-fence') };
         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 {
-        const nl = lineEnding(document.content);
-        const line = `${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
-    };
+export function parseFrontmatter(content, file = '') {
+    const read = opened(content, file);
+    if (!read.ok)
+        return read;
     return {
-        outcome: 'applied',
-        document: parsed.document
+        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
-    };
+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 {
-        outcome: 'applied',
-        document: parsed.document
+        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('<')) return false;
+    if (to === '' || to.startsWith('<'))
+        return false;
     let depth = 0;
-    for (const character of to){
-        if (/[\s\u0000-\u001f\u007f]/.test(character)) return false;
-        if (character === '(') depth += 1;
+    for (const character of to) {
+        if (/[\s\u0000-\u001f\u007f]/.test(character))
+            return false;
+        if (character === '(')
+            depth += 1;
         else if (character === ')') {
-            if (depth === 0) return false;
+            if (depth === 0)
+                return false;
             depth -= 1;
         }
     }
@@ -169,74 +102,364 @@ function fitsBrackets(to) {
     return to !== '' && !/[<>\n\r]/.test(to);
 }
 function destinationText(to, bracketed) {
-    if (fitsBare(to)) return bracketed && fitsBrackets(to) ? `<${to}>` : to;
-    if (fitsBrackets(to)) return `<${to}>`;
+    if (fitsBare(to))
+        return bracketed && fitsBrackets(to) ? `<${to}>` : to;
+    if (fitsBrackets(to))
+        return `<${to}>`;
     return null;
 }
-function applyLink(document, href, to) {
-    const content = document.content;
-    const bodyStart = bodyStartOf(content);
-    const matches = hrefOccurrences(content.slice(bodyStart)).filter((occurrence)=>occurrence.href === href);
-    if (matches.length === 0) return {
-        outcome: 'stale',
-        document
+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 to = retarget(href, relative(file, path));
+        if (destinationText(to, false) === null)
+            return refuse('', 'unwritable-link', to);
+        written.set(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, entryOf = mapEntry) {
+    let node = root;
+    for (const key of pointerSegments(pointer)) {
+        if (node?.kind === 'map')
+            node = entryOf(node, key)?.value;
+        else if (node?.kind === 'seq' && ARRAY_INDEX.test(key))
+            node = node.items[Number(key)];
+        else
+            return undefined;
+    }
+    return node;
+}
+function scalarText(source, value) {
+    if (source === "'")
+        return `'${value.replaceAll("'", "''")}'`;
+    if (source === '"')
+        return JSON.stringify(value);
+    return serializeJs(value);
+}
+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 written = to + hrefSuffix(href);
+    const changes = [];
+    for (const { pointer, value } of definition === undefined
+        ? []
+        : references(document, definition)) {
+        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 apply(document, changes);
+}
+export function relativizeBody(body, file, handle) {
+    const relinkedBody = shellRelinked(body, file, handle);
+    if (typeof relinkedBody !== 'string')
+        return { outcome: 'refuse', refusal: relinkedBody };
+    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 };
+}
+export function relinkBody(body, file, moves) {
     let rewritten = '';
     let cursor = 0;
-    for (const match of matches){
+    for (const match of hrefOccurrences(body)) {
+        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, 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('', 'unwritable-link', written)
-        };
-        rewritten += content.slice(cursor, bodyStart + match.start);
-        rewritten += text;
-        cursor = bodyStart + match.end;
-    }
-    const parsed = parse(rewritten + content.slice(cursor));
-    if (!parsed.ok) return {
-        outcome: 'refuse',
-        refusal: parsed.refusal
-    };
-    return {
-        outcome: 'applied',
-        document: parsed.document
-    };
+        if (text === null)
+            return { outcome: 'refuse', refusal: refuse(file, 'unwritable-link', written) };
+        rewritten += body.slice(cursor, match.start) + text;
+        cursor = match.end;
+    }
+    return { outcome: 'applied', body: rewritten + body.slice(cursor) };
 }
-export function links(document, file) {
+function linksIn(occurrences, file) {
     const found = [];
     const seen = new Set();
-    for (const occurrence of hrefOccurrences(document.content.slice(bodyStartOf(document.content)))){
-        if (seen.has(occurrence.href)) continue;
-        const resolved = classifyHref(file, occurrence.href);
-        if (resolved.kind !== 'path') continue;
+    for (const occurrence of occurrences) {
+        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.path
-        });
+        found.push({ href: occurrence.href, target: resolved });
     }
     return found;
 }
-export function apply(document, change) {
-    if (change.kind === 'link') return applyLink(document, change.href, change.to);
-    if (change.kind === 'preamble') return applyPreamble(document, change.value, change.prior);
-    try {
-        if (change.kind === 'field') return applyField(document, change.name, change.value, change.prior);
-        return applySection(document, change.name, change.value, change.prior);
-    } catch (error) {
-        if (error instanceof YamlError) {
-            return {
-                outcome: 'refuse',
-                refusal: refuse('', 'frontmatter-fence', change.name)
-            };
+export function links(document, file) {
+    return linksIn(destinations(inventoryOf(document)), file);
+}
+export function bodyLinks(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),
+    };
+}
+function partOf(change) {
+    if (change.kind === 'field' || change.kind === 'section')
+        return `${change.kind} ${change.name}`;
+    if (change.kind === 'link')
+        return `link ${change.href}`;
+    if (change.kind === 'reference')
+        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);
         }
-        throw error;
+        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 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;
+        }
+    }
+}
+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;
+        }
+        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;
 }
-
-//# sourceMappingURL=document.js.map
+export function frontmatter(document) {
+    return internals.get(document)?.root ?? null;
+}

package/dist/fields.d.ts

@@ -0,0 +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

@@ -0,0 +1 @@
+{"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

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