@agentshouse/mdruntime 0.1.0-cdb8840578a20 → 0.1.0-cdded6c080913

package/dist/replica.js

@@ -1,199 +1,215 @@
 import { equalValue, parse } from '@agentshouse/mdmodel';
 import { immutable, landing } from './change.js';
-import { changedCleanly, collectionOf, unreadable, validateCollection, } from './collection.js';
-import { acceptedBinaries, overlay, overlayChanged, sameLayerText, } from './overlay.js';
-import { providerRewritten } from './save.js';
-import { drafted, patched, settled, shared } from './shared.js';
-export function compositionOf(record) {
+import { collectionOf } from './collection.js';
+import { storedModel } from './model.js';
+import { acceptedBinaries, overlaying } from './overlay.js';
+import { writtenFacts } from './rows.js';
+import { effectiveIn, rewriting } from './save.js';
+import { ROW_WEIGHT } from './turn.js';
+export function compositionOf(record, builtIn, typedPaths) {
     return {
         model: record.model,
         selection: record.typedSelection === null
             ? null
-            : { roots: record.typedSelection.roots, model: record.selectionModel },
+            : { roots: record.typedSelection.roots, model: builtIn },
+        typedPaths,
     };
 }
-function held(record) {
-    const documents = shared(record.documents);
-    const binaries = shared(record.binaries);
-    const revisions = shared(record.revisions);
-    const changes = shared(record.changes);
-    const written = shared(record.written);
-    return documents === record.documents &&
-        binaries === record.binaries &&
-        revisions === record.revisions &&
-        changes === record.changes &&
-        written === record.written
-        ? record
-        : { ...record, documents, binaries, revisions, changes, written };
+export function storedRecord(record) {
+    const { key: _key, ...stored } = record;
+    return JSON.stringify({ ...stored, model: storedModel(stored.model) });
 }
-export function confirmedOf(record, previous) {
-    const kept = held(record);
-    return {
-        record: kept,
-        collection: collectionOf(kept.documents, compositionOf(kept), previous?.collection),
+const PROBES = new Set([
+    'then',
+    'toJSON',
+    'constructor',
+    'valueOf',
+    'toString',
+]);
+class UnreadPath extends Error {
+    constructor(path) {
+        super(`the replica slice holds no row for ${path}`);
+    }
+}
+function strict(values, held) {
+    const guard = (property) => {
+        if (typeof property === 'string' && !held.has(property) && !PROBES.has(property)) {
+            throw new UnreadPath(property);
+        }
     };
+    return new Proxy(values, {
+        get(target, property, receiver) {
+            guard(property);
+            return Reflect.get(target, property, receiver);
+        },
+        has(target, property) {
+            guard(property);
+            return Reflect.has(target, property);
+        },
+        getOwnPropertyDescriptor(target, property) {
+            guard(property);
+            return Reflect.getOwnPropertyDescriptor(target, property);
+        },
+    });
 }
-export function sameMembership(record, other) {
-    return (JSON.stringify(record.typedSelection?.roots ?? null) ===
-        JSON.stringify(other.typedSelection?.roots ?? null));
+export function* slicing(entries, paths) {
+    const held = new Set(paths);
+    for (const entry of entries)
+        held.add(entry.path);
+    const documents = {};
+    const binaries = {};
+    const revisions = {};
+    const fileIds = {};
+    const created = {};
+    const changes = {};
+    const written = {};
+    const facts = {};
+    for (const entry of entries) {
+        if (entry.facts !== null)
+            facts[entry.path] = entry.facts;
+        if (entry.binary !== null)
+            binaries[entry.path] = entry.binary;
+        else if (entry.content !== null)
+            documents[entry.path] = entry.content;
+        if (entry.revision !== null)
+            revisions[entry.path] = entry.revision;
+        if (entry.fileId !== null)
+            fileIds[entry.path] = entry.fileId;
+        if (entry.created !== null)
+            created[entry.path] = entry.created;
+        if (entry.change !== null)
+            changes[entry.path] = entry.change;
+        if (entry.written !== null)
+            written[entry.path] = entry.written;
+        yield ROW_WEIGHT;
+    }
+    return {
+        documents: strict(documents, held),
+        binaries: strict(binaries, held),
+        revisions: strict(revisions, held),
+        fileIds: strict(fileIds, held),
+        created: strict(created, held),
+        changes: strict(changes, held),
+        written: strict(written, held),
+        facts: strict(facts, held),
+        held,
+    };
 }
-function cleanly(record, previous) {
-    if (previous === undefined)
-        return false;
-    const before = previous.record;
-    return changedCleanly({ text: record.documents, binaries: record.binaries }, { text: before.documents, binaries: before.binaries, composition: compositionOf(before) }, compositionOf(record));
+export function entryAt(layer, path) {
+    const content = layer.documents[path];
+    const binary = layer.binaries[path];
+    if (content === undefined && binary === undefined)
+        return null;
+    return {
+        path,
+        content: content ?? null,
+        binary: binary ?? null,
+        revision: layer.revisions[path] ?? null,
+        fileId: layer.fileIds[path] ?? null,
+        created: layer.created[path] ?? null,
+        change: layer.changes[path] ?? null,
+        written: layer.written?.[path] ?? null,
+    };
 }
-export function readStaged(staged, previous) {
-    const record = held(staged);
-    const textChanged = previous === undefined || !sameLayerText(record, previous.record);
-    const modeled = record.model.status !== 'unavailable' || record.selectionModel.status !== 'unavailable';
-    if (modeled &&
-        (textChanged ||
-            record.model !== previous?.record.model ||
-            record.selectionModel !== previous?.record.selectionModel) &&
-        !cleanly(record, previous)) {
-        const verdict = validateCollection(record.documents, Object.keys(record.binaries), compositionOf(record));
-        if (verdict.verdict === 'refuse' && verdict.rule !== 'model-unavailable') {
-            return { kind: 'refused', refusal: verdict };
-        }
-        if (verdict.verdict === 'refuse') {
-            const refused = unreadable(record.documents, previous?.record.documents);
-            if (refused !== null)
-                return refused;
+export function* slicingWith(slice, set, removed) {
+    const entries = new Map();
+    for (const path of slice.held) {
+        const entry = entryAt(slice, path);
+        if (entry !== null) {
+            entries.set(path, { ...entry, type: null, facts: slice.facts[path] ?? null });
         }
+        yield ROW_WEIGHT;
     }
-    else if (textChanged) {
-        const refused = unreadable(record.documents, previous?.record.documents);
-        if (refused !== null)
-            return refused;
-    }
-    return { kind: 'staged', confirmed: confirmedOf(record, previous) };
+    for (const path of removed)
+        entries.delete(path);
+    for (const entry of set)
+        entries.set(entry.path, { ...entry, type: null });
+    return yield* slicing([...entries.values()], [...slice.held, ...set.map(({ path }) => path), ...removed]);
 }
-export function readReclassified(record, previous) {
-    const verdict = validateCollection(record.documents, Object.keys(record.binaries), compositionOf(record));
-    if (verdict.verdict !== 'refuse')
-        return { kind: 'staged', confirmed: confirmedOf(record, previous) };
-    return verdict.rule === 'model-unavailable'
-        ? { kind: 'deferred' }
-        : { kind: 'refused', refusal: verdict };
+function changePaths(change) {
+    return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
-function returnedBinaries(held, submitted, accepted) {
-    const binaries = drafted(held);
-    for (const change of submitted.changes) {
-        if (change.kind !== 'move')
-            continue;
-        const moved = binaries[change.path];
-        if (moved === undefined || accepted.revisions[change.to] === undefined)
-            continue;
-        binaries[change.to] = moved;
-        delete binaries[change.path];
-    }
-    Object.assign(binaries, acceptedBinaries(accepted.binaryFiles ?? {}));
-    for (const path of accepted.removals)
-        delete binaries[path];
-    return settled(binaries);
-}
-export function applyReturned(confirmed, submitted, accepted, roomVersion, writtenAt) {
-    const { documents, revisions, changes, removals } = accepted;
-    const nextDocuments = drafted(confirmed.record.documents);
-    const nextRevisions = drafted(confirmed.record.revisions);
-    const nextChanges = drafted(confirmed.record.changes);
-    const nextWritten = drafted(confirmed.record.written);
-    Object.assign(nextDocuments, documents);
-    Object.assign(nextRevisions, revisions);
-    for (const path of Object.keys(documents))
-        nextWritten[path] = writtenAt;
-    for (const [path, revision] of Object.entries(revisions)) {
-        if (confirmed.record.revisions[path] !== revision)
-            delete nextChanges[path];
-    }
-    Object.assign(nextChanges, changes);
-    for (const path of removals) {
-        delete nextDocuments[path];
-        delete nextRevisions[path];
-        delete nextChanges[path];
-        delete nextWritten[path];
+export function touchedBy(queue) {
+    const paths = new Set();
+    for (const batch of queue) {
+        for (const change of batch.changes)
+            for (const path of changePaths(change))
+                paths.add(path);
+        for (const precondition of batch.preconditions)
+            paths.add(precondition.path);
+        for (const move of batch.between?.moves ?? [])
+            paths.add(move.path);
     }
-    return readStaged({
-        ...confirmed.record,
-        roomVersion,
-        documents: settled(nextDocuments),
-        revisions: settled(nextRevisions),
-        changes: settled(nextChanges),
-        written: settled(nextWritten),
-        binaries: returnedBinaries(confirmed.record.binaries, submitted, accepted),
-    }, confirmed);
+    return paths;
 }
-function predicted(confirmed, batches, previous) {
-    const composition = compositionOf(confirmed.record);
-    let layer = confirmed.record;
-    const replay = [];
-    const prior = new Map(previous?.replay.map((step) => [step.id, step]) ?? []);
-    for (const batch of batches) {
-        const before = layer;
-        const old = prior.get(batch.id);
-        const hasMove = batch.changes.some((change) => change.kind === 'move');
-        const reuseRewrite = old?.collection !== undefined &&
-            sameLayerText(before, old.before) &&
-            old.collection.composition.model === composition.model &&
-            old.collection.composition.selection?.model === composition.selection?.model &&
-            JSON.stringify(old.collection.composition.selection?.roots) ===
-                JSON.stringify(composition.selection?.roots);
-        const collection = hasMove
-            ? reuseRewrite
-                ? old.collection
-                : collectionOf(before.documents, composition, old?.collection ?? confirmed.collection)
-            : undefined;
-        const effective = collection === undefined
-            ? batch
-            : reuseRewrite
-                ? old.effective
-                : providerRewritten(batch, { ...before, collection });
-        layer =
-            old === undefined
-                ? overlay(before, [effective])
-                : overlayChanged(before, [effective], old.before, [old.effective], old.after);
-        replay.push({
-            id: batch.id,
-            before,
-            after: layer,
-            effective,
-            ...(collection === undefined ? {} : { collection }),
-        });
+export function movedBy(queue, locator) {
+    const paths = new Set();
+    for (const batch of queue) {
+        if (!rewriting(batch, locator))
+            continue;
+        for (const change of batch.changes)
+            if (change.kind === 'move')
+                paths.add(change.path);
+        if (batch.between?.source.room === locator) {
+            for (const move of batch.between.moves)
+                paths.add(move.path);
+        }
     }
-    return { layer, replay };
+    return paths;
 }
-export function replicaOf(confirmed, queue, previous) {
-    const batches = Object.freeze(queue.map(immutable));
-    if (batches.length === 0) {
-        return {
-            confirmed,
-            queue: batches,
-            visible: {
-                documents: confirmed.record.documents,
-                binaries: confirmed.record.binaries,
-                revisions: confirmed.record.revisions,
-                changes: confirmed.record.changes,
-                collection: confirmed.collection,
-            },
-            replay: [],
-        };
+export function* replaying(confirmed, queue, locator, composition) {
+    let layer = confirmed;
+    const touched = new Set();
+    for (const batch of queue) {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
+                ...layer,
+                collection: collectionOf(layer.documents, composition),
+            })
+            : batch;
+        for (const change of effective.changes)
+            for (const path of changePaths(change))
+                touched.add(path);
+        layer = yield* overlaying(layer, [effective]);
+        yield ROW_WEIGHT;
     }
-    const { layer, replay } = predicted(confirmed, batches, previous);
     return {
-        confirmed,
-        queue: batches,
-        replay,
-        visible: {
-            ...layer,
-            collection: collectionOf(layer.documents, compositionOf(confirmed.record), previous?.visible.collection ?? confirmed.collection),
-        },
+        visible: { ...layer, collection: collectionOf(layer.documents, composition) },
+        touched,
     };
 }
+export function* overlayOf(visible, touched) {
+    const rows = [];
+    for (const path of touched) {
+        const entry = entryAt(visible, path);
+        yield ROW_WEIGHT + (entry?.content?.length ?? 0);
+        const text = entry?.binary === null ? entry.content : null;
+        rows.push(entry === null
+            ? {
+                path,
+                present: false,
+                content: null,
+                binary: null,
+                revision: null,
+                fileId: null,
+                created: null,
+                change: null,
+                written: null,
+                facts: null,
+            }
+            : {
+                ...entry,
+                written: null,
+                present: true,
+                facts: text === null ? null : writtenFacts(path, text, visible.collection.composition),
+            });
+    }
+    return rows;
+}
 function present(layer, path) {
     return layer.documents[path] !== undefined || layer.binaries[path] !== undefined;
 }
-function holds(layer, preconditions) {
+export function holds(layer, preconditions) {
     const parsed = new Map();
     const documentAt = (path) => {
         if (!parsed.has(path)) {
@@ -258,15 +274,19 @@ function effects(change) {
             { kind: 'present', path: change.to },
         ];
     }
-    if (change.kind === 'binary')
+    if (change.kind === 'binary' || change.kind === 'arrival')
         return [{ kind: 'present', path }];
     return [{ kind: 'absent', path }];
 }
 export function landed(batch, confirmed, current = {}) {
-    const layer = {
-        ...confirmed.record,
-        documents: patched(confirmed.record.documents, Object.entries(current)),
-    };
+    const documents = new Proxy(confirmed.documents, {
+        get(target, property, receiver) {
+            if (typeof property === 'string' && Object.hasOwn(current, property))
+                return current[property];
+            return Reflect.get(target, property, receiver);
+        },
+    });
+    const layer = { ...confirmed, documents };
     return batch.changes.every((change, index) => {
         if (change.kind === 'replace' || (change.kind === 'create' && 'content' in change)) {
             const at = landing(batch.changes, index, change.path);
@@ -284,32 +304,162 @@ export function landed(batch, confirmed, current = {}) {
         });
     });
 }
-export function withdrawals(confirmed, queue, withdrawable, local) {
+function founded(batch, layer) {
+    let changed = false;
+    const preconditions = batch.preconditions.map((precondition) => {
+        if (precondition.kind !== 'content')
+            return precondition;
+        const revision = layer.revisions[precondition.path];
+        if (revision === undefined || layer.documents[precondition.path] !== precondition.content) {
+            return precondition;
+        }
+        changed = true;
+        return { kind: 'revision', path: precondition.path, revision };
+    });
+    return changed ? immutable({ ...batch, preconditions }) : batch;
+}
+export function* standing(confirmed, queue, withdrawable, local, locator, composition) {
     if (!queue.some(withdrawable))
-        return [];
-    const composition = compositionOf(confirmed.record);
-    let layer = confirmed.record;
+        return { withdrawn: [], kept: queue };
+    let layer = confirmed;
     const withdrawn = [];
+    const kept = [];
     for (const batch of queue) {
         if (withdrawable(batch) && !holds(layer, batch.preconditions)) {
             withdrawn.push(batch);
             continue;
         }
-        const effective = batch.changes.some((change) => change.kind === 'move')
-            ? providerRewritten(batch, {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
                 ...layer,
                 collection: collectionOf(layer.documents, composition),
             })
             : batch;
         let unapplied = false;
-        const next = overlay(layer, [effective], () => {
+        const next = yield* overlaying(layer, [effective], () => {
             unapplied = true;
         });
         if (local && unapplied) {
             withdrawn.push(batch);
             continue;
         }
+        kept.push(local || !withdrawable(batch) ? batch : founded(batch, layer));
         layer = next;
     }
-    return withdrawn;
+    return { withdrawn, kept };
+}
+export function returnedPaths(submitted, accepted) {
+    const paths = new Set([
+        ...Object.keys(accepted.documents),
+        ...Object.keys(accepted.revisions),
+        ...Object.keys(accepted.fileIds ?? {}),
+        ...Object.keys(accepted.changes),
+        ...Object.keys(accepted.binaryFiles ?? {}),
+        ...accepted.removals,
+    ]);
+    for (const change of submitted.changes) {
+        if (change.kind === 'move') {
+            paths.add(change.path);
+            paths.add(change.to);
+        }
+        if (change.kind === 'arrival')
+            paths.add(change.path);
+    }
+    return paths;
+}
+export function* returning(confirmed, submitted, accepted, writtenAt, composition) {
+    const documents = new Map();
+    const binaries = new Map();
+    const revisions = new Map();
+    const fileIds = new Map();
+    const created = new Map();
+    const changes = new Map();
+    const written = new Map();
+    const facts = new Map();
+    const read = (changed, held, path) => (changed.has(path) ? changed.get(path) : held[path]);
+    for (const [path, content] of Object.entries(accepted.documents)) {
+        yield ROW_WEIGHT + content.length;
+        documents.set(path, content);
+        facts.set(path, writtenFacts(path, content, composition));
+        fileIds.set(path, undefined);
+        written.set(path, writtenAt);
+    }
+    for (const [path, revision] of Object.entries(accepted.revisions)) {
+        yield ROW_WEIGHT;
+        revisions.set(path, revision);
+        fileIds.set(path, undefined);
+        if (confirmed.revisions[path] !== revision)
+            changes.set(path, undefined);
+    }
+    for (const [path, fileId] of Object.entries(accepted.fileIds ?? {}))
+        fileIds.set(path, fileId);
+    for (const [path, change] of Object.entries(accepted.changes))
+        changes.set(path, change);
+    for (const path of accepted.removals) {
+        documents.set(path, undefined);
+        revisions.set(path, undefined);
+        fileIds.set(path, undefined);
+        changes.set(path, undefined);
+        written.set(path, undefined);
+    }
+    for (const change of submitted.changes) {
+        if (change.kind === 'arrival') {
+            if (accepted.revisions[change.path] === undefined)
+                continue;
+            created.set(change.path, change.created);
+            if ('binary' in change)
+                binaries.set(change.path, { state: 'accepted', ...change.binary });
+            continue;
+        }
+        if (change.kind !== 'move' || accepted.revisions[change.to] === undefined)
+            continue;
+        created.set(change.to, read(created, confirmed.created, change.path));
+        created.set(change.path, undefined);
+        const moved = read(binaries, confirmed.binaries, change.path);
+        if (moved === undefined)
+            continue;
+        binaries.set(change.to, moved);
+        binaries.set(change.path, undefined);
+    }
+    for (const [path, binary] of acceptedBinaries(accepted.binaryFiles ?? {}))
+        binaries.set(path, binary);
+    for (const path of accepted.removals) {
+        binaries.set(path, undefined);
+        created.set(path, undefined);
+    }
+    const paths = new Set([
+        ...documents.keys(),
+        ...binaries.keys(),
+        ...revisions.keys(),
+        ...fileIds.keys(),
+        ...created.keys(),
+        ...changes.keys(),
+        ...written.keys(),
+    ]);
+    const set = [];
+    const removed = [];
+    for (const path of paths) {
+        const content = read(documents, confirmed.documents, path);
+        const binary = read(binaries, confirmed.binaries, path);
+        yield ROW_WEIGHT;
+        if (content === undefined && binary === undefined) {
+            removed.push(path);
+            continue;
+        }
+        const text = binary === undefined ? (content ?? null) : null;
+        const fresh = confirmed.documents[path] === undefined && confirmed.binaries[path] === undefined;
+        set.push({
+            path,
+            content: text,
+            facts: text === null ? null : (read(facts, confirmed.facts, path) ?? null),
+            binary: binary ?? null,
+            revision: read(revisions, confirmed.revisions, path) ?? null,
+            fileId: read(fileIds, confirmed.fileIds, path) ?? null,
+            created: read(created, confirmed.created, path) ??
+                (fresh ? (read(changes, confirmed.changes, path)?.time ?? null) : null),
+            change: read(changes, confirmed.changes, path) ?? null,
+            written: read(written, confirmed.written, path) ?? null,
+        });
+    }
+    return { set, removed };
 }

package/dist/room-draft.d.ts

@@ -32,6 +32,7 @@ export type RoomDraftParts = {
     readonly creation?: RoomDraftCreation;
     readonly move?: {
         readonly to: string;
+        readonly room?: string;
         readonly base?: string | null;
     };
     readonly removal?: {
@@ -39,11 +40,12 @@ export type RoomDraftParts = {
     };
     readonly file?: {
         readonly blob: Blob;
+        readonly base?: string | null;
     };
 };
 export type HeldFile = {
-    readonly blob: Blob;
     readonly localId: string;
+    readonly name?: string;
     readonly byteLength: number;
     readonly mediaType: string;
     readonly sha256: string;
@@ -69,6 +71,7 @@ type HeldParts = {
     readonly creation?: RoomDraftCreation;
     readonly move?: {
         readonly to: string;
+        readonly room?: string;
         readonly base: string | null;
     };
     readonly removal?: {
@@ -87,9 +90,9 @@ type ChangedUnderneath = {
     readonly file?: string | null;
 };
 export type ReturnReason = ProviderRefusal & {
-    readonly kind: Open<'conflicted' | 'rejected' | 'expired' | 'withdrawn'>;
+    readonly kind: Open<'conflicted' | 'rejected' | 'withdrawn'>;
 };
-export declare function returnedBy(kind: 'expired' | 'withdrawn'): ReturnReason;
+export declare function returnedBy(kind: 'withdrawn'): ReturnReason;
 export type RoomDraft = {
     readonly room: string;
     readonly path: string;
@@ -110,7 +113,7 @@ export type RoomDraftWrite = {
 export declare function staleWrite(current: RoomDraft | null): RoomDraftWrite;
 export type ChangedPart = {
     readonly path: string;
-    readonly part: Open<'field' | 'section' | 'preamble' | 'markdown' | 'creation' | 'move' | 'removal' | 'file'>;
+    readonly part: Open<'field' | 'section' | 'preamble' | 'markdown' | 'move' | 'removal' | 'file'>;
     readonly name?: string;
 };
 export type RoomDraftRecord = {
@@ -124,16 +127,44 @@ export type SavedDraft = {
     readonly path: string;
     readonly parts: HeldParts;
 };
-export declare function readParts(value: unknown): RoomDraftParts;
+export declare function readParts(value: unknown, path: string): RoomDraftParts;
+export declare function gatheredParts(earlier: unknown, later: unknown): unknown;
 export declare function held(current: HeldParts | undefined, parts: RoomDraftParts, file?: HeldFile): HeldParts;
 export declare function underneath(parts: HeldParts, path: string, visible: VisibleLayer | undefined): ChangedUnderneath;
 export declare function heldFile(blob: Blob, base: string | null): Promise<HeldFile>;
 export declare function binaryBase(visible: VisibleLayer | undefined, path: string): string | null;
-export declare function changedParts(path: string, report: ChangedUnderneath): readonly ChangedPart[];
+export declare function changedParts(path: string, parts: HeldParts, visible: VisibleLayer | undefined): readonly ChangedPart[];
+export declare function lineEnded(text: string): string;
+export type TextParts = {
+    readonly fields?: Readonly<Record<string, {
+        readonly value: unknown;
+    }>>;
+    readonly sections?: Readonly<Record<string, {
+        readonly value: string;
+    }>>;
+    readonly preamble?: {
+        readonly value: string;
+    };
+};
+export declare function partsAfter(markdown: string, parts: TextParts): string;
 export declare function returnedInto(existing: HeldParts | undefined, returned: HeldParts): HeldParts;
 export declare function moveTarget(move: {
     readonly to: string;
 }): string;
+export declare function readSavedParts(named: readonly {
+    readonly path: string;
+    readonly parts: unknown;
+}[]): readonly {
+    readonly path: string;
+    readonly parts: RoomDraftParts;
+}[];
+export declare function partsChanges(named: readonly {
+    readonly path: string;
+    readonly parts: unknown;
+}[]): {
+    readonly changes: readonly Change[];
+    readonly preconditions: readonly Precondition[];
+};
 export declare function changesOf(path: string, parts: HeldParts): {
     changes: readonly Change[];
     bases: readonly Precondition[];