@agentshouse/mdruntime 0.1.0-ca7c26c6bc27e → 0.1.0-ca8707258fdde

package/dist/replica.js

@@ -1,163 +1,215 @@
-import { parse } from '@agentshouse/mdmodel';
-import { immutable } from './change.js';
-import { parseCollection, readCollection, validateCollection, } from './collection.js';
-import { overlay, overlayChanged, sameLayerText } from './overlay.js';
-import { providerRewritten } from './save.js';
-import { equalValue } from './room-draft.js';
-import { declaredAttachments } from './attachment.js';
-export function compositionOf(record) {
+import { equalValue, parse } from '@agentshouse/mdmodel';
+import { immutable, landing } from './change.js';
+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,
     };
 }
-export function readConfirmed(record, previous) {
-    const read = readCollection(record.documents, compositionOf(record), previous === undefined
-        ? undefined
-        : { text: previous.record.documents, collection: previous.collection });
-    return read.kind === 'read'
-        ? { kind: 'staged', confirmed: { record, collection: read.collection } }
-        : read;
+export function storedRecord(record) {
+    const { key: _key, ...stored } = record;
+    return JSON.stringify({ ...stored, model: storedModel(stored.model) });
 }
-export function sameMembership(record, other) {
-    return (JSON.stringify(record.typedSelection?.roots ?? null) ===
-        JSON.stringify(other.typedSelection?.roots ?? null));
+const PROBES = new Set([
+    'then',
+    'toJSON',
+    'constructor',
+    'valueOf',
+    'toString',
+]);
+class UnreadPath extends Error {
+    constructor(path) {
+        super(`the replica slice holds no row for ${path}`);
+    }
 }
-export function readStaged(record, previous) {
-    if ((record.model.status !== 'unavailable' || record.selectionModel.status !== 'unavailable') &&
-        (previous === undefined ||
-            !sameLayerText(record, previous.record) ||
-            record.model !== previous.record.model ||
-            record.selectionModel !== previous.record.selectionModel)) {
-        const verdict = validateCollection(record.documents, record.binaryTargets, compositionOf(record));
-        if (verdict.verdict === 'refuse' && verdict.rule !== 'model-unavailable') {
-            return { kind: 'refused', refusal: verdict };
+function strict(values, held) {
+    const guard = (property) => {
+        if (typeof property === 'string' && !held.has(property) && !PROBES.has(property)) {
+            throw new UnreadPath(property);
         }
-    }
-    return readConfirmed(record, previous);
+    };
+    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 readReclassified(record, previous) {
-    const verdict = validateCollection(record.documents, record.binaryTargets, compositionOf(record));
-    if (verdict.verdict !== 'refuse')
-        return readConfirmed(record, previous);
-    return verdict.rule === 'model-unavailable'
-        ? { kind: 'deferred' }
-        : { kind: 'refused', refusal: verdict };
+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,
+    };
 }
-export function applyReturned(confirmed, documents, revisions, removals, attachments, roomVersion, writtenAt) {
-    const nextDocuments = { ...confirmed.record.documents, ...documents };
-    const nextRevisions = { ...confirmed.record.revisions, ...revisions };
-    const nextChanges = { ...confirmed.record.changes };
-    const nextWritten = {
-        ...confirmed.record.written,
-        ...Object.fromEntries(Object.keys(documents).map((path) => [path, writtenAt])),
+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,
     };
-    const binaryTargets = new Set(confirmed.record.binaryTargets);
-    for (const [path, revision] of Object.entries(revisions)) {
-        if (confirmed.record.revisions[path] !== revision)
-            delete nextChanges[path];
+}
+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;
     }
-    for (const path of removals) {
-        delete nextDocuments[path];
-        delete nextRevisions[path];
-        delete nextChanges[path];
-        delete nextWritten[path];
-        binaryTargets.delete(path);
+    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]);
+}
+function changePaths(change) {
+    return change.kind === 'move' ? [change.path, change.to] : [change.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: nextDocuments,
-        revisions: nextRevisions,
-        changes: nextChanges,
-        written: nextWritten,
-        binaryTargets: [...binaryTargets].sort(),
-        attachments: attachments === undefined
-            ? confirmed.record.attachments
-            : declaredAttachments([attachments]),
-    }, 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
-                : parseCollection(before.documents, composition, old?.collection === undefined
-                    ? { text: confirmed.record.documents, collection: confirmed.collection }
-                    : { text: old.before.documents, collection: old.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, rewriting, previous) {
-    const batches = Object.freeze(queue.map(immutable));
-    if (batches.length === 0) {
-        return {
-            confirmed,
-            queue: batches,
-            visible: {
-                documents: confirmed.record.documents,
-                binaryTargets: confirmed.record.binaryTargets,
-                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 predictedState = rewriting === 'provider' ? predicted(confirmed, batches, previous) : null;
-    const layer = rewriting === 'provider'
-        ? predictedState.layer
-        : previous === undefined
-            ? overlay(confirmed.record, batches)
-            : overlayChanged(confirmed.record, batches, previous.confirmed.record, previous.queue, previous.visible);
     return {
-        confirmed,
-        queue: batches,
-        replay: predictedState?.replay ?? [],
-        visible: {
-            ...layer,
-            collection: parseCollection(layer.documents, compositionOf(confirmed.record), previous === undefined
-                ? undefined
-                : { text: previous.visible.documents, collection: previous.visible.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.binaryTargets.includes(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)) {
@@ -176,6 +228,8 @@ function holds(layer, preconditions) {
         if (precondition.kind === 'revision') {
             return present(layer, path) && layer.revisions[path] === precondition.revision;
         }
+        if (precondition.kind === 'content')
+            return layer.documents[path] === precondition.content;
         const document = documentAt(path);
         if (document === null)
             return false;
@@ -220,53 +274,192 @@ function effects(change) {
             { kind: 'present', path: change.to },
         ];
     }
+    if (change.kind === 'binary' || change.kind === 'arrival')
+        return [{ kind: 'present', path }];
     return [{ kind: 'absent', path }];
 }
-function after(changes, index, path) {
-    let at = path;
-    for (const change of changes.slice(index + 1)) {
-        if (change.path !== at)
-            continue;
-        if (change.kind === 'remove')
-            return null;
-        if (change.kind === 'move')
-            at = change.to;
-    }
-    return at;
-}
-export function landed(batch, confirmed) {
-    const layer = confirmed.record;
+export function landed(batch, confirmed, 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 = after(batch.changes, index, change.path);
+            const at = landing(batch.changes, index, change.path);
             return at === null || layer.documents[at] === change.content;
         }
+        if (change.kind === 'binary') {
+            const at = landing(batch.changes, index, change.path);
+            return at === null || layer.binaries[at]?.sha256 === change.sha256;
+        }
         return effects(change).every((effect) => {
             if (effect.kind === 'absent')
                 return holds(layer, [effect]);
-            const at = after(batch.changes, index, effect.path);
+            const at = landing(batch.changes, index, effect.path);
             return at === null || holds(layer, [{ ...effect, path: at }]);
         });
     });
 }
-export function withdrawals(confirmed, queue, withdrawable, rewriting) {
+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 = rewriting === 'provider' && batch.changes.some((change) => change.kind === 'move')
-            ? providerRewritten(batch, {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
                 ...layer,
-                collection: parseCollection(layer.documents, composition),
+                collection: collectionOf(layer.documents, composition),
             })
             : batch;
-        layer = overlay(layer, [effective]);
+        let unapplied = false;
+        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, 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 withdrawn;
+    return { set, removed };
 }