@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c0105dbd22806

package/dist/room-draft.js

@@ -0,0 +1,438 @@
+import { apply, equalValue, frontmatterValue, parse, serialize } from '@agentshouse/mdmodel';
+import { runtimeError } from './failure.js';
+import { hexDigest } from './file.js';
+import { binaryLocalId } from './identity.js';
+import { normalize } from './paths.js';
+export function returnedBy(kind) {
+    return { kind, code: kind, fields: {}, retryable: false };
+}
+export function staleWrite(current) {
+    return { outcome: 'stale', code: 'stale', retryable: false, current };
+}
+function malformed() {
+    throw runtimeError('room-draft-malformed');
+}
+function plain(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === 'string' ? value : malformed();
+}
+function optionalText(value) {
+    return value === undefined ? undefined : text(value);
+}
+function markdownBase(value) {
+    return value === null ? null : optionalText(value);
+}
+function entries(value, each) {
+    if (!plain(value))
+        malformed();
+    const read = {};
+    for (const [name, item] of Object.entries(value))
+        read[name] = each(item);
+    return read;
+}
+function fieldValue(value) {
+    if (value === null)
+        return null;
+    if (!plain(value) || !Object.hasOwn(value, 'value') || !frontmatterValue(value.value)) {
+        malformed();
+    }
+    return { value: value.value };
+}
+function textPart(value) {
+    if (!plain(value))
+        malformed();
+    const base = optionalText(value.base);
+    return { value: text(value.value), ...(base === undefined ? {} : { base }) };
+}
+function creationOf(value) {
+    if (!plain(value))
+        malformed();
+    if (Object.hasOwn(value, 'markdown'))
+        return { markdown: text(value.markdown) };
+    const fields = entries(value.fields, (item) => (frontmatterValue(item) ? item : malformed()));
+    return { type: text(value.type), fields, sections: entries(value.sections, text) };
+}
+const PART_NAMES = new Set([
+    'fields',
+    'sections',
+    'preamble',
+    'markdown',
+    'creation',
+    'move',
+    'removal',
+    'file',
+]);
+export function readParts(value) {
+    if (!plain(value) || Object.keys(value).some((name) => !PART_NAMES.has(name)))
+        malformed();
+    const parts = {};
+    if (value.fields !== undefined) {
+        parts.fields = entries(value.fields, (item) => {
+            if (!plain(item) || !Object.hasOwn(item, 'value') || !frontmatterValue(item.value)) {
+                malformed();
+            }
+            return item.base === undefined
+                ? { value: item.value }
+                : { value: item.value, base: fieldValue(item.base) };
+        });
+    }
+    if (value.sections !== undefined)
+        parts.sections = entries(value.sections, textPart);
+    if (value.preamble !== undefined)
+        parts.preamble = textPart(value.preamble);
+    if (value.markdown !== undefined)
+        parts.markdown = textPart(value.markdown);
+    if (value.creation !== undefined)
+        parts.creation = creationOf(value.creation);
+    if (value.move !== undefined) {
+        if (!plain(value.move))
+            malformed();
+        const base = markdownBase(value.move.base);
+        parts.move = { to: text(value.move.to), ...(base === undefined ? {} : { base }) };
+    }
+    if (value.removal !== undefined) {
+        if (!plain(value.removal))
+            malformed();
+        const base = markdownBase(value.removal.base);
+        parts.removal = base === undefined ? {} : { base };
+    }
+    if (value.file !== undefined) {
+        if (!plain(value.file) || !(value.file.blob instanceof Blob))
+            malformed();
+        if (Object.keys(value).length > 1)
+            throw runtimeError('room-draft-file-exclusive');
+        parts.file = { blob: value.file.blob };
+    }
+    return parts;
+}
+function named(record) {
+    return Object.entries(record ?? {});
+}
+function own(record, name) {
+    return record !== undefined && Object.hasOwn(record, name) ? record[name] : undefined;
+}
+function kept(prior, base) {
+    if (prior !== undefined)
+        return prior.base;
+    if (base === undefined)
+        throw runtimeError('room-draft-base-missing');
+    return base;
+}
+function editsText(parts) {
+    return (parts.preamble !== undefined ||
+        named(parts.fields).length > 0 ||
+        named(parts.sections).length > 0);
+}
+export function held(current, parts, file) {
+    if (parts.markdown !== undefined && editsText(parts)) {
+        throw runtimeError('room-draft-markdown-exclusive');
+    }
+    if (file !== undefined) {
+        if (current !== undefined && current.file === undefined) {
+            throw runtimeError('room-draft-file-exclusive');
+        }
+        return { file: { ...file, base: current?.file === undefined ? file.base : current.file.base } };
+    }
+    if (current?.file !== undefined) {
+        if (editsText(parts) ||
+            parts.markdown !== undefined ||
+            parts.creation !== undefined ||
+            (parts.move === undefined && parts.removal === undefined)) {
+            throw runtimeError('room-draft-file-exclusive');
+        }
+        return {
+            file: current.file,
+            ...(parts.move === undefined
+                ? {}
+                : { move: { to: parts.move.to, base: kept(current.move, parts.move.base) } }),
+            ...(parts.removal === undefined
+                ? {}
+                : { removal: { base: kept(current.removal, parts.removal.base) } }),
+        };
+    }
+    const next = {};
+    const fields = named(parts.fields);
+    if (fields.length > 0) {
+        next.fields = Object.fromEntries(fields.map(([name, part]) => [
+            name,
+            { value: part.value, base: kept(own(current?.fields, name), part.base) },
+        ]));
+    }
+    const sections = named(parts.sections);
+    if (sections.length > 0) {
+        next.sections = Object.fromEntries(sections.map(([name, part]) => [
+            name,
+            { value: part.value, base: kept(own(current?.sections, name), part.base) },
+        ]));
+    }
+    if (parts.preamble !== undefined) {
+        next.preamble = {
+            value: parts.preamble.value,
+            base: kept(current?.preamble, parts.preamble.base),
+        };
+    }
+    if (parts.markdown !== undefined) {
+        next.markdown = {
+            value: parts.markdown.value,
+            base: kept(current?.markdown, parts.markdown.base),
+        };
+    }
+    if (parts.creation !== undefined)
+        next.creation = parts.creation;
+    if (parts.move !== undefined) {
+        next.move = { to: parts.move.to, base: kept(current?.move, parts.move.base) };
+    }
+    if (parts.removal !== undefined) {
+        next.removal = { base: kept(current?.removal, parts.removal.base) };
+    }
+    if (Object.keys(next).length === 0)
+        throw runtimeError('room-draft-empty');
+    return next;
+}
+function sameField(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    return equalValue(left.value, right.value);
+}
+export function underneath(parts, path, visible) {
+    const markdown = visible?.documents[path] ?? null;
+    const document = visible?.collection.document(path);
+    const report = {};
+    const fields = {};
+    for (const [name, part] of named(parts.fields)) {
+        const current = document !== undefined && Object.hasOwn(document.fields, name)
+            ? { value: document.fields[name] }
+            : null;
+        if (!sameField(part.base, current))
+            fields[name] = current;
+    }
+    if (Object.keys(fields).length > 0)
+        report.fields = fields;
+    const sections = {};
+    for (const [name, part] of named(parts.sections)) {
+        const current = document !== undefined && Object.hasOwn(document.sections, name)
+            ? document.sections[name]
+            : null;
+        if (current !== part.base)
+            sections[name] = current;
+    }
+    if (Object.keys(sections).length > 0)
+        report.sections = sections;
+    const preamble = document?.preamble ?? null;
+    if (parts.preamble !== undefined && preamble !== parts.preamble.base)
+        report.preamble = preamble;
+    if (parts.markdown !== undefined && markdown !== parts.markdown.base)
+        report.markdown = markdown;
+    if (parts.creation !== undefined && markdown !== null)
+        report.creation = markdown;
+    if (parts.move !== undefined && markdown !== parts.move.base)
+        report.move = markdown;
+    if (parts.removal !== undefined && markdown !== parts.removal.base)
+        report.removal = markdown;
+    if (parts.file !== undefined) {
+        const file = binaryBase(visible, path);
+        if (file !== parts.file.base || markdown !== null)
+            report.file = file;
+    }
+    return report;
+}
+const UNTYPED_MEDIA_TYPE = 'application/octet-stream';
+export async function heldFile(blob, base) {
+    const bytes = await blob.arrayBuffer();
+    return {
+        blob,
+        localId: binaryLocalId(),
+        byteLength: bytes.byteLength,
+        mediaType: blob.type === '' ? UNTYPED_MEDIA_TYPE : blob.type,
+        sha256: hexDigest(await crypto.subtle.digest('SHA-256', bytes)),
+        base,
+    };
+}
+export function binaryBase(visible, path) {
+    return visible?.binaries[path] === undefined ? null : (visible.revisions[path] ?? null);
+}
+export function changedParts(path, report) {
+    return [
+        ...(report.creation === undefined ? [] : [{ path, part: 'creation' }]),
+        ...named(report.fields).map(([name]) => ({ path, part: 'field', name })),
+        ...named(report.sections).map(([name]) => ({ path, part: 'section', name })),
+        ...(report.preamble === undefined ? [] : [{ path, part: 'preamble' }]),
+        ...(report.markdown === undefined ? [] : [{ path, part: 'markdown' }]),
+        ...(report.move === undefined ? [] : [{ path, part: 'move' }]),
+        ...(report.removal === undefined ? [] : [{ path, part: 'removal' }]),
+        ...(report.file === undefined ? [] : [{ path, part: 'file' }]),
+    ];
+}
+function joined(existing, returned) {
+    const merged = { ...existing };
+    for (const [name, part] of named(returned))
+        if (!Object.hasOwn(merged, name))
+            merged[name] = part;
+    return Object.keys(merged).length === 0 ? undefined : merged;
+}
+function ended(text) {
+    return text === '' || text.endsWith('\n') ? text : `${text}\n`;
+}
+function frontmatterOf(fields) {
+    const opened = parse('---\n---\n');
+    if (!opened.ok)
+        return malformed();
+    let document = opened.document;
+    for (const [name, part] of fields) {
+        const next = apply(document, { kind: 'field', name, value: part.value, prior: undefined });
+        if (next.outcome !== 'applied')
+            return malformed();
+        document = next.document;
+    }
+    return serialize(document);
+}
+function concatenated(markdown, parts) {
+    const fields = named(parts.fields);
+    const pieces = [
+        ...(fields.length === 0 ? [] : [frontmatterOf(fields)]),
+        ...(parts.preamble === undefined ? [] : [parts.preamble.value]),
+        ...named(parts.sections).map(([name, part]) => `## ${name}\n${part.value}`),
+    ];
+    if (pieces.length === 0)
+        return markdown;
+    return `${ended(markdown)}\n${pieces.map(ended).join('')}`;
+}
+export function returnedInto(existing, returned) {
+    if (existing === undefined)
+        return returned;
+    const next = { ...existing };
+    const whole = existing.markdown ?? returned.markdown;
+    if (whole === undefined) {
+        const fields = joined(existing.fields, returned.fields);
+        const sections = joined(existing.sections, returned.sections);
+        if (fields !== undefined)
+            next.fields = fields;
+        if (sections !== undefined)
+            next.sections = sections;
+        const preamble = existing.preamble ?? returned.preamble;
+        if (preamble !== undefined)
+            next.preamble = preamble;
+    }
+    else {
+        delete next.fields;
+        delete next.sections;
+        delete next.preamble;
+        const value = concatenated(whole.value, existing.markdown === undefined ? existing : returned);
+        next.markdown = { value, base: whole.base };
+    }
+    const creation = existing.creation ?? returned.creation;
+    const move = existing.move ?? returned.move;
+    const removal = existing.removal ?? returned.removal;
+    const file = existing.file ?? returned.file;
+    if (creation !== undefined)
+        next.creation = creation;
+    if (move !== undefined)
+        next.move = move;
+    if (removal !== undefined)
+        next.removal = removal;
+    if (file !== undefined)
+        next.file = file;
+    return next;
+}
+export function moveTarget(move) {
+    const to = normalize(move.to);
+    return to === null || to === '' ? move.to : to;
+}
+export function changesOf(path, parts) {
+    const changes = [];
+    const bases = [];
+    const creation = parts.creation;
+    if (creation !== undefined) {
+        changes.push('markdown' in creation
+            ? { kind: 'create', path, content: creation.markdown }
+            : {
+                kind: 'create',
+                path,
+                fields: { type: creation.type, ...creation.fields },
+                sections: creation.sections,
+            });
+    }
+    for (const [name, part] of named(parts.fields)) {
+        changes.push({ kind: 'field', path, name, value: part.value });
+        bases.push({ kind: 'field', path, name, value: part.base?.value });
+    }
+    for (const [name, part] of named(parts.sections)) {
+        changes.push({ kind: 'section', path, name, value: part.value });
+        bases.push({ kind: 'section', path, name, value: part.base });
+    }
+    if (parts.preamble !== undefined) {
+        changes.push({ kind: 'preamble', path, value: parts.preamble.value });
+        bases.push({ kind: 'preamble', path, value: parts.preamble.base });
+    }
+    if (parts.markdown !== undefined) {
+        changes.push({ kind: 'replace', path, content: parts.markdown.value });
+    }
+    if (parts.file !== undefined && parts.removal === undefined) {
+        const { base, ...file } = parts.file;
+        const at = parts.move === undefined ? path : moveTarget(parts.move);
+        if (base !== null && at !== path)
+            changes.push({ kind: 'move', path, to: at });
+        changes.push({ kind: 'binary', path: at, ...file });
+        if (base === null && at !== path)
+            bases.push({ kind: 'absent', path: at });
+        return { changes, bases };
+    }
+    if (parts.file?.base === null)
+        return { changes, bases };
+    if (parts.move !== undefined)
+        changes.push({ kind: 'move', path, to: moveTarget(parts.move) });
+    if (parts.removal !== undefined)
+        changes.push({ kind: 'remove', path });
+    return { changes, bases };
+}
+function rebased(before, after) {
+    return before === undefined ? after : { ...after, base: before.base };
+}
+function rebasedAll(before, after) {
+    return {
+        ...before,
+        ...Object.fromEntries(Object.entries(after).map(([name, part]) => [name, rebased(before?.[name], part)])),
+    };
+}
+export function joinedDraft(carried, saved) {
+    const draft = saved.find((item) => item.path === carried.path);
+    if (draft === undefined)
+        return carried;
+    const held = carried.parts;
+    const next = draft.parts;
+    return {
+        path: carried.path,
+        parts: {
+            ...held,
+            ...next,
+            ...(next.fields === undefined ? {} : { fields: rebasedAll(held.fields, next.fields) }),
+            ...(next.sections === undefined
+                ? {}
+                : { sections: rebasedAll(held.sections, next.sections) }),
+            ...(next.preamble === undefined ? {} : { preamble: rebased(held.preamble, next.preamble) }),
+            ...(next.markdown === undefined ? {} : { markdown: rebased(held.markdown, next.markdown) }),
+        },
+    };
+}
+export function withdrawnDrafts(drafts, changes) {
+    return drafts.flatMap((draft) => {
+        const file = draft.parts.file;
+        const at = draft.parts.move?.to ?? draft.path;
+        const change = changes.find((item) => (item.kind === 'move' || item.kind === 'remove') && item.path === at);
+        if (file === undefined || change === undefined)
+            return [draft];
+        if (change.kind === 'move') {
+            return [
+                {
+                    path: draft.path,
+                    parts: change.to === draft.path ? { file } : { file, move: { to: change.to, base: null } },
+                },
+            ];
+        }
+        return file.base === null
+            ? []
+            : [{ path: draft.path, parts: { file, removal: { base: null } } }];
+    });
+}

package/dist/rows.d.ts

@@ -0,0 +1,46 @@
+import { type Document } from '@agentshouse/mdmodel';
+import type { HeadChange } from './adapter.js';
+import type { BinaryFileRecord } from './binary.js';
+import { type Composition } from './collection.js';
+type Fields = Readonly<Record<string, unknown>>;
+export type DocumentRow = {
+    key: string;
+    kind: 'document';
+    room: string;
+    path: string;
+    type: string | null;
+    fields: Fields;
+    values: Fields;
+    reached: Readonly<Record<string, readonly unknown[]>>;
+    directories: readonly string[];
+    body: string;
+    change: HeadChange | null;
+    binary: BinaryFileRecord | null;
+};
+export type BodyRow = {
+    key: string;
+    kind: 'body';
+    room: string;
+    path: string;
+    preamble: string;
+    sections: Readonly<Record<string, string>>;
+    markdown: string;
+};
+export type ReferenceRow = {
+    key: string;
+    kind: 'reference';
+    room: string;
+    source: string;
+    target: string;
+    field: string;
+    forms: readonly string[];
+    path: string;
+    type: string;
+};
+export type Row = DocumentRow | BodyRow | ReferenceRow;
+export declare function documentKey(room: string, path: string): string;
+export declare function roomOfKey(key: string): string;
+export declare function markdownPath(path: string): boolean;
+export declare function rowsOf(room: string, path: string, document: Document | null, composition: Composition, change: HeadChange | null, binary: BinaryFileRecord | null): readonly Row[];
+export {};
+//# sourceMappingURL=rows.d.ts.map

package/dist/rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9D,KAAK,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEhD,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,CAAC;IACtD,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG,WAAW,GAAG,OAAO,GAAG,YAAY,CAAC;AAMvD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAmFD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,MAAM,CACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GAAG,IAAI,EACzB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAC9B,SAAS,GAAG,EAAE,CAyEhB"}

package/dist/rows.js

@@ -0,0 +1,145 @@
+import { ARRAY_INDEX, escapePointer, references, target, } from '@agentshouse/mdmodel';
+import { governing } from './collection.js';
+import { definitionOf } from './model.js';
+function keyOf(...parts) {
+    return `${parts.join('\u0000')}\u0000`;
+}
+export function documentKey(room, path) {
+    return keyOf('d', room, path);
+}
+export function roomOfKey(key) {
+    return key.split('\u0000')[1];
+}
+function plainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function compared(reading, exact, value) {
+    if (!reading.references.has(exact))
+        return value;
+    return (typeof value === 'string' ? target(reading.path, value) : null) ?? undefined;
+}
+function record(reading, node, forms, exact) {
+    const value = Array.isArray(node)
+        ? node.map((item, index) => compared(reading, `${exact}/${index}`, item))
+        : compared(reading, exact, node);
+    for (const form of forms) {
+        if (form.pending)
+            continue;
+        (reading.reached[form.text] ??= []).push(value);
+        if (!form.through && value !== undefined && !plainObject(value)) {
+            reading.values[form.text] = value;
+        }
+    }
+    if (Array.isArray(node) || plainObject(node) || !reading.references.has(exact))
+        return;
+    const found = compared(reading, exact, node);
+    if (typeof found !== 'string')
+        return;
+    const field = forms
+        .map((form) => form.text)
+        .reduce((left, right) => (right.length < left.length ? right : left));
+    const known = reading.targets.get(`${field}\u0000${found}`);
+    const kept = known ?? { field, target: found, forms: new Set() };
+    for (const form of forms)
+        kept.forms.add(form.text);
+    reading.targets.set(`${field}\u0000${found}`, kept);
+}
+function walk(reading, node, forms, exact) {
+    record(reading, node, forms, exact);
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => walk(reading, item, forms.flatMap((form) => [
+            ...(form.pending
+                ? []
+                : [{ text: `${form.text}/${index}`, through: form.through, pending: false }]),
+            { text: form.text, through: true, pending: true },
+        ]), `${exact}/${index}`));
+        return;
+    }
+    if (!plainObject(node))
+        return;
+    for (const [key, value] of Object.entries(node)) {
+        const segment = escapePointer(key);
+        walk(reading, value, forms.flatMap((form) => form.pending && ARRAY_INDEX.test(key)
+            ? []
+            : [{ text: `${form.text}/${segment}`, through: form.through, pending: false }]), `${exact}/${segment}`);
+    }
+}
+function directoriesOf(path) {
+    const parts = path.split('/').slice(0, -1);
+    return ['', ...parts.map((_, index) => parts.slice(0, index + 1).join('/'))];
+}
+export function markdownPath(path) {
+    return path.endsWith('.md');
+}
+export function rowsOf(room, path, document, composition, change, binary) {
+    const key = documentKey(room, path);
+    const body = keyOf('b', room, path);
+    if (document === null || !markdownPath(path)) {
+        return [
+            {
+                key,
+                kind: 'document',
+                room,
+                path,
+                type: null,
+                fields: {},
+                values: {},
+                reached: {},
+                directories: directoriesOf(path),
+                body,
+                change,
+                binary,
+            },
+        ];
+    }
+    const type = document.type ?? 'any';
+    const definition = definitionOf(governing(composition, path), document.type);
+    const reading = {
+        path,
+        references: new Set(definition === undefined ? [] : references(document, definition).map((one) => one.pointer)),
+        values: {},
+        reached: {},
+        targets: new Map(),
+    };
+    for (const [name, value] of Object.entries(document.fields)) {
+        const segment = escapePointer(name);
+        walk(reading, value, [{ text: `/${segment}`, through: false, pending: false }], `/${segment}`);
+    }
+    const { values, reached } = reading;
+    return [
+        {
+            key,
+            kind: 'document',
+            room,
+            path,
+            type,
+            fields: document.fields,
+            values,
+            reached,
+            directories: directoriesOf(path),
+            body,
+            change,
+            binary,
+        },
+        {
+            key: body,
+            kind: 'body',
+            room,
+            path,
+            preamble: document.preamble,
+            sections: document.sections,
+            markdown: document.content,
+        },
+        ...[...reading.targets.values()].map(({ field, target: found, forms }) => ({
+            key: keyOf('r', room, path, field, found),
+            kind: 'reference',
+            room,
+            source: key,
+            target: documentKey(room, found),
+            field,
+            forms: [...forms].sort(),
+            path,
+            type,
+        })),
+    ];
+}

package/dist/save.d.ts

@@ -1,24 +1,29 @@
-import type { AttachedModelBinding } from './model.js';
 import type { ProviderLimit } from './adapter.js';
-import { type Change, type ChangeBatch } from './change.js';
+import { type Change, type ChangeBatch, type Precondition, type WrittenBy } from './change.js';
 import { type Composition } from './collection.js';
 import type { VisibleLayer } from './replica.js';
+import type { ChangedPart } from './room-draft.js';
 export type SaveRefusal = {
-    source?: 'model';
-    rule: string;
+    code: string;
+    retryable: boolean;
     file?: string;
     location?: string;
     referrers?: readonly string[];
+    parts?: readonly ChangedPart[];
 };
 export type SaveInput = {
+    local: boolean;
     composition: Composition;
     baseRoomVersion: string;
     operations: import('./adapter.js').OperationScopes;
-    binding: AttachedModelBinding | null;
     providerOwnedPaths: readonly string[];
     providerLimits: readonly ProviderLimit[];
     visible: VisibleLayer;
+    handle: string;
     changes: readonly Change[];
+    bases: readonly Precondition[];
+    queued?: ReadonlySet<string>;
+    writtenBy?: WrittenBy;
 };
 export type BatchResult = {
     kind: 'batch';
@@ -27,5 +32,28 @@ export type BatchResult = {
     kind: 'refused';
     refusal: SaveRefusal;
 };
+export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): ChangeBatch;
+export type Requeued = {
+    kind: 'requeued';
+    queue: readonly ChangeBatch[];
+    changes: readonly Change[];
+    queued: ReadonlySet<string>;
+    withdrawn: ReadonlyMap<string, ChangeBatch | null>;
+    owners: ReadonlySet<string>;
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export type Joining = {
+    kind: 'joined';
+    batch: ChangeBatch;
+    queue: readonly ChangeBatch[];
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export declare function requeued(queue: readonly ChangeBatch[], changes: readonly Change[], visible: VisibleLayer, changeable: (batch: ChangeBatch) => boolean, state: (queue: readonly ChangeBatch[]) => VisibleLayer): Requeued;
+export declare function joined(queue: readonly ChangeBatch[], owner: ChangeBatch, extra: ChangeBatch): Joining;
+export declare function limitedIn(queue: readonly ChangeBatch[], batch: ChangeBatch, limits: readonly ProviderLimit[], state: (queue: readonly ChangeBatch[]) => VisibleLayer): SaveRefusal | null;
 export declare function buildBatch(input: SaveInput): BatchResult;
 //# sourceMappingURL=save.d.ts.map