@agentshouse/mdruntime 0.1.0-cdb8840578a20 → 0.1.0-cdded6c080913

package/dist/room-drafts.js

@@ -0,0 +1,216 @@
+import { plain } from '@agentshouse/mdmodel';
+import { changeSet } from './change-set.js';
+import { collectionOf } from './collection.js';
+import { runtimeError } from './failure.js';
+import { roomDraftRevision } from './identity.js';
+import { normalize } from './paths.js';
+import { slicing } from './replica.js';
+import { binaryBase, gatheredParts, held, heldFile, readParts, staleWrite, underneath, } from './room-draft.js';
+import { stepped } from './turn.js';
+const ROOM_DRAFTS = 'room-drafts';
+const presentationTopic = (app) => `presentation\u0000${app}`;
+export async function visibleOf(store, locator, paths) {
+    const kept = await store.record(locator);
+    if (kept === undefined)
+        return undefined;
+    const local = await store.open();
+    const slice = await stepped(slicing(await local.entries(kept.key, 'visible', paths), paths));
+    return { ...slice, collection: collectionOf(slice.documents, store.composed(kept)) };
+}
+function roomDraftOf(record, visible) {
+    return structuredClone({
+        room: record.locator,
+        path: record.path,
+        revision: record.revision,
+        parts: record.parts,
+        changedUnderneath: underneath(record.parts, record.path, visible),
+        returned: record.returned,
+    });
+}
+async function roomDraftsOf(store, records) {
+    const rooms = new Map();
+    for (const record of records) {
+        const paths = rooms.get(record.locator) ?? [];
+        paths.push(record.path);
+        rooms.set(record.locator, paths);
+    }
+    const layers = new Map();
+    for (const [locator, paths] of rooms) {
+        layers.set(locator, await visibleOf(store, locator, paths));
+    }
+    return records.map((record) => roomDraftOf(record, layers.get(record.locator)));
+}
+function inOrder(records) {
+    return [...records].sort((left, right) => {
+        if (left.locator !== right.locator)
+            return left.locator < right.locator ? -1 : 1;
+        if (left.path !== right.path)
+            return left.path < right.path ? -1 : 1;
+        return 0;
+    });
+}
+async function snapshotRoomDrafts(store) {
+    return roomDraftsOf(store, inOrder(await store.drafts()));
+}
+export function publishRoomDrafts({ store, socket }, waitingOnly, touched = null) {
+    const unwatched = () => socket.closed() || store.watching(ROOM_DRAFTS).length === 0;
+    if (unwatched())
+        return Promise.resolve();
+    return store.publication(async () => {
+        if (unwatched())
+            return;
+        const records = await store.drafts();
+        if (socket.closed())
+            return;
+        if (touched !== null &&
+            !records.some((record) => touched.some(({ locator, path }) => locator === record.locator && (path === null || path === record.path)))) {
+            return;
+        }
+        const value = await roomDraftsOf(store, inOrder(records));
+        if (socket.closed())
+            return;
+        const answered = store.watching(ROOM_DRAFTS, waitingOnly ? 'waiting' : 'all');
+        for (const watcher of answered)
+            watcher.answer(value);
+    });
+}
+async function presentationOf(store, app) {
+    const value = await (await store.open()).presentation(app);
+    return value === undefined ? null : structuredClone(value);
+}
+export function emitPresentation({ store, socket }, app) {
+    const topic = presentationTopic(app);
+    const listening = () => store.watching(topic, 'ready');
+    if (socket.closed() || listening().length === 0)
+        return Promise.resolve();
+    return store.publication(async () => {
+        if (socket.closed() || listening().length === 0)
+            return;
+        const value = await presentationOf(store, app);
+        if (socket.closed())
+            return;
+        for (const watcher of listening())
+            watcher.answer(value);
+    });
+}
+async function writtenRoomDraft({ store }, room, path, revision, input, next) {
+    const parts = readParts(input, path);
+    if (path === '' || normalize(path) !== path)
+        throw runtimeError('room-draft-malformed', `room-draft-malformed at ${path}: a path inside the Room, such as notes/a.md`);
+    const local = await store.open();
+    const current = await store.draft(room, path);
+    if ((current?.revision ?? null) !== revision) {
+        return staleWrite(current === undefined ? null : ((await roomDraftsOf(store, [current]))[0] ?? null));
+    }
+    const file = parts.file === undefined
+        ? undefined
+        : await heldFile(parts.file.blob, parts.file.base === undefined
+            ? binaryBase(await visibleOf(store, room, [path]), path)
+            : parts.file.base);
+    const record = {
+        locator: room,
+        path,
+        revision: next,
+        parts: held(current?.parts, parts, file),
+        returned: current?.returned ?? null,
+    };
+    await local.keepRoomDraft(record, parts.file === undefined || file === undefined
+        ? []
+        : [{ key: file.localId, blob: parts.file.blob }]);
+    await store.changed(changeSet(room, { drafts: [path] }));
+    return { outcome: 'written', roomDraft: (await roomDraftsOf(store, [record]))[0] ?? null };
+}
+async function keptPresentation({ store }, app, next) {
+    const local = await store.open();
+    const stored = next(await local.presentation(app));
+    await local.present({ app, value: stored });
+    await store.changed(changeSet('', { presentation: app }));
+}
+export function roomDraftSurface(runtime) {
+    const { store } = runtime;
+    return {
+        list() {
+            return store
+                .exclusive(async () => {
+                await store.open();
+                return snapshotRoomDrafts(store);
+            })
+                .then((listed) => {
+                publishRoomDrafts(runtime, true);
+                return listed;
+            });
+        },
+        async read(room, path) {
+            const record = await store.draft(room, path);
+            return record === undefined ? null : ((await roomDraftsOf(store, [record]))[0] ?? null);
+        },
+        write(room, path, revision, input, next = roomDraftRevision()) {
+            if (typeof next !== 'string' || next === '')
+                return Promise.reject(runtimeError('room-draft-malformed'));
+            return store.gathered(`room-draft\u0000${room}\u0000${path}`, { revision, input, next }, (earlier, later) => {
+                if (later.revision !== earlier.next)
+                    return null;
+                const parts = gatheredParts(earlier.input, later.input);
+                return parts === null
+                    ? null
+                    : { revision: earlier.revision, input: parts, next: later.next };
+            }, (written) => writtenRoomDraft(runtime, room, path, written.revision, written.input, written.next));
+        },
+        discard(room, path, revision) {
+            return store.exclusive(async () => {
+                const local = await store.open();
+                const current = await store.draft(room, path);
+                if (current === undefined || current.revision !== revision) {
+                    return staleWrite(current === undefined ? null : ((await roomDraftsOf(store, [current]))[0] ?? null));
+                }
+                await local.discardRoomDraft(room, path);
+                await store.changed(changeSet(room, { drafts: [path] }));
+                return { outcome: 'written', roomDraft: null };
+            });
+        },
+    };
+}
+export function presentationSurface(runtime) {
+    const { store } = runtime;
+    return {
+        read(app) {
+            return store.exclusive(() => presentationOf(store, app));
+        },
+        write(app, value) {
+            return store.exclusive(() => keptPresentation(runtime, app, () => structuredClone(value)));
+        },
+        edit(app, members) {
+            return store.gathered(`presentation\u0000${app}`, structuredClone(members), (earlier, later) => ({ ...earlier, ...later }), (edited) => keptPresentation(runtime, app, (kept) => Object.fromEntries([
+                ...Object.entries(plain(kept) ? kept : {}).filter(([member]) => !Object.hasOwn(edited, member)),
+                ...Object.entries(edited).filter(([, value]) => value !== null),
+            ])));
+        },
+    };
+}
+export function watchRoomDrafts({ store, socket }, deliver) {
+    const watcher = store.watch(ROOM_DRAFTS, deliver);
+    const unwatched = () => socket.closed() || !watcher.held();
+    void store
+        .exclusive(async () => {
+        await store.open();
+    })
+        .then(() => store.publication(async () => {
+        if (unwatched())
+            return;
+        const value = await snapshotRoomDrafts(store);
+        if (!unwatched())
+            watcher.answer(value);
+    }), () => { });
+    return watcher.stop;
+}
+export function watchPresentation({ store, socket }, app, deliver) {
+    const watcher = store.watch(presentationTopic(app), deliver);
+    void store
+        .exclusive(async () => {
+        const value = await presentationOf(store, app);
+        if (!socket.closed() && watcher.held())
+            watcher.answer(value);
+    })
+        .catch(() => { });
+    return watcher.stop;
+}

package/dist/rows.d.ts

@@ -1,37 +1,39 @@
-import { type Frontmatter } from '@agentshouse/mdmodel';
-import type { HeadChange } from './adapter.js';
-import type { BinaryFileRecord } from './binary.js';
+import { type HeldValue } from '@agentshouse/mdmodel';
+import type { SavedFacts } from './adapter.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[];
-    text: string | null;
-    change: HeadChange | null;
-    binary: BinaryFileRecord | null;
+type LinkKind = 'field' | 'link';
+type HeldLink = {
+    readonly kind: LinkKind;
+    readonly keys: string;
+    readonly places: string;
+    readonly target: string;
+    readonly field: 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 Described = {
+    readonly type: string | null;
+    readonly declared: string | null;
+    readonly queried: boolean;
+    readonly folder: string;
+    readonly fields: string | null;
+    readonly links: string | null;
+};
+export type Held = {
+    readonly type: string | null;
+    readonly fields: Readonly<Record<string, unknown>> | null;
+    readonly links: readonly string[];
+};
+export type Derived = {
+    readonly values: readonly HeldValue[];
+    readonly links: readonly HeldLink[];
 };
-export type Row = DocumentRow | ReferenceRow;
 export declare function documentKey(room: string, path: string): string;
 export declare function roomOfKey(key: string): string;
+export declare function pathOfKey(key: string): string;
 export declare function markdownPath(path: string): boolean;
-export declare function rowsOf(room: string, path: string, document: Frontmatter | null, composition: Composition, change: HeadChange | null, binary: BinaryFileRecord | null): readonly Row[];
+export declare function folderOf(path: string): string;
+export declare function writtenFacts(path: string, content: string, composition: Composition): SavedFacts | null;
+export declare function described(path: string, content: string | null, facts: SavedFacts | null): Described;
+export declare function heldOf(path: string, content: string | null, facts: SavedFacts | null): Held;
+export declare function derived(path: string, held: Held, composition: Composition): Derived;
 export {};
 //# sourceMappingURL=rows.d.ts.map

package/dist/rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EACjB,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,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACjC,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,YAAY,CAAC;AAM7C,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,WAAW,GAAG,IAAI,EAC5B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAC9B,SAAS,GAAG,EAAE,CA+DhB"}
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAClG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9D,KAAK,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAEjC,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC,CAAC;AAMF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAaD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,WAAW,GACvB,UAAU,GAAG,IAAI,CAQnB;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,KAAK,EAAE,UAAU,GAAG,IAAI,GACvB,SAAS,CAeX;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAK3F;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAYnF"}

package/dist/rows.js

@@ -1,4 +1,4 @@
-import { ARRAY_INDEX, escapePointer, references, target, } from '@agentshouse/mdmodel';
+import { byCodePoint, documentFacts, indexed, parse } from '@agentshouse/mdmodel';
 import { governing } from './collection.js';
 import { definitionOf } from './model.js';
 function keyOf(...parts) {
@@ -10,126 +10,69 @@ export function documentKey(room, path) {
 export function roomOfKey(key) {
     return key.split('\u0000')[1];
 }
-function plainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+export function pathOfKey(key) {
+    return key.split('\u0000')[2];
 }
-function compared(reading, exact, value) {
-    if (!reading.references.has(exact))
-        return value;
-    return (typeof value === 'string' ? target(reading.path, value) : null) ?? undefined;
+export function markdownPath(path) {
+    return path.endsWith('.md');
 }
-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);
+export function folderOf(path) {
+    return path.slice(0, Math.max(path.lastIndexOf('/'), 0));
 }
-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 byKey(_key, value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).sort(([one], [other]) => byCodePoint(one, other)));
 }
-function directoriesOf(path) {
-    const parts = path.split('/').slice(0, -1);
-    return ['', ...parts.map((_, index) => parts.slice(0, index + 1).join('/'))];
+function fieldsText(fields) {
+    return JSON.stringify(fields, byKey);
 }
-export function markdownPath(path) {
-    return path.endsWith('.md');
+export function writtenFacts(path, content, composition) {
+    const model = governing(composition, path);
+    const facts = documentFacts(path, parse(content, path), {
+        types: model.status === 'unavailable' ? {} : model.types,
+    });
+    return facts === null
+        ? null
+        : { ...facts, fields: JSON.parse(fieldsText(facts.fields)) };
 }
-export function rowsOf(room, path, document, composition, change, binary) {
-    const key = documentKey(room, path);
-    if (document === null || !markdownPath(path)) {
-        return [
-            {
-                key,
-                kind: 'document',
-                room,
-                path,
-                type: null,
-                fields: {},
-                values: {},
-                reached: {},
-                directories: directoriesOf(path),
-                text: null,
-                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(),
+export function described(path, content, facts) {
+    const folder = folderOf(path);
+    const unread = { type: null, fields: null, links: null, folder };
+    if (content === null)
+        return { ...unread, declared: null, queried: true };
+    if (facts === null)
+        return { ...unread, declared: null, queried: !markdownPath(path) };
+    const links = JSON.stringify(facts.links);
+    if (!markdownPath(path))
+        return { ...unread, declared: facts.type, queried: true, links };
+    return {
+        type: facts.type,
+        declared: facts.type,
+        queried: true,
+        folder,
+        fields: fieldsText(facts.fields),
+        links,
     };
-    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),
-            text: document.content,
-            change,
-            binary,
-        },
-        ...[...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,
-        })),
-    ];
+}
+export function heldOf(path, content, facts) {
+    if (content === null || facts === null)
+        return { type: null, fields: null, links: [] };
+    return markdownPath(path)
+        ? { type: facts.type, fields: facts.fields, links: facts.links }
+        : { type: null, fields: null, links: facts.links };
+}
+export function derived(path, held, composition) {
+    const stored = held.links.map((target) => ({
+        kind: 'link',
+        keys: '',
+        places: '',
+        target,
+        field: '',
+    }));
+    if (held.type === null || held.fields === null)
+        return { values: [], links: stored };
+    const definition = definitionOf(governing(composition, path), held.type);
+    const { values, links: fields } = indexed(path, held.fields, definition);
+    return { values, links: [...fields, ...stored] };
 }

package/dist/runtime.d.ts

@@ -0,0 +1,42 @@
+import type { Authorization, DiscoveredRoom, ScopedRefusal, TypedPath } from './adapter.js';
+import type { ChangeSet } from './change-set.js';
+import type { ChangeBatch } from './change.js';
+import type { RuntimeShell } from './durability.js';
+import type { ConversationStore } from './conversation.js';
+import type { FiguresRead } from './figures.js';
+import type { Withheld } from './install.js';
+import type { LiveQueries } from './live.js';
+import type { Log } from './log.js';
+import type { ModelState } from './model.js';
+import type { ReadAnswers } from './reads.js';
+import type { Recovery } from './recovery.js';
+import type { ReplicaRecord } from './replica.js';
+import type { RuntimeSocket, RoomDeclaration } from './socket.js';
+import type { CycleProgress } from './status.js';
+import type { Settling } from './saves.js';
+import type { HeldCover, RuntimeStore, Store, Work } from './store.js';
+import type { schemaTypes } from './attached-model.js';
+export type Runtime = {
+    readonly store: Store;
+    readonly socket: RuntimeSocket;
+    readonly journal: Log;
+    readonly recovery: Recovery;
+    readonly shell: RuntimeShell;
+    readonly localSaves: boolean;
+    readonly roomTypes: Parameters<typeof schemaTypes>[1];
+    readonly builtIn: ModelState;
+    readonly typedPaths: readonly TypedPath[];
+    readonly usableWhenHeld: readonly string[];
+    readonly build: string;
+    readonly conversations: ConversationStore;
+    readonly liveQueries: LiveQueries<HeldCover>;
+    readonly figures: FiguresRead;
+    readonly lastAnswers: ReadAnswers;
+    settle(local: RuntimeStore, locator: string, work: Work, record: ReplicaRecord, queue: readonly ChangeBatch[], settling?: Settling): Promise<ChangeSet>;
+    scoped(result: ScopedRefusal, room: RoomDeclaration, local: RuntimeStore): Promise<void>;
+    submitLater(locator: string): void;
+    unpair(local: RuntimeStore): Promise<void>;
+    advanced(room: DiscoveredRoom, local: RuntimeStore, authorized: Authorization): Promise<Withheld | null>;
+    withhold(withheld: Withheld, room: DiscoveredRoom, local: RuntimeStore, progress: CycleProgress): Promise<void>;
+};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/runtime.js

@@ -0,0 +1 @@
+export {};

package/dist/save.d.ts

@@ -1,6 +1,8 @@
-import type { ProviderLimit } from './adapter.js';
+import { type Validation } from '@agentshouse/mdmodel';
+import type { OperationScopes, ProviderLimit } from './adapter.js';
 import { type Change, type ChangeBatch, type Precondition, type WrittenBy } from './change.js';
 import { type Composition } from './collection.js';
+import { type Layer } from './overlay.js';
 import type { VisibleLayer } from './replica.js';
 import type { ChangedPart } from './room-draft.js';
 export type SaveRefusal = {
@@ -19,25 +21,29 @@ export type SaveInput = {
     providerOwnedPaths: readonly string[];
     providerLimits: readonly ProviderLimit[];
     visible: VisibleLayer;
+    folders: ReadonlySet<string>;
     handle: string;
     changes: readonly Change[];
     bases: readonly Precondition[];
     queued?: ReadonlySet<string>;
     writtenBy?: WrittenBy;
-    clean?: {
-        text: Readonly<Record<string, string>>;
-        binaries: Readonly<Record<string, unknown>>;
-        composition: Composition;
-    };
+    unmodeled: boolean;
+    validate: Validator;
 };
-export type BatchResult = {
-    kind: 'batch';
-    batch: ChangeBatch;
-} | {
+export type Validator = (resulting: Layer, touched: readonly string[]) => Promise<Validation>;
+type Refusing = {
     kind: 'refused';
     refusal: SaveRefusal;
 };
-export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): ChangeBatch;
+export type BatchResult = {
+    kind: 'batch';
+    batch: ChangeBatch;
+} | Refusing;
+export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
+export declare function leavingRewritten(batch: ChangeBatch, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
+export declare function rewriting(batch: ChangeBatch, locator: string): boolean;
+export declare function effectiveIn(batch: ChangeBatch, locator: string, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
+export declare function queuedDocuments(queue: readonly ChangeBatch[]): ReadonlySet<string>;
 export type Requeued = {
     kind: 'requeued';
     queue: readonly ChangeBatch[];
@@ -57,8 +63,41 @@ export type Joining = {
     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;
+type VisibleOver = (queue: readonly ChangeBatch[]) => Generator<number, VisibleLayer, void>;
+export declare function requeuing(queue: readonly ChangeBatch[], changes: readonly Change[], visible: VisibleLayer, changeable: (batch: ChangeBatch) => boolean, state: VisibleOver): Generator<number, Requeued, void>;
 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;
+export declare function limiting(queue: readonly ChangeBatch[], batch: ChangeBatch, limits: readonly ProviderLimit[], state: VisibleOver): Generator<number, SaveRefusal | null, void>;
+export declare const MOVE_DOCUMENTS = "move-documents";
+export type MoveSide = {
+    room: string;
+    handle: string;
+    baseRoomVersion: string;
+    composition: Composition;
+    operations: OperationScopes;
+    providerOwnedPaths: readonly string[];
+    visible: VisibleLayer;
+    folders: ReadonlySet<string>;
+    queued: ReadonlySet<string>;
+    unmodeled: boolean;
+    validate: Validator;
+};
+export type MoveInput = {
+    source: MoveSide;
+    destination: MoveSide;
+    moves: readonly {
+        readonly path: string;
+        readonly to: string;
+    }[];
+    providerLimits: readonly ProviderLimit[];
+    local: boolean;
+    writtenBy?: WrittenBy;
+};
+export type MoveResult = {
+    kind: 'moved';
+    leaving: ChangeBatch;
+    arriving: ChangeBatch;
+} | Refusing;
+export declare function buildMove(input: MoveInput): Promise<MoveResult>;
+export declare function buildBatch(input: SaveInput): Promise<BatchResult>;
+export {};
 //# sourceMappingURL=save.d.ts.map