@agentshouse/mdruntime 0.1.0-cfbf80d8d4644 → 0.1.0-cfe148b32e3d8

package/dist/outcome.d.ts

@@ -1,8 +1,64 @@
-import type { ActionResult } from './adapter.js';
+import type { ActionResult, AdapterFailure, BinaryLinkResult, HistoryResult, HistoryRevision, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
 import type { ChangeBatch } from './change.js';
-export type CallResult = ActionResult | {
-    kind: 'undeclared';
+import type { KeptBinary, KeptResult } from './opened.js';
+type Refused<Kind extends string> = ProviderRefusal & {
+    kind: Kind;
 };
+export type Failure = Refused<'transport-uncertainty'> | Refused<'revoked-authorization'> | (Refused<'room-not-readable'> & {
+    locator: string;
+}) | (Refused<'room-locked'> & {
+    locator: string;
+}) | ScopedRefusal;
+export type CallResult = {
+    kind: 'action';
+    result: unknown;
+    at?: RoomVersionAt;
+} | Refused<'rejected'> | Refused<'undeclared'> | Failure;
+export type HistoryAnswer = Exclude<HistoryResult, {
+    kind: Failure['kind'];
+}> | Failure;
+type BinaryRefusal = Refused<'rejected'> | Refused<'absent'> | Failure;
+export type BinaryAnswer = {
+    kind: 'binary';
+    stream: ReadableStream<Uint8Array>;
+    byteLength: number;
+    mediaType: string;
+} | BinaryRefusal;
+export type HeldBinaryAnswer = KeptBinary | BinaryRefusal;
+export type BinaryLinkAnswer = {
+    kind: 'link';
+    url: string;
+    name: string;
+} | Refused<'rejected'> | Refused<'absent'> | Failure;
+export type Resolution = {
+    readonly kind: 'document';
+    readonly room: string;
+    readonly path: string;
+} | {
+    readonly kind: 'deleted';
+    readonly room: string;
+    readonly path: string;
+    readonly revision: HistoryRevision;
+} | Refused<'unreadable'> | Refused<'absent'> | Failure;
+export declare const UNREADABLE: Refused<'unreadable'>;
+export declare const LOCKED_UNREADABLE: Refused<'unreadable'>;
+export declare const ABSENT_TARGET: Refused<'absent'>;
+export declare function absentBinary(path: string): Refused<'absent'>;
+export declare function binaryAnswer(result: KeptResult): HeldBinaryAnswer;
+export declare function binaryLinkAnswer(result: BinaryLinkResult): BinaryLinkAnswer;
+export declare const ROOM_LOCKED = "room-locked";
+export declare function lockedRoom(locator: string): Refused<'room-locked'> & {
+    locator: string;
+};
+export type Offline = {
+    readonly kind: 'offline';
+};
+export declare const OFFLINE: Offline;
+export declare const UNCERTAIN: Failure;
+export declare function undeclared(name: string): CallResult;
+export declare function failure(result: AdapterFailure): Failure;
+export declare function calledResult(result: ActionResult): CallResult;
+export declare function historyAnswer(result: HistoryResult): HistoryAnswer;
 export type Submission = {
     readonly state: 'waiting' | 'submitted';
 } | {
@@ -12,7 +68,10 @@ export type Submission = {
 export type QueueEntry = {
     readonly batch: ChangeBatch;
 } & (Submission | {
+    readonly state: 'local';
+} | {
     readonly state: 'accepted';
     readonly roomVersion: string;
 });
+export {};
 //# sourceMappingURL=outcome.d.ts.map

package/dist/outcome.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outcome.d.ts","sourceRoot":"","sources":["../src/outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAE/D,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CAAA;CAAE,GAC3C;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GAAG,CACvD,UAAU,GACV;IAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAC/D,CAAC"}
+{"version":3,"file":"outcome.d.ts","sourceRoot":"","sources":["../src/outcome.ts"],"names":[],"mappings":"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"}

package/dist/outcome.js

@@ -1 +1,67 @@
-export {};
+export const UNREADABLE = {
+    kind: 'unreadable',
+    code: 'room-not-readable',
+    fields: {},
+    retryable: false,
+};
+export const LOCKED_UNREADABLE = {
+    kind: 'unreadable',
+    code: 'room-locked',
+    fields: {},
+    retryable: true,
+};
+export const ABSENT_TARGET = {
+    kind: 'absent',
+    code: 'reference-absent',
+    fields: {},
+    retryable: false,
+};
+export function absentBinary(path) {
+    return { kind: 'absent', code: 'binary-file-absent', fields: { path }, retryable: false };
+}
+export function binaryAnswer(result) {
+    return result.kind === 'binary' || result.kind === 'rejected' ? result : failure(result);
+}
+export function binaryLinkAnswer(result) {
+    return result.kind === 'link' || result.kind === 'rejected' ? result : failure(result);
+}
+export const ROOM_LOCKED = 'room-locked';
+export function lockedRoom(locator) {
+    return { kind: ROOM_LOCKED, locator, code: ROOM_LOCKED, fields: {}, retryable: true };
+}
+export const OFFLINE = { kind: 'offline' };
+export const UNCERTAIN = {
+    kind: 'transport-uncertainty',
+    code: 'transport-uncertainty',
+    fields: {},
+    retryable: true,
+};
+export function undeclared(name) {
+    return { kind: 'undeclared', code: 'action-undeclared', fields: { name }, retryable: false };
+}
+export function failure(result) {
+    switch (result.kind) {
+        case 'transport-uncertainty':
+            return UNCERTAIN;
+        case 'revoked-authorization':
+            return { kind: result.kind, code: result.kind, fields: {}, retryable: false };
+        case 'room-not-readable':
+            return {
+                kind: result.kind,
+                locator: result.locator,
+                code: result.kind,
+                fields: {},
+                retryable: false,
+            };
+        case 'scoped-refusal':
+            return result;
+    }
+}
+export function calledResult(result) {
+    return result.kind === 'action' || result.kind === 'rejected' ? result : failure(result);
+}
+export function historyAnswer(result) {
+    return result.kind === 'history' || result.kind === 'revision' || result.kind === 'no-history'
+        ? result
+        : failure(result);
+}

package/dist/overlay.d.ts

@@ -1,15 +1,25 @@
-import type { HeadChange } from './adapter.js';
+import type { BinaryFile, HeadChange } from './adapter.js';
 import type { ChangeBatch } from './change.js';
 export type Heads = {
     revisions: Readonly<Record<string, string>>;
+    fileIds: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
 };
+export type HeldBinary = ({
+    readonly state: 'accepted';
+} & BinaryFile) | {
+    readonly state: 'pending';
+    readonly localId: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+    readonly sha256: string;
+};
 export type Layer = Heads & {
     documents: Readonly<Record<string, string>>;
-    binaryTargets: readonly string[];
+    binaries: Readonly<Record<string, HeldBinary>>;
 };
+export declare function acceptedBinaries(files: Readonly<Record<string, BinaryFile>>): Generator<readonly [string, HeldBinary]>;
+export declare function sameBinary(left: HeldBinary | undefined, right: HeldBinary | undefined): boolean;
 export declare function sameChange(left: HeadChange | undefined, right: HeadChange | undefined): boolean;
-export declare function overlay(base: Layer, queue: readonly ChangeBatch[]): Layer;
-export declare function sameLayerText(left: Layer, right: Layer): boolean;
-export declare function overlayChanged(base: Layer, queue: readonly ChangeBatch[], previousBase: Layer, previousQueue: readonly ChangeBatch[], previousVisible: Layer): Layer;
+export declare function overlaying(base: Layer, queue: readonly ChangeBatch[], unapplied?: () => void): Generator<number, Layer, void>;
 //# sourceMappingURL=overlay.d.ts.map

package/dist/overlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../src/overlay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAU,WAAW,EAAgB,MAAM,aAAa,CAAC;AAErE,MAAM,MAAM,KAAK,GAAG;IAClB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG;IAC1B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAQ/F;AAoJD,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,KAAK,CAiBzE;AAQD,wBAAgB,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAQhE;AAmBD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,YAAY,EAAE,KAAK,EACnB,aAAa,EAAE,SAAS,WAAW,EAAE,EACrC,eAAe,EAAE,KAAK,GACrB,KAAK,CA4FP"}
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../src/overlay.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAU,WAAW,EAAgB,MAAM,aAAa,CAAC;AAIrE,MAAM,MAAM,KAAK,GAAG;IAClB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,CAAC;IAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAAG,UAAU,CAAC,GAC7C;IACE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEN,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG;IAC1B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CAChD,CAAC;AAEF,wBAAiB,gBAAgB,CAC/B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAC1C,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAE1C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAW/F;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAQ/F;AAqMD,wBAAiB,UAAU,CACzB,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,SAAS,CAAC,EAAE,MAAM,IAAI,GACrB,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAoChC"}

package/dist/overlay.js

@@ -1,4 +1,21 @@
-import { apply, parse, serialize } from '@agentshouse/mdmodel';
+import { apply, frontmatterValue, parse, serialize, } from '@agentshouse/mdmodel';
+import { drafted, entriesIn, settling } from './shared.js';
+import { ROW_WEIGHT } from './turn.js';
+export function* acceptedBinaries(files) {
+    for (const [path, file] of entriesIn(files))
+        yield [path, { state: 'accepted', ...file }];
+}
+export function sameBinary(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.state === right.state &&
+        left.byteLength === right.byteLength &&
+        left.mediaType === right.mediaType &&
+        left.sha256 === right.sha256 &&
+        (left.state === 'accepted'
+            ? right.state === 'accepted'
+            : right.state === 'pending' && left.localId === right.localId));
+}
 export function sameChange(left, right) {
     if (left === undefined || right === undefined)
         return left === right;
@@ -8,10 +25,13 @@ export function sameChange(left, right) {
         left.author?.name === right.author?.name);
 }
 const EMPTY_FRONTMATTER = '---\n---\n';
+function isPart(change) {
+    return change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble';
+}
 function at(path, name) {
     return `${path} ${name}`;
 }
-function priorsOf(preconditions) {
+function* priorsOf(preconditions) {
     const fields = new Map();
     const sections = new Map();
     const preambles = new Map();
@@ -25,6 +45,7 @@ function priorsOf(preconditions) {
         if (precondition.kind === 'preamble') {
             preambles.set(precondition.path, precondition.value);
         }
+        yield ROW_WEIGHT;
     }
     return {
         field: (path, name) => fields.get(at(path, name)),
@@ -40,49 +61,50 @@ function compose(fields, sections) {
     const opened = parse(skeleton);
     if (!opened.ok)
         return skeleton;
-    let document = opened.document;
-    for (const [name, value] of Object.entries(fields)) {
-        const next = apply(document, { kind: 'field', name, value, prior: undefined });
-        if (next.outcome === 'applied')
-            document = next.document;
-    }
-    return serialize(document);
+    const next = apply(opened.document, Object.entries(fields).flatMap(([name, value]) => frontmatterValue(value) ? [{ kind: 'field', name, value, prior: undefined }] : []));
+    return serialize(next.outcome === 'applied' ? next.document : opened.document);
 }
-function edited(document, change, priors) {
-    if (change.kind === 'field') {
-        return apply(document, {
+function edited(change, priors) {
+    if (change.kind === 'field')
+        return {
             kind: 'field',
             name: change.name,
             value: change.value,
             prior: priors.field(change.path, change.name),
-        });
-    }
-    if (change.kind === 'preamble') {
-        return apply(document, {
-            kind: 'preamble',
-            value: change.value,
-            prior: priors.preamble(change.path),
-        });
-    }
-    if (change.kind !== 'section')
-        return null;
-    return apply(document, {
+        };
+    if (change.kind === 'preamble')
+        return { kind: 'preamble', value: change.value, prior: priors.preamble(change.path) };
+    return {
         kind: 'section',
         name: change.name,
         value: change.value,
         prior: priors.section(change.path, change.name),
-    });
+    };
 }
-function edit(staged, change, priors) {
-    const text = staged.documents[change.path];
+function edit(staged, changes, priors) {
+    const path = changes[0].path;
+    delete staged.revisions[path];
+    const text = staged.documents[path];
     if (text === undefined)
-        return;
-    const parsed = parse(text, change.path);
+        return changes.length;
+    const parsed = parse(text, path);
     if (!parsed.ok)
-        return;
-    const next = edited(parsed.document, change, priors);
-    if (next?.outcome === 'applied')
-        staged.documents[change.path] = serialize(next.document);
+        return changes.length;
+    const wanted = changes.map((change) => edited(change, priors));
+    const first = apply(parsed.document, wanted);
+    if (first.outcome === 'refuse')
+        return changes.length;
+    if (first.outcome === 'applied') {
+        staged.documents[path] = serialize(first.document);
+        return 0;
+    }
+    const stale = new Set(first.stale);
+    const kept = wanted.filter((_, at) => !stale.has(at));
+    const rest = apply(parsed.document, kept);
+    if (rest.outcome !== 'applied')
+        return changes.length;
+    staged.documents[path] = serialize(rest.document);
+    return first.stale.length;
 }
 function relocate(staged, from, to) {
     const text = staged.documents[from];
@@ -90,194 +112,128 @@ function relocate(staged, from, to) {
         delete staged.documents[from];
         staged.documents[to] = text;
     }
-    else if (staged.binaryTargets.delete(from)) {
-        staged.binaryTargets.add(to);
+    else if (staged.binaries[from] !== undefined) {
+        staged.binaries[to] = staged.binaries[from];
+        delete staged.binaries[from];
     }
     else {
-        return;
+        return false;
     }
     moveHead(staged, from, to);
+    return true;
 }
 function moveHead(heads, from, to) {
     const revision = heads.revisions[from];
+    const fileId = heads.fileIds[from];
     const change = heads.changes[from];
     delete heads.revisions[from];
+    delete heads.fileIds[from];
     delete heads.changes[from];
+    delete heads.fileIds[to];
     delete heads.changes[to];
     if (revision !== undefined)
         heads.revisions[to] = revision;
+    if (fileId !== undefined)
+        heads.fileIds[to] = fileId;
     if (change !== undefined)
         heads.changes[to] = change;
 }
 function erase(staged, path) {
     delete staged.documents[path];
     delete staged.revisions[path];
+    delete staged.fileIds[path];
     delete staged.changes[path];
-    staged.binaryTargets.delete(path);
+    delete staged.binaries[path];
 }
-function stage(staged, change, priors) {
-    if (change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble') {
-        edit(staged, change, priors);
-        return;
-    }
+function stage(staged, change) {
     if (change.kind === 'create') {
         staged.documents[change.path] =
             'content' in change ? change.content : compose(change.fields, change.sections);
+        delete staged.fileIds[change.path];
         delete staged.changes[change.path];
-        return;
+        return true;
     }
     if (change.kind === 'replace') {
+        delete staged.revisions[change.path];
         if (staged.documents[change.path] === undefined)
-            return;
+            return false;
         staged.documents[change.path] = change.content;
-        return;
+        return true;
+    }
+    if (change.kind === 'binary') {
+        if (staged.documents[change.path] !== undefined)
+            return false;
+        staged.binaries[change.path] = {
+            state: 'pending',
+            localId: change.localId,
+            byteLength: change.byteLength,
+            mediaType: change.mediaType,
+            sha256: change.sha256,
+        };
+        delete staged.revisions[change.path];
+        delete staged.changes[change.path];
+        return true;
     }
     if (change.kind === 'move') {
-        relocate(staged, change.path, change.to);
-        return;
+        return relocate(staged, change.path, change.to);
+    }
+    if (change.kind === 'arrival') {
+        erase(staged, change.path);
+        if ('content' in change)
+            staged.documents[change.path] = change.content;
+        else
+            staged.binaries[change.path] = { state: 'accepted', ...change.binary };
+        arrive(staged, change);
+        return true;
     }
     erase(staged, change.path);
+    return true;
+}
+function arrive(heads, change) {
+    if (change.revision !== undefined)
+        heads.revisions[change.path] = change.revision;
+    if (change.fileId !== undefined)
+        heads.fileIds[change.path] = change.fileId;
+    if (change.change !== undefined)
+        heads.changes[change.path] = change.change;
 }
-export function overlay(base, queue) {
+export function* overlaying(base, queue, unapplied) {
     const staged = {
-        documents: { ...base.documents },
-        binaryTargets: new Set(base.binaryTargets),
-        revisions: { ...base.revisions },
-        changes: { ...base.changes },
-    };
-    for (const batch of queue) {
-        const priors = priorsOf(batch.preconditions);
-        for (const change of batch.changes)
-            stage(staged, change, priors);
-    }
-    return {
-        documents: staged.documents,
-        binaryTargets: [...staged.binaryTargets].sort(),
-        revisions: staged.revisions,
-        changes: staged.changes,
+        documents: drafted(base.documents),
+        binaries: drafted(base.binaries),
+        revisions: drafted(base.revisions),
+        fileIds: drafted(base.fileIds),
+        changes: drafted(base.changes),
     };
-}
-function pathsOf(batch) {
-    return batch.changes.flatMap((change) => change.kind === 'move' ? [change.path, change.to] : [change.path]);
-}
-export function sameLayerText(left, right) {
-    const paths = Object.keys(left.documents);
-    return (paths.length === Object.keys(right.documents).length &&
-        paths.every((path) => left.documents[path] === right.documents[path]) &&
-        left.binaryTargets.length === right.binaryTargets.length &&
-        left.binaryTargets.every((path) => right.binaryTargets.includes(path)));
-}
-function replayHeads(base, queue) {
-    const heads = { revisions: { ...base.revisions }, changes: { ...base.changes } };
     for (const batch of queue) {
-        for (const change of batch.changes) {
-            if (change.kind === 'remove') {
-                delete heads.revisions[change.path];
-                delete heads.changes[change.path];
-            }
-            else if (change.kind === 'create') {
-                delete heads.changes[change.path];
-            }
-            else if (change.kind === 'move') {
-                moveHead(heads, change.path, change.to);
-            }
-        }
-    }
-    return heads;
-}
-export function overlayChanged(base, queue, previousBase, previousQueue, previousVisible) {
-    const before = previousQueue.map((batch) => JSON.stringify(batch));
-    const after = queue.map((batch) => JSON.stringify(batch));
-    if (before.length === after.length &&
-        before.every((id, index) => id === after[index]) &&
-        sameLayerText(base, previousBase)) {
-        return {
-            documents: previousVisible.documents,
-            binaryTargets: previousVisible.binaryTargets,
-            ...replayHeads(base, queue),
-        };
-    }
-    const affected = new Set();
-    const paths = new Set([
-        ...Object.keys(base.documents),
-        ...Object.keys(previousBase.documents),
-        ...Object.keys(base.revisions),
-        ...Object.keys(previousBase.revisions),
-        ...Object.keys(base.changes),
-        ...Object.keys(previousBase.changes),
-        ...base.binaryTargets,
-        ...previousBase.binaryTargets,
-    ]);
-    for (const path of paths) {
-        if (base.documents[path] !== previousBase.documents[path] ||
-            base.revisions[path] !== previousBase.revisions[path] ||
-            !sameChange(base.changes[path], previousBase.changes[path]) ||
-            base.binaryTargets.includes(path) !== previousBase.binaryTargets.includes(path))
-            affected.add(path);
-    }
-    const oldIds = new Set(before);
-    const newIds = new Set(after);
-    for (const batch of previousQueue) {
-        if (!newIds.has(JSON.stringify(batch)))
-            for (const path of pathsOf(batch))
-                affected.add(path);
-    }
-    for (const batch of queue) {
-        if (!oldIds.has(JSON.stringify(batch)))
-            for (const path of pathsOf(batch))
-                affected.add(path);
-    }
-    let expanded = true;
-    while (expanded) {
-        expanded = false;
-        for (const batch of queue) {
-            const touched = pathsOf(batch);
-            if (!touched.some((path) => affected.has(path)))
+        const priors = yield* priorsOf(batch.preconditions);
+        for (let index = 0; index < batch.changes.length; index += 1) {
+            const change = batch.changes[index];
+            if (!isPart(change)) {
+                if (!stage(staged, change))
+                    unapplied?.();
+                yield ROW_WEIGHT;
                 continue;
-            for (const path of touched) {
-                if (affected.has(path))
-                    continue;
-                affected.add(path);
-                expanded = true;
             }
+            const run = [change];
+            while (index + 1 < batch.changes.length) {
+                const next = batch.changes[index + 1];
+                if (!isPart(next) || next.path !== change.path)
+                    break;
+                run.push(next);
+                index += 1;
+            }
+            const text = staged.documents[change.path] ?? '';
+            for (let left = edit(staged, run, priors); left > 0; left -= 1)
+                unapplied?.();
+            yield ROW_WEIGHT + text.length;
         }
     }
-    const documents = {};
-    const revisions = {};
-    const changes = {};
-    for (const path of affected) {
-        if (base.documents[path] !== undefined)
-            documents[path] = base.documents[path];
-        if (base.revisions[path] !== undefined)
-            revisions[path] = base.revisions[path];
-        if (base.changes[path] !== undefined)
-            changes[path] = base.changes[path];
-    }
-    const staged = overlay({
-        documents,
-        revisions,
-        changes,
-        binaryTargets: base.binaryTargets.filter((path) => affected.has(path)),
-    }, queue.filter((batch) => pathsOf(batch).some((path) => affected.has(path))));
-    const mergedDocuments = { ...previousVisible.documents };
-    const mergedRevisions = { ...previousVisible.revisions };
-    const mergedChanges = { ...previousVisible.changes };
-    const mergedTargets = new Set(previousVisible.binaryTargets);
-    for (const path of affected) {
-        delete mergedDocuments[path];
-        delete mergedRevisions[path];
-        delete mergedChanges[path];
-        mergedTargets.delete(path);
-    }
-    Object.assign(mergedDocuments, staged.documents);
-    Object.assign(mergedRevisions, staged.revisions);
-    Object.assign(mergedChanges, staged.changes);
-    for (const path of staged.binaryTargets)
-        mergedTargets.add(path);
     return {
-        documents: mergedDocuments,
-        revisions: mergedRevisions,
-        changes: mergedChanges,
-        binaryTargets: [...mergedTargets].sort(),
+        documents: yield* settling(staged.documents),
+        binaries: yield* settling(staged.binaries),
+        revisions: yield* settling(staged.revisions),
+        fileIds: yield* settling(staged.fileIds),
+        changes: yield* settling(staged.changes),
     };
 }