@agentshouse/mdruntime 0.1.0-c967d1ca66fee → 0.1.0-c969b8dee6cc8

package/dist/save.d.ts

@@ -22,7 +22,13 @@ export type SaveInput = {
     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;
+    };
 };
 export type BatchResult = {
     kind: 'batch';
@@ -32,5 +38,28 @@ export type BatchResult = {
     refusal: SaveRefusal;
 };
 export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): ChangeBatch;
+export declare function queuedDocuments(queue: readonly ChangeBatch[]): ReadonlySet<string>;
+export type Requeued = {
+    kind: 'requeued';
+    queue: readonly ChangeBatch[];
+    changes: readonly Change[];
+    queued: ReadonlySet<string>;
+    withdrawn: ReadonlyMap<string, ChangeBatch | null>;
+    owners: ReadonlySet<string>;
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export type Joining = {
+    kind: 'joined';
+    batch: ChangeBatch;
+    queue: readonly ChangeBatch[];
+} | {
+    kind: 'refused';
+    refusal: SaveRefusal;
+};
+export declare function requeued(queue: readonly ChangeBatch[], changes: readonly Change[], visible: VisibleLayer, changeable: (batch: ChangeBatch) => boolean, state: (queue: readonly ChangeBatch[]) => VisibleLayer): Requeued;
+export declare function joined(queue: readonly ChangeBatch[], owner: ChangeBatch, extra: ChangeBatch): Joining;
+export declare function limitedIn(queue: readonly ChangeBatch[], batch: ChangeBatch, limits: readonly ProviderLimit[], state: (queue: readonly ChangeBatch[]) => VisibleLayer): SaveRefusal | null;
 export declare function buildBatch(input: SaveInput): BatchResult;
 //# sourceMappingURL=save.d.ts.map

package/dist/save.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../src/save.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AACrB,OAAO,EAML,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,OAAO,cAAc,EAAE,eAAe,CAAC;IACnD,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/B,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAiL9C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,GAAG,WAAW,CAOxF;AAyRD,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CAkFxD"}
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../src/save.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAIL,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AACrB,OAAO,EASL,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,OAAO,cAAc,EAAE,eAAe,CAAC;IACnD,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/B,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACvC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAC5C,WAAW,EAAE,WAAW,CAAC;KAC1B,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAsL9C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,GAAG,WAAW,CAOxF;AAgID,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,CAWlF;AAyND,MAAM,MAAM,QAAQ,GAChB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC;IACnD,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC7B,GACD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAM9C,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAiM9C,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,EAC3C,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,KAAK,YAAY,GACrD,QAAQ,CA+DV;AAUD,wBAAgB,MAAM,CACpB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,WAAW,GACjB,OAAO,CAiCT;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,KAAK,YAAY,GACrD,WAAW,GAAG,IAAI,CASpB;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CA4GxD"}

package/dist/save.js

@@ -1,7 +1,7 @@
 import { definitionOf } from './model.js';
 import { apply, ATTACHMENT, links, parse, pointerSegments, references, relative, relativize, retarget, serialize, target, } from '@agentshouse/mdmodel';
-import { immutable, } from './change.js';
-import { collectionOf, documentsOf, governing, validateCollection, } from './collection.js';
+import { immutable, queuedFile, departure, } from './change.js';
+import { available, changedCleanly, collectionOf, documentsOf, governing, referring, validateCollection, } from './collection.js';
 import { changeBatchIdentity } from './identity.js';
 import { overlay } from './overlay.js';
 import { covered, normalize } from './paths.js';
@@ -122,7 +122,10 @@ function rewrites(changes, visible) {
     for (const change of changes) {
         if (change.kind === 'move')
             moves.set(change.path, change.to);
-        if (change.kind === 'remove' || change.kind === 'replace' || change.kind === 'create') {
+        if (change.kind === 'remove' ||
+            change.kind === 'replace' ||
+            change.kind === 'create' ||
+            change.kind === 'binary') {
             settled.add(change.path);
         }
         if (change.kind === 'field')
@@ -174,7 +177,7 @@ export function providerRewritten(batch, visible) {
         ...anticipated(batch.changes, batch.preconditions, rewritten.changes, visible),
     };
 }
-function incoming(collection, removed) {
+function incoming(collection, removed, candidates) {
     const found = new Map();
     const note = (target, file) => {
         if (!removed.has(target))
@@ -183,7 +186,13 @@ function incoming(collection, removed) {
         referrers.add(file);
         found.set(target, referrers);
     };
-    for (const [path, document] of documentsOf(collection)) {
+    const read = candidates === null
+        ? documentsOf(collection)
+        : [...new Set(candidates)].sort().flatMap((path) => {
+            const document = collection.document(path);
+            return document === undefined ? [] : [[path, document]];
+        });
+    for (const [path, document] of read) {
         const definition = definitionOf(governing(collection.composition, path), document.type);
         for (const { value, to } of definition === undefined ? [] : references(document, definition)) {
             if (to.includes(ATTACHMENT))
@@ -214,11 +223,14 @@ function affected(change) {
     return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
 function guard(changes, input) {
-    const existing = new Set([
-        ...Object.keys(input.visible.documents),
-        ...input.visible.binaryTargets,
-    ]);
-    for (const change of changes) {
+    const overridden = new Map();
+    const existing = {
+        has: (path) => overridden.get(path) ??
+            (Object.hasOwn(input.visible.documents, path) || Object.hasOwn(input.visible.binaries, path)),
+        add: (path) => void overridden.set(path, true),
+        delete: (path) => void overridden.set(path, false),
+    };
+    for (const [index, change] of changes.entries()) {
         for (const path of affected(change)) {
             const normalized = normalize(path);
             if (normalized === null || normalized === '')
@@ -236,12 +248,26 @@ function guard(changes, input) {
             existing.add(change.path);
             continue;
         }
+        if (change.kind === 'binary') {
+            if (input.visible.documents[change.path] !== undefined ||
+                (existing.has(change.path) &&
+                    input.bases.some((base) => base.kind === 'absent' && base.path === change.path))) {
+                return refuse('path-collision', change.path);
+            }
+            if (!input.local &&
+                existing.has(change.path) &&
+                input.visible.revisions[departure(changes, index)] === undefined) {
+                return refuse('unknown-revision', change.path);
+            }
+            existing.add(change.path);
+            continue;
+        }
         if (change.kind === 'move') {
             if (!existing.has(change.path))
                 return refuse('path-absent', change.path);
             if (existing.has(change.to))
                 return refuse('path-collision', change.to);
-            if (!input.local && unrevisionedDocument(input.visible, change.path)) {
+            if (unrevised(input, change.path)) {
                 return refuse('unknown-revision', change.path);
             }
             existing.delete(change.path);
@@ -251,14 +277,14 @@ function guard(changes, input) {
         if (!existing.has(change.path))
             return refuse('path-absent', change.path);
         if (change.kind === 'remove') {
-            if (!input.local && unrevisionedDocument(input.visible, change.path)) {
+            if (unrevised(input, change.path)) {
                 return refuse('unknown-revision', change.path);
             }
             existing.delete(change.path);
             continue;
         }
         if (change.kind === 'replace') {
-            if (!input.local && input.visible.revisions[change.path] === undefined) {
+            if (unrevised(input, change.path)) {
                 return refuse('unknown-revision', change.path);
             }
             continue;
@@ -269,8 +295,28 @@ function guard(changes, input) {
     }
     return null;
 }
-function unrevisionedDocument(visible, path) {
-    return visible.revisions[path] === undefined && !visible.binaryTargets.includes(path);
+function unrevised(input, path) {
+    return (!input.local && input.queued?.has(path) !== true && input.visible.revisions[path] === undefined);
+}
+export function queuedDocuments(queue) {
+    const paths = new Set();
+    for (const batch of queue) {
+        for (const change of batch.changes) {
+            if (change.kind === 'binary')
+                continue;
+            if (change.kind === 'remove')
+                paths.delete(change.path);
+            else if (change.kind !== 'move')
+                paths.add(change.path);
+            else if (paths.delete(change.path))
+                paths.add(change.to);
+        }
+    }
+    return paths;
+}
+function identity(precondition) {
+    const part = precondition.kind === 'field' || precondition.kind === 'section' ? precondition.name : '';
+    return `${precondition.kind} ${precondition.path} ${part}`;
 }
 function existence(visible, path) {
     const revision = visible.revisions[path];
@@ -289,11 +335,10 @@ function preconditionsOf(changes, visible, bases) {
     const preconditions = [];
     const seen = new Set();
     const add = (precondition) => {
-        const part = precondition.kind === 'field' || precondition.kind === 'section' ? precondition.name : '';
-        const identity = `${precondition.kind} ${precondition.path} ${part}`;
-        if (seen.has(identity))
+        const held = identity(precondition);
+        if (seen.has(held))
             return;
-        seen.add(identity);
+        seen.add(held);
         preconditions.push(precondition);
     };
     for (const change of changes) {
@@ -328,6 +373,13 @@ function preconditionsOf(changes, visible, bases) {
             add({ kind: 'absent', path: change.path });
             continue;
         }
+        if (change.kind === 'binary') {
+            const revision = visible.revisions[change.path];
+            add(visible.binaries[change.path] === undefined || revision === undefined
+                ? { kind: 'absent', path: change.path }
+                : { kind: 'revision', path: change.path, revision });
+            continue;
+        }
         add(existence(visible, change.path));
         if (change.kind === 'move')
             add({ kind: 'absent', path: change.to });
@@ -337,10 +389,10 @@ function preconditionsOf(changes, visible, bases) {
 function depth(path) {
     return path.split('/').length;
 }
-function exceeded(limits, changes, resulting) {
-    const written = changes.map((change) => (change.kind === 'move' ? change.to : change.path));
+function exceeded(limits, changes, effective, resulting) {
+    const written = effective.map((change) => (change.kind === 'move' ? change.to : change.path));
     const created = changes
-        .filter((change) => change.kind === 'create' || change.kind === 'move')
+        .filter((change) => change.kind === 'create' || change.kind === 'move' || change.kind === 'binary')
         .map((change) => (change.kind === 'move' ? change.to : change.path));
     for (const limit of limits) {
         const value = limit.value;
@@ -354,7 +406,7 @@ function exceeded(limits, changes, resulting) {
             return refuse('provider-limit', undefined, limit.name);
         }
         if (limit.name === 'document-size') {
-            const large = written.find((path) => (resulting.documents[path] ?? '').length > value);
+            const large = written.find((path) => new TextEncoder().encode(resulting.documents[path] ?? '').byteLength > value);
             if (large !== undefined)
                 return refuse('provider-limit', large, limit.name);
         }
@@ -423,6 +475,8 @@ function relativeChanges(input) {
     });
 }
 function unmodeledType(collection, composition) {
+    if (available(composition))
+        return false;
     for (const [path, document] of documentsOf(collection)) {
         if (document.type !== undefined &&
             document.type !== 'any' &&
@@ -431,6 +485,270 @@ function unmodeledType(collection, composition) {
     }
     return false;
 }
+function unqueueable(file) {
+    return { kind: 'refused', refusal: { code: 'unknown-revision', retryable: false, file } };
+}
+function isPart(change) {
+    return change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble';
+}
+function touched(change) {
+    return change.kind === 'move' ? [change.path, change.to] : [change.path];
+}
+function partApplied(content, path, change) {
+    const parsed = parse(content, path);
+    if (!parsed.ok)
+        return null;
+    const document = parsed.document;
+    const applied = apply(document, change.kind === 'field'
+        ? {
+            kind: 'field',
+            name: change.name,
+            value: change.value,
+            prior: document.fields[change.name],
+        }
+        : change.kind === 'section'
+            ? {
+                kind: 'section',
+                name: change.name,
+                value: change.value,
+                prior: document.sections[change.name],
+            }
+            : { kind: 'preamble', value: change.value, prior: document.preamble });
+    return applied.outcome === 'applied' ? serialize(applied.document) : null;
+}
+function folded(changes, change, appending) {
+    const held = changes.find((item) => item.path === change.path && (item.kind === 'create' || item.kind === 'replace'));
+    const whole = held === undefined ? -1 : changes.indexOf(held);
+    const occupied = changes.some((item) => !isPart(item) && item !== held && touched(item).includes(change.path));
+    if (isPart(change)) {
+        const same = changes.findIndex((item) => item.kind === change.kind &&
+            item.path === change.path &&
+            (change.kind === 'preamble' || ('name' in item && item.name === change.name)));
+        if (same !== -1) {
+            changes[same] = change;
+            return 'folded';
+        }
+        if (held === undefined) {
+            if (!appending)
+                return 'skipped';
+            if (occupied)
+                return 'refused';
+            changes.push(change);
+            return 'appended';
+        }
+        if ('content' in held) {
+            const content = partApplied(held.content, held.path, change);
+            if (content === null)
+                return 'refused';
+            changes[whole] = { ...held, content };
+            return 'folded';
+        }
+        if (change.kind === 'preamble')
+            return 'refused';
+        changes[whole] =
+            change.kind === 'field'
+                ? { ...held, fields: { ...held.fields, [change.name]: change.value } }
+                : { ...held, sections: { ...held.sections, [change.name]: change.value } };
+        return 'folded';
+    }
+    if (change.kind === 'replace') {
+        if (held !== undefined) {
+            if (!('content' in held))
+                return 'refused';
+            changes[whole] = { ...held, content: change.content };
+            return 'folded';
+        }
+        const parts = changes.filter((item) => isPart(item) && item.path === change.path);
+        if (parts.length === 0 && !appending)
+            return 'skipped';
+        if (occupied)
+            return 'refused';
+        changes.splice(0, changes.length, ...changes.filter((item) => !parts.includes(item)), change);
+        return 'appended';
+    }
+    if (changes.some((item) => touched(change).some((path) => touched(item).includes(path))))
+        return 'refused';
+    changes.push(change);
+    return 'appended';
+}
+function relinked(batch, move, before, after, appending) {
+    const derived = rewrites([move], after);
+    if (derived.kind === 'refused')
+        return derived;
+    const changes = [...batch.changes];
+    const appended = [];
+    let changed = false;
+    for (const change of derived.changes) {
+        if (change === move)
+            continue;
+        const outcome = folded(changes, change, appending);
+        if (outcome === 'refused')
+            return unqueueable(change.path);
+        if (outcome === 'appended')
+            appended.push(change);
+        if (outcome !== 'skipped')
+            changed = true;
+    }
+    if (!changed)
+        return { kind: 'relinked', batch };
+    const held = new Set(batch.preconditions.map(identity));
+    return {
+        kind: 'relinked',
+        batch: immutable({
+            ...batch,
+            id: changeBatchIdentity(),
+            changes,
+            preconditions: [
+                ...batch.preconditions,
+                ...preconditionsOf(appended, before, []).filter((precondition) => !held.has(identity(precondition))),
+            ],
+        }),
+    };
+}
+function leading(changes, at) {
+    const from = departure(changes, at);
+    return new Set(changes.filter((change, index) => index < at && change.kind === 'move' && departure(changes, index) === from));
+}
+function created(batch, at) {
+    const file = batch.changes[at];
+    return (leading(batch.changes, at).size === 0 &&
+        batch.preconditions.some((precondition) => precondition.kind === 'absent' && precondition.path === file.path));
+}
+function withdrawnFile(batch, change, at) {
+    const file = batch.changes[at];
+    const from = departure(batch.changes, at);
+    const moves = leading(batch.changes, at);
+    const fresh = created(batch, at);
+    const vacated = new Set([...moves].map((move) => move.to));
+    if (fresh)
+        vacated.add(file.path);
+    const replaced = fresh
+        ? change.kind === 'remove'
+            ? []
+            : [{ ...file, path: change.to }]
+        : change.kind === 'remove'
+            ? [{ kind: 'remove', path: from }]
+            : change.to === from
+                ? [{ ...file, path: from }]
+                : [
+                    { kind: 'move', path: from, to: change.to },
+                    { ...file, path: change.to },
+                ];
+    const added = change.kind === 'move' && (fresh || change.to !== from)
+        ? [{ kind: 'absent', path: change.to }]
+        : [];
+    const changes = batch.changes.flatMap((item) => item === file ? replaced : item.kind === 'move' && moves.has(item) ? [] : [item]);
+    if (changes.length === 0)
+        return null;
+    const preconditions = [
+        ...added,
+        ...batch.preconditions.filter((precondition) => precondition.kind !== 'absent' || !vacated.has(precondition.path)),
+    ];
+    return immutable({ ...batch, id: changeBatchIdentity(), changes, preconditions });
+}
+export function requeued(queue, changes, visible, changeable, state) {
+    const next = [...queue];
+    const origins = new Map();
+    const withdrawn = new Map();
+    const owners = new Set();
+    const queued = new Set();
+    const kept = [];
+    const originOf = (batch) => origins.get(batch) ?? batch.id;
+    const open = (batch) => origins.has(batch) || changeable(batch);
+    for (const change of changes) {
+        const held = visible.binaries[change.path];
+        if ((change.kind !== 'move' && change.kind !== 'remove') || held?.state !== 'pending') {
+            kept.push(change);
+            continue;
+        }
+        let index = next.length - 1;
+        while (index >= 0 && queuedFile(next[index], change.path, held.localId) === -1)
+            index -= 1;
+        const owner = next[index];
+        if (owner === undefined || !open(owner))
+            return unqueueable(change.path);
+        const following = next.slice(index);
+        const rebuilt = [];
+        let before = change.kind === 'move' ? state(next.slice(0, index)) : visible;
+        for (const [offset, batch] of following.entries()) {
+            let current = batch;
+            if (change.kind === 'move') {
+                const after = state(next.slice(0, index + offset + 1));
+                const appending = offset === 0 && created(batch, queuedFile(batch, change.path, held.localId));
+                const relinking = relinked(batch, change, before, after, appending);
+                if (relinking.kind === 'refused')
+                    return relinking;
+                current = relinking.batch;
+                before = after;
+            }
+            if (current !== batch && !open(batch))
+                return unqueueable(change.path);
+            rebuilt.push(offset === 0
+                ? withdrawnFile(current, change, queuedFile(current, change.path, held.localId))
+                : current);
+        }
+        for (const [offset, batch] of following.entries()) {
+            const replaced = rebuilt[offset];
+            if (replaced === batch)
+                continue;
+            const origin = originOf(batch);
+            withdrawn.set(origin, replaced);
+            if (replaced !== null)
+                origins.set(replaced, origin);
+        }
+        owners.add(originOf(owner));
+        next.splice(index, following.length, ...rebuilt.filter((batch) => batch !== null));
+        queued.add(change.path);
+    }
+    return {
+        kind: 'requeued',
+        queue: withdrawn.size === 0 ? queue : next,
+        changes: kept,
+        queued,
+        withdrawn,
+        owners,
+    };
+}
+function covering(precondition) {
+    return precondition.kind === 'field' ||
+        precondition.kind === 'section' ||
+        precondition.kind === 'preamble'
+        ? identity(precondition)
+        : `path ${precondition.path}`;
+}
+export function joined(queue, owner, extra) {
+    const later = new Set(queue.slice(queue.indexOf(owner) + 1).flatMap((batch) => batch.changes.flatMap(touched)));
+    const clash = extra.changes.flatMap(touched).find((path) => later.has(path));
+    if (clash !== undefined)
+        return unqueueable(clash);
+    const changes = [...owner.changes];
+    for (const change of extra.changes) {
+        if (folded(changes, change, true) === 'refused')
+            return unqueueable(change.path);
+    }
+    const held = new Set(owner.preconditions.map(covering));
+    const written = new Set(owner.changes.flatMap((change) => change.kind === 'create' || change.kind === 'replace' ? [change.path] : []));
+    const preconditions = [
+        ...owner.preconditions,
+        ...extra.preconditions.filter((precondition) => {
+            const key = covering(precondition);
+            return (!held.has(key) && (key === `path ${precondition.path}` || !written.has(precondition.path)));
+        }),
+    ];
+    const batch = immutable({
+        ...owner,
+        ...(extra.validation === undefined ? {} : { validation: extra.validation }),
+        id: changeBatchIdentity(),
+        changes,
+        preconditions,
+    });
+    return { kind: 'joined', batch, queue: queue.map((item) => (item === owner ? batch : item)) };
+}
+export function limitedIn(queue, batch, limits, state) {
+    const at = queue.indexOf(batch);
+    const limited = exceeded(limits, batch.changes, providerRewritten(batch, state(queue.slice(0, at))).changes, state(queue.slice(0, at + 1)));
+    return limited?.kind === 'refused' ? limited.refusal : null;
+}
 export function buildBatch(input) {
     const changes = relativeChanges(input);
     const structural = changes.find((change) => change.kind === 'move' || change.kind === 'remove');
@@ -449,9 +767,16 @@ export function buildBatch(input) {
     const resulting = overlay(input.visible, [
         { id: '', baseRoomVersion: input.baseRoomVersion, ...predicted },
     ]);
+    const clean = input.clean !== undefined &&
+        input.clean.text === input.visible.documents &&
+        input.clean.binaries === input.visible.binaries &&
+        available(input.composition)
+        ? input.clean
+        : null;
     const removed = new Set(changes.filter((change) => change.kind === 'remove').map((change) => change.path));
     if (removed.size > 0) {
-        const referenced = incoming(collectionOf(resulting.documents, input.composition), removed);
+        const referrers = clean === null ? null : referring(clean, input.composition, removed);
+        const referenced = incoming(collectionOf(resulting.documents, input.composition), removed, referrers === null ? null : [...referrers, ...predicted.changes.flatMap(affected)]);
         if (referenced !== null)
             return referenced;
     }
@@ -461,15 +786,20 @@ export function buildBatch(input) {
         const parsed = parse(content);
         return parsed.ok && parsed.document.type !== undefined && parsed.document.type !== 'any';
     };
-    const typedPaths = [...new Set(predicted.changes.flatMap(affected))].filter((path) => typed(input.visible.documents[path]) || typed(resulting.documents[path]));
+    const touched = [...new Set(predicted.changes.flatMap(affected))];
+    const typedPaths = touched.filter((path) => typed(input.visible.documents[path]) || typed(resulting.documents[path]));
     const needsModel = typedPaths.length > 0;
     const withoutModel = typedPaths.find((path) => governing(input.composition, path).status === 'unavailable');
     if (withoutModel !== undefined)
         return refuse('model-unavailable', withoutModel);
-    const validationText = needsModel
-        ? resulting.documents
-        : Object.fromEntries(Object.entries(resulting.documents).filter(([path]) => predicted.changes.some((change) => affected(change).includes(path))));
-    const verdict = validateCollection(validationText, resulting.binaryTargets, input.composition);
+    const verdict = clean !== null &&
+        changedCleanly({ text: resulting.documents, binaries: resulting.binaries }, clean, input.composition)
+        ? { verdict: 'accept' }
+        : validateCollection(needsModel
+            ? resulting.documents
+            : Object.fromEntries(touched.flatMap((path) => resulting.documents[path] === undefined
+                ? []
+                : [[path, resulting.documents[path]]])), Object.keys(resulting.binaries), input.composition);
     if (verdict.verdict === 'refuse') {
         return {
             kind: 'refused',
@@ -482,7 +812,7 @@ export function buildBatch(input) {
             },
         };
     }
-    const limited = exceeded(input.providerLimits, changes, resulting);
+    const limited = exceeded(input.providerLimits, changes, predicted.changes, resulting);
     if (limited !== null)
         return limited;
     const validated = typedPaths

package/dist/search.d.ts

@@ -1,12 +1,16 @@
+import type { ProviderRefusal } from './adapter.js';
 import type { ChangeSet } from './change-set.js';
-import { type Filter } from './query.js';
+import { type CoveredRoom, type Filter, type PendingRoom } from './query.js';
 import type { Open } from './open.js';
 export type DocumentPart = Open<'fields' | 'sections' | 'preamble' | 'path'>;
 export type SearchRequest = {
     text: string;
     documents?: Filter;
+    collection?: true;
     conversations?: readonly string[];
     limit?: number;
+    after?: string;
+    total?: true;
 };
 export type DocumentHit = {
     room: string;
@@ -21,10 +25,38 @@ export type MessageHit = {
     score: number;
     matches: Readonly<Record<string, readonly Open<'text'>[]>>;
 };
-export type SearchResult = {
+export type SearchCoverage = {
+    rooms: readonly CoveredRoom[];
+    conversations: readonly string[];
+    index: string;
+    overlay: readonly string[];
+};
+export type PendingConversation = {
+    conversation: string;
+    awaits: Open<'index'>;
+};
+export type SearchHits = {
     documents: readonly DocumentHit[];
     messages: readonly MessageHit[];
 };
+export type SearchWindow = SearchHits & {
+    next?: string;
+    total?: {
+        documents: number;
+        messages: number;
+    };
+};
+export type SearchPending = SearchHits & {
+    pending: readonly (PendingRoom | PendingConversation)[];
+    coverage: SearchCoverage;
+};
+export type SearchUndeclared = ProviderRefusal & {
+    kind: 'undeclared';
+};
+export type SearchResult = (SearchWindow & {
+    coverage: SearchCoverage;
+}) | SearchPending | SearchUndeclared;
+export declare function undeclaredSearch(): SearchUndeclared;
 export type SearchedDocument = {
     room: string;
     path: string;
@@ -39,24 +71,35 @@ export type SearchedMessage = {
     text: string;
 };
 export type SearchSource = {
-    documents(): readonly SearchedDocument[];
+    room(room: string): readonly string[];
     document(room: string, path: string): SearchedDocument | null;
-    messages(): readonly SearchedMessage[];
-    message(conversation: string, identity: string): SearchedMessage | null;
 };
+type HitCursor = readonly [number, string, string] | readonly [] | null;
 export type SearchPlan = {
     text: string;
     documents: unknown;
+    collection: boolean;
     conversations: readonly string[] | null;
     limit: number | null;
+    after: readonly [HitCursor, HitCursor] | null;
+    total: boolean;
 };
 export type SearchIndex = {
+    generation(): string;
+    rooms(): ReadonlySet<string>;
+    conversations(): ReadonlySet<string>;
+    indexRoom(room: string): Promise<void>;
+    indexMessages(conversation: string, messages: readonly SearchedMessage[], whole: boolean): void;
+    forget(rooms: readonly string[]): void;
     changed(set: ChangeSet): void;
+    changes(): number;
+    caughtUp(): Promise<void>;
     search(plan: SearchPlan, documents: readonly {
         room: string;
         path: string;
-    }[] | null): SearchResult;
+    }[] | null, conversations: readonly string[], rooms: ReadonlySet<string> | null, selections: ReadonlyMap<string, readonly string[]> | null): SearchWindow;
 };
 export declare function searchPlanOf(input: unknown): SearchPlan;
 export declare function createSearchIndex(source: SearchSource): SearchIndex;
+export {};
 //# sourceMappingURL=search.d.ts.map