@agentshouse/mdruntime 0.1.0-cd3486bd400ed → 0.1.0-cd35ccee27a19

package/dist/save.js

@@ -1,10 +1,13 @@
-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 { changeBatchIdentity } from './identity.js';
-import { overlay } from './overlay.js';
-import { covered, normalize } from './paths.js';
+import { apply, ARRAY_INDEX, ATTACHMENT, create, links, parse, pointerSegments, references, relative, relativize, retarget, roomReferences, serialize, target, } from '@agentshouse/mdmodel';
+import { immutable, leaving, queuedFile, departure, } from './change.js';
+import { collectionOf, definitionsAt, documentsOf, governing, } from './collection.js';
+import { changeBatchIdentity, roomDraftRevision } from './identity.js';
+import { overlaying } from './overlay.js';
+import { ancestors } from './paths.js';
+import { entriesIn, sorting } from './shared.js';
+import { changedParts, changesOf, moveTarget, withdrawnDrafts, } from './room-draft.js';
+import { paced, ROW_WEIGHT, stepped } from './turn.js';
+import { validatedCollection } from './validation.js';
 function refuse(code, file, location) {
     return {
         kind: 'refused',
@@ -17,10 +20,7 @@ function refuse(code, file, location) {
     };
 }
 function repointed(document, definition, from, to, moves, settled) {
-    const parsed = parse(document.content, from);
-    if (!parsed.ok)
-        return [];
-    let next = parsed.document;
+    const changes = [];
     const names = new Set();
     for (const { pointer, value } of definition === undefined
         ? []
@@ -32,38 +32,39 @@ function repointed(document, definition, from, to, moves, settled) {
         const destination = moves.get(named) ?? named;
         if (target(to, value) === destination)
             continue;
-        const applied = apply(next, {
+        changes.push({
             kind: 'reference',
             pointer,
             value: retarget(value, relative(to, destination)),
             prior: value,
         });
-        if (applied.outcome !== 'applied')
-            continue;
-        next = applied.document;
         names.add(name);
     }
+    if (changes.length === 0)
+        return [];
+    const applied = apply(document, changes, definition);
+    if (applied.outcome !== 'applied')
+        return [];
+    const next = applied.document;
     return [...names].map((name) => ({ kind: 'field', path: from, name, value: next.fields[name] }));
 }
-function edited(document, path, changes) {
-    let next = document;
+function edited(document, changes, definition) {
+    const parts = new Map();
     for (const change of changes) {
-        if (change.path !== path)
-            continue;
-        if (change.kind !== 'section' && change.kind !== 'preamble')
-            continue;
-        const applied = apply(next, change.kind === 'preamble'
-            ? { kind: 'preamble', value: change.value, prior: next.preamble }
-            : {
+        if (change.kind === 'preamble')
+            parts.set('preamble', { kind: 'preamble', value: change.value, prior: document.preamble });
+        if (change.kind === 'section')
+            parts.set(`section ${change.name}`, {
                 kind: 'section',
                 name: change.name,
                 value: change.value,
-                prior: next.sections[change.name],
+                prior: document.sections[change.name] ?? '',
             });
-        if (applied.outcome === 'applied')
-            next = applied.document;
     }
-    return next;
+    if (parts.size === 0)
+        return document;
+    const applied = apply(document, [...parts.values()], definition);
+    return applied.outcome === 'applied' ? applied.document : document;
 }
 function bodies(path, before, after) {
     const changes = [];
@@ -77,8 +78,8 @@ function bodies(path, before, after) {
     }
     return changes;
 }
-function relinks(path, moved, before, moves) {
-    let after = before;
+function relinks(path, moved, before, moves, definition) {
+    const changes = [];
     for (const link of links(before, path)) {
         const destination = moves.get(link.target) ?? link.target;
         if (destination === link.target && moved === path)
@@ -86,20 +87,23 @@ function relinks(path, moved, before, moves) {
         const to = relative(moved, destination);
         if (to === relative(path, link.target))
             continue;
-        const applied = apply(after, { kind: 'link', href: link.href, to });
-        if (applied.outcome === 'refuse') {
-            return {
-                kind: 'refused',
-                refusal: {
-                    code: applied.refusal.rule,
-                    retryable: false,
-                    file: path,
-                    ...(applied.refusal.location === undefined ? {} : { location: applied.refusal.location }),
-                },
-            };
-        }
-        after = applied.document;
+        changes.push({ kind: 'link', href: link.href, to });
     }
+    if (changes.length === 0)
+        return { kind: 'changes', changes: [] };
+    const applied = apply(before, changes, definition);
+    if (applied.outcome === 'refuse') {
+        return {
+            kind: 'refused',
+            refusal: {
+                code: applied.refusal.rule,
+                retryable: false,
+                file: path,
+                ...(applied.refusal.location === undefined ? {} : { location: applied.refusal.location }),
+            },
+        };
+    }
+    const after = applied.document;
     if (after === before)
         return { kind: 'changes', changes: [] };
     if (before.type === undefined) {
@@ -107,74 +111,173 @@ function relinks(path, moved, before, moves) {
     }
     return { kind: 'changes', changes: bodies(path, before, after) };
 }
-function subsumed(merged, path) {
-    for (let index = merged.length - 1; index >= 0; index -= 1) {
-        const item = merged[index];
-        if (item.path !== path)
-            continue;
-        if (item.kind === 'section' || item.kind === 'preamble')
-            merged.splice(index, 1);
-    }
+function partKey(change) {
+    return change.kind === 'section' ? `section ${change.name}` : change.kind;
 }
-function rewrites(changes, visible) {
+const NAMES_A_SKIP_TESTS = 64;
+const ENCODED = /[%&\\]/u;
+function movedNames(moves) {
+    const names = new Set([...moves.keys()].map((path) => path.slice(path.lastIndexOf('/') + 1)));
+    return names.size > NAMES_A_SKIP_TESTS ? null : [...names];
+}
+function cannotLink(text, names) {
+    return names !== null && !ENCODED.test(text) && !names.some((name) => text.includes(name));
+}
+function* rewrites(changes, visible) {
     const moves = new Map();
     const settled = new Set();
-    for (const change of changes) {
+    const parts = new Map();
+    for (const [index, change] of changes.entries()) {
         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')
             settled.add(`${change.path} ${change.name}`);
+        if (isPart(change)) {
+            const held = parts.get(change.path);
+            if (held === undefined)
+                parts.set(change.path, [index]);
+            else
+                held.push(index);
+        }
     }
     if (moves.size === 0)
         return { kind: 'changes', changes };
+    const names = movedNames(moves);
     const merged = [...changes];
     const added = [];
-    for (const [path, document] of documentsOf(visible.collection)) {
+    for (const [path, document] of yield* documentsOf(visible.collection)) {
         if (settled.has(path))
             continue;
         const moved = moves.get(path) ?? path;
-        const definition = definitionOf(governing(visible.collection.composition, path), document.type);
-        added.push(...repointed(document, definition, path, moved, moves, settled));
-        const relinked = relinks(path, moved, edited(document, path, merged), moves);
+        const definition = definitionsAt(visible.collection.composition, path)(document.type);
+        const repointing = repointed(document, definition, path, moved, moves, settled);
+        added.push(...repointing);
+        const own = parts.get(path) ?? [];
+        const relinked = moved === path && own.length === 0 && cannotLink(document.content, names)
+            ? { kind: 'changes', changes: [] }
+            : relinks(path, moved, edited(document, own.map((index) => merged[index]), definition), moves, definition);
         if (relinked.kind === 'refused')
             return relinked;
+        const keyed = new Map();
+        for (const index of own) {
+            const key = partKey(merged[index]);
+            if (!keyed.has(key))
+                keyed.set(key, index);
+        }
         for (const change of relinked.changes) {
             if (change.kind === 'replace') {
-                subsumed(merged, path);
+                for (const index of own) {
+                    const kind = merged[index]?.kind;
+                    if (kind === 'section' || kind === 'preamble')
+                        merged[index] = null;
+                }
                 added.push(change);
                 continue;
             }
-            const index = merged.findIndex((item) => item.kind === change.kind &&
-                item.path === path &&
-                (change.kind !== 'section' || (item.kind === 'section' && item.name === change.name)));
-            if (index === -1)
+            const index = keyed.get(partKey(change));
+            if (index === undefined)
                 added.push(change);
             else
                 merged[index] = change;
         }
+        const text = visible.collection.text[path].length;
+        const rewritten = repointing.length > 0 || relinked.changes.length > 0;
+        yield ROW_WEIGHT + text + (rewritten ? text : 0);
     }
-    return { kind: 'changes', changes: [...added, ...merged] };
+    return {
+        kind: 'changes',
+        changes: [...added, ...merged.filter((change) => change !== null)],
+    };
 }
-function anticipated(changes, preconditions, rewritten, visible) {
-    const derived = rewritten.filter((change) => !changes.includes(change));
+function* anticipated(changes, preconditions, rewritten, visible) {
+    const given = new Set(changes);
+    const derived = rewritten.filter((change) => !given.has(change));
     return {
         changes: rewritten,
-        preconditions: [...preconditionsOf(derived, visible, []), ...preconditions],
+        preconditions: [...(yield* preconditionsOf(derived, visible, [])), ...preconditions],
     };
 }
-export function providerRewritten(batch, visible) {
-    const rewritten = rewrites(batch.changes, visible);
+export function* providerRewritten(batch, visible) {
+    const rewritten = yield* rewrites(batch.changes, visible);
     if (rewritten.kind === 'refused')
         return batch;
     return {
         ...batch,
-        ...anticipated(batch.changes, batch.preconditions, rewritten.changes, visible),
+        ...(yield* anticipated(batch.changes, batch.preconditions, rewritten.changes, visible)),
     };
 }
-function incoming(collection, removed) {
+function crossed(document, definition, path, to) {
+    const changes = [];
+    for (const link of links(document, path)) {
+        const written = to(link.target, link.href);
+        if (written !== undefined)
+            changes.push({ kind: 'link', href: link.href, to: written });
+    }
+    for (const { pointer, value } of definition === undefined
+        ? []
+        : references(document, definition)) {
+        const named = target(path, value);
+        const written = named === null ? undefined : to(named, value);
+        if (written !== undefined) {
+            changes.push({ kind: 'reference', pointer, value: retarget(value, written), prior: value });
+        }
+    }
+    return changes;
+}
+function rewritten(path, document, changes, definition) {
+    if (changes.length === 0)
+        return [];
+    const applied = apply(document, changes, definition);
+    if (applied.outcome !== 'applied')
+        return [];
+    const after = applied.document;
+    if (document.type === undefined)
+        return [{ kind: 'replace', path, content: serialize(after) }];
+    const names = new Set(changes.flatMap((change) => change.kind === 'reference' ? [pointerSegments(change.pointer)[0] ?? ''] : []));
+    return [
+        ...[...names].map((name) => ({ kind: 'field', path, name, value: after.fields[name] })),
+        ...bodies(path, document, after),
+    ];
+}
+function roomPathOf(handle, path) {
+    return `/rooms/${handle}/${path}`;
+}
+function* leavingRewritten(batch, visible) {
+    const between = batch.between;
+    if (between === undefined)
+        return batch;
+    const moved = new Map(between.moves.map(({ path, to }) => [path, roomPathOf(between.destination.handle, to)]));
+    const derived = [];
+    for (const [path, document] of yield* documentsOf(visible.collection)) {
+        if (moved.has(path))
+            continue;
+        const definition = definitionsAt(visible.collection.composition, path)(document.type);
+        derived.push(...rewritten(path, document, crossed(document, definition, path, (named) => moved.get(named)), definition));
+        yield ROW_WEIGHT + visible.collection.text[path].length;
+    }
+    if (derived.length === 0)
+        return batch;
+    return {
+        ...batch,
+        changes: [...derived, ...batch.changes],
+        preconditions: [...(yield* preconditionsOf(derived, visible, [])), ...batch.preconditions],
+    };
+}
+export function rewriting(batch, locator) {
+    return leaving(batch, locator) || batch.changes.some((change) => change.kind === 'move');
+}
+export function* effectiveIn(batch, locator, visible) {
+    return leaving(batch, locator)
+        ? yield* leavingRewritten(batch, visible)
+        : yield* providerRewritten(batch, visible);
+}
+function* incoming(collection, removed, candidates) {
     const found = new Map();
     const note = (target, file) => {
         if (!removed.has(target))
@@ -183,8 +286,21 @@ function incoming(collection, removed) {
         referrers.add(file);
         found.set(target, referrers);
     };
-    for (const [path, document] of documentsOf(collection)) {
-        const definition = definitionOf(governing(collection.composition, path), document.type);
+    const read = function* (paths) {
+        const seen = new Set();
+        for (const path of paths) {
+            if (seen.has(path))
+                continue;
+            seen.add(path);
+            const document = collection.document(path);
+            if (document !== undefined)
+                yield [path, document];
+        }
+    };
+    for (const [path, document] of candidates === null
+        ? yield* documentsOf(collection)
+        : read(candidates)) {
+        const definition = definitionsAt(collection.composition, path)(document.type);
         for (const { value, to } of definition === undefined ? [] : references(document, definition)) {
             if (to.includes(ATTACHMENT))
                 continue;
@@ -192,8 +308,9 @@ function incoming(collection, removed) {
             if (named !== null)
                 note(named, path);
         }
+        yield ROW_WEIGHT + collection.text[path].length;
     }
-    const [first] = [...found.keys()].sort();
+    const [first] = yield* sorting(found.keys());
     if (first === undefined)
         return null;
     const every = new Set();
@@ -206,42 +323,61 @@ function incoming(collection, removed) {
             code: 'referenced-missing-file',
             retryable: false,
             file: first,
-            referrers: [...every].sort(),
+            referrers: yield* sorting(every),
         },
     };
 }
 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 WRITE = ['write'];
+const MOVE_OUT = ['write', 'erase'];
+function guard(changes, input, removing) {
+    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),
+    };
+    const occupied = (path) => input.folders.has(path) ? path : (ancestors(path).find((one) => existing.has(one)) ?? null);
+    for (const [index, change] of changes.entries()) {
         for (const path of affected(change)) {
-            const normalized = normalize(path);
-            if (normalized === null || normalized === '')
-                return refuse('room-root', path);
-            if (covered(input.providerOwnedPaths, normalized)) {
-                return refuse('provider-owned-path', normalized);
-            }
-            const operation = change.kind === 'remove' ? 'delete' : 'write';
-            if (!input.local && !covered(input.operations[operation], normalized))
-                return refuse(`${operation}-grant`, normalized);
+            const refused = input.rule(path, change.kind === 'remove' ? removing : WRITE);
+            if (refused !== null)
+                return refuse(refused.code, refused.path);
         }
-        if (change.kind === 'create') {
-            if (existing.has(change.path))
+        if (change.kind === 'create' || change.kind === 'arrival') {
+            const taken = existing.has(change.path) ? change.path : occupied(change.path);
+            if (taken !== null)
+                return refuse('path-collision', taken);
+            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);
+            }
+            const taken = occupied(change.path);
+            if (taken !== null)
+                return refuse('path-collision', taken);
+            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)) {
+            const taken = existing.has(change.to) ? change.to : occupied(change.to);
+            if (taken !== null)
+                return refuse('path-collision', taken);
+            if (unrevised(input, change.path)) {
                 return refuse('unknown-revision', change.path);
             }
             existing.delete(change.path);
@@ -251,14 +387,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 +405,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) && input.visible.revisions[path] === undefined;
+}
+function queuedDocuments(queue) {
+    const paths = new Set();
+    for (const batch of queue) {
+        for (const change of batch.changes) {
+            if (change.kind === 'binary' || (change.kind === 'arrival' && !('content' in change)))
+                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];
@@ -285,18 +441,18 @@ function sameTarget(precondition, change) {
     return ((precondition.kind !== 'field' && precondition.kind !== 'section') ||
         ((change.kind === 'field' || change.kind === 'section') && precondition.name === change.name));
 }
-function preconditionsOf(changes, visible, bases) {
+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) {
+        yield ROW_WEIGHT;
         if (change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble') {
             const based = bases.find((base) => sameTarget(base, change));
             if (based !== undefined) {
@@ -328,6 +484,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 +500,13 @@ 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* exceeding(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' ||
+        change.kind === 'arrival')
         .map((change) => (change.kind === 'move' ? change.to : change.path));
     for (const limit of limits) {
         const value = limit.value;
@@ -354,9 +520,13 @@ 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);
-            if (large !== undefined)
-                return refuse('provider-limit', large, limit.name);
+            for (const path of written) {
+                const text = resulting.documents[path] ?? '';
+                if (new TextEncoder().encode(text).byteLength > value) {
+                    return refuse('provider-limit', path, limit.name);
+                }
+                yield ROW_WEIGHT + text.length;
+            }
         }
         if (limit.name === 'path-length') {
             const long = created.find((path) => path.length > value);
@@ -374,19 +544,16 @@ function exceeded(limits, changes, resulting) {
 function shellRelative(text, path, handle, definition) {
     if (!text.includes(`/rooms/${handle}/`))
         return null;
-    const parsed = parse(text, path);
+    const parsed = parse(text, path, definition);
     if (!parsed.ok)
         return null;
     const result = relativize(parsed.document, path, handle, definition(parsed.document.type));
     return result.outcome === 'applied' && result.document.content !== text ? result.document : null;
 }
 function relativeField(path, name, value, handle, definition) {
-    const opened = parse('---\n---\n');
-    if (definition === undefined ||
-        !opened.ok ||
-        !JSON.stringify(value ?? null).includes(`/rooms/${handle}/`))
+    if (definition === undefined || !JSON.stringify(value ?? null).includes(`/rooms/${handle}/`))
         return value;
-    const held = apply(opened.document, { kind: 'field', name, value, prior: undefined });
+    const held = apply(create(definition.name, definition), [{ kind: 'field', name, value, prior: undefined }], definition);
     if (held.outcome !== 'applied')
         return value;
     const result = relativize(held.document, path, handle, definition);
@@ -394,7 +561,7 @@ function relativeField(path, name, value, handle, definition) {
 }
 function relativeChanges(input) {
     const { handle, composition, visible } = input;
-    const typed = (path) => (type) => definitionOf(governing(composition, path), type);
+    const typed = (path) => definitionsAt(composition, path);
     const body = (path, text) => shellRelative(text, path, handle, () => undefined)?.content ?? text;
     return input.changes.map((change) => {
         const definition = typed(change.path);
@@ -422,54 +589,314 @@ function relativeChanges(input) {
         return { ...change, fields, sections };
     });
 }
-function unmodeledType(collection, composition) {
-    for (const [path, document] of documentsOf(collection)) {
-        if (document.type !== undefined &&
-            document.type !== 'any' &&
-            governing(composition, path).status === 'unavailable')
-            return true;
+function unqueueable(file) {
+    return refuse('unknown-revision', 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 partsApplied(content, path, changes, composition) {
+    const definitions = definitionsAt(composition, path);
+    const parsed = parse(content, path, definitions);
+    if (!parsed.ok)
+        return null;
+    const document = parsed.document;
+    const parts = new Map();
+    for (const change of changes) {
+        if (change.kind === 'field')
+            parts.set(`field ${change.name}`, {
+                kind: 'field',
+                name: change.name,
+                value: change.value,
+                prior: document.fields[change.name],
+            });
+        else if (change.kind === 'section')
+            parts.set(`section ${change.name}`, {
+                kind: 'section',
+                name: change.name,
+                value: change.value,
+                prior: document.sections[change.name] ?? '',
+            });
+        else
+            parts.set('preamble', { kind: 'preamble', value: change.value, prior: document.preamble });
+    }
+    const applied = apply(document, [...parts.values()], definitions(document.type));
+    return applied.outcome === 'applied' ? serialize(applied.document) : null;
+}
+function settledParts(changes, deferred, composition) {
+    for (const [held, parts] of deferred) {
+        const content = partsApplied(held.content, held.path, parts, composition);
+        if (content === null)
+            return held.path;
+        changes[changes.indexOf(held)] = { ...held, content };
     }
-    return false;
+    deferred.clear();
+    return null;
 }
-export function buildBatch(input) {
-    const changes = relativeChanges(input);
-    const structural = changes.find((change) => change.kind === 'move' || change.kind === 'remove');
-    if (structural !== undefined && unmodeledType(input.visible.collection, input.composition))
-        return refuse('model-unavailable', structural.path);
+function folded(changes, change, appending, deferred) {
+    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 parts = deferred.get(held);
+            if (parts === undefined)
+                deferred.set(held, [change]);
+            else
+                parts.push(change);
+            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 = yield* rewrites([move], after);
+    if (derived.kind === 'refused')
+        return derived;
+    const changes = [...batch.changes];
+    const appended = [];
+    let changed = false;
+    const deferred = new Map();
+    for (const change of derived.changes) {
+        if (change === move)
+            continue;
+        const unsettled = isPart(change)
+            ? null
+            : settledParts(changes, deferred, after.collection.composition);
+        if (unsettled !== null)
+            return unqueueable(unsettled);
+        const outcome = folded(changes, change, appending, deferred);
+        if (outcome === 'refused')
+            return unqueueable(change.path);
+        if (outcome === 'appended')
+            appended.push(change);
+        if (outcome !== 'skipped')
+            changed = true;
+    }
+    const unsettled = settledParts(changes, deferred, after.collection.composition);
+    if (unsettled !== null)
+        return unqueueable(unsettled);
+    if (!changed)
+        return { kind: 'relinked', batch };
+    const held = new Set(batch.preconditions.map(identity));
+    const added = yield* preconditionsOf(appended, before, []);
+    return {
+        kind: 'relinked',
+        batch: immutable({
+            ...batch,
+            id: changeBatchIdentity(),
+            changes,
+            preconditions: [
+                ...batch.preconditions,
+                ...added.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 refuse('no-change');
-    const rewritten = rewrites(changes, input.visible);
-    if (rewritten.kind === 'refused')
-        return rewritten;
-    const refusal = guard(changes, input);
-    if (refusal !== null)
-        return refusal;
-    const preconditions = preconditionsOf(changes, input.visible, input.bases);
-    const predicted = anticipated(changes, preconditions, rewritten.changes, input.visible);
-    const resulting = overlay(input.visible, [
-        { id: '', baseRoomVersion: input.baseRoomVersion, ...predicted },
-    ]);
-    const removed = new Set(changes.filter((change) => change.kind === 'remove').map((change) => change.path));
+        return null;
+    const preconditions = [
+        ...added,
+        ...batch.preconditions.filter((precondition) => precondition.kind !== 'absent' || !vacated.has(precondition.path)),
+    ];
+    return immutable({ ...batch, id: changeBatchIdentity(), changes, preconditions });
+}
+function* requeuing(queue, changes, visible, changeable, state) {
+    const next = [...queue];
+    const origins = new Map();
+    const withdrawn = new Map();
+    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' ? yield* state(next.slice(0, index)) : visible;
+        for (const [offset, batch] of following.entries()) {
+            let current = batch;
+            if (change.kind === 'move') {
+                const after = yield* state(next.slice(0, index + offset + 1));
+                const appending = offset === 0 && created(batch, queuedFile(batch, change.path, held.localId));
+                const relinking = yield* relinked(batch, change, before, after, appending);
+                if (relinking.kind === 'refused')
+                    return relinking;
+                current = relinking.batch;
+                before = after;
+            }
+            if (current !== batch && (!open(batch) || batch.between !== undefined))
+                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);
+        }
+        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,
+    };
+}
+function* limiting(queue, batch, limits, state) {
+    const at = queue.indexOf(batch);
+    const rewritten = yield* providerRewritten(batch, yield* state(queue.slice(0, at)));
+    const limited = yield* exceeding(limits, batch.changes, rewritten.changes, yield* state(queue.slice(0, at + 1)));
+    return limited?.refusal ?? null;
+}
+function typedText(content) {
+    if (content === undefined)
+        return false;
+    const parsed = parse(content);
+    return parsed.ok && parsed.document.type !== undefined && parsed.document.type !== 'any';
+}
+function touchedLibrary(resulting, touched, composition) {
+    const entries = touched
+        .flatMap((path) => {
+        const content = resulting.documents[path];
+        const binary = resulting.binaries[path] !== undefined;
+        return content === undefined && !binary ? [] : [{ path, content: content ?? null }];
+    })
+        .sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
+    const contents = new Map(entries.map(({ path, content }) => [path, content]));
+    const binaries = new Set(Array.from(entriesIn(resulting.binaries), ([path]) => path));
+    return validatedCollection(() => Promise.resolve({ entries, next: null }), async (paths) => {
+        const known = new Map();
+        const pace = paced();
+        for (const path of paths) {
+            const content = contents.get(path);
+            if (binaries.has(path))
+                known.set(path, { type: undefined, binary: true });
+            else if (content !== undefined && content !== null) {
+                const read = parse(content, path, definitionsAt(composition, path));
+                if (read.ok)
+                    known.set(path, { type: read.document.type ?? 'any', binary: false });
+                await pace(content.length + ROW_WEIGHT);
+            }
+        }
+        return known;
+    }, composition);
+}
+async function judging(visible, resulting, composition, validate, removed, touched) {
     if (removed.size > 0) {
-        const referenced = incoming(collectionOf(resulting.documents, input.composition), removed);
+        const referenced = await stepped(incoming(collectionOf(resulting.documents, composition), removed, null));
         if (referenced !== null)
             return referenced;
     }
-    const typed = (content) => {
-        if (content === undefined)
-            return false;
-        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 needsModel = typedPaths.length > 0;
-    const withoutModel = typedPaths.find((path) => governing(input.composition, path).status === 'unavailable');
+    const typedPaths = [];
+    const pace = paced();
+    for (const path of touched) {
+        const before = visible.documents[path];
+        const after = resulting.documents[path];
+        if (typedText(before) || typedText(after))
+            typedPaths.push(path);
+        await pace((before?.length ?? 0) + (after?.length ?? 0) + ROW_WEIGHT);
+    }
+    const withoutModel = typedPaths.find((path) => governing(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 = typedPaths.length > 0
+        ? await validate(resulting, touched)
+        : await touchedLibrary(resulting, touched, composition);
     if (verdict.verdict === 'refuse') {
         return {
             kind: 'refused',
@@ -482,12 +909,93 @@ export function buildBatch(input) {
             },
         };
     }
-    const limited = exceeded(input.providerLimits, changes, resulting);
+    return {
+        kind: 'judged',
+        validated: typedPaths
+            .map((path) => governing(composition, path))
+            .find((model) => model.status !== 'unavailable'),
+    };
+}
+function placed(reference) {
+    const key = roomPathOf(reference.handle, reference.path);
+    if (reference.kind === 'link')
+        return `link ${key}`;
+    if (reference.kind === 'item')
+        return `section ${reference.section} ${key}`;
+    const pointer = reference.pointer
+        .split('/')
+        .map((segment) => (ARRAY_INDEX.test(segment) ? '-' : segment))
+        .join('/');
+    return `field ${pointer} ${key}`;
+}
+function roomReferencesIn(path, content, composition) {
+    if (content === undefined)
+        return [];
+    const definitions = definitionsAt(composition, path);
+    const parsed = parse(content, path, definitions);
+    if (!parsed.ok)
+        return [];
+    return roomReferences(parsed.document, definitions(parsed.document.type));
+}
+function* admittedRooms(changes, visible, resulting, composition) {
+    const from = new Map();
+    for (const [index, change] of changes.entries()) {
+        if (change.kind === 'move')
+            from.set(change.to, departure(changes, index));
+    }
+    for (const path of [...new Set(changes.flatMap(affected))].sort()) {
+        const now = resulting.documents[path];
+        if (now === undefined)
+            continue;
+        const held = new Set(roomReferencesIn(path, visible.documents[from.get(path) ?? path], composition).map(placed));
+        for (const reference of roomReferencesIn(path, now, composition)) {
+            if (reference.kind === 'link' || reference.crossRoom === true)
+                continue;
+            if (held.has(placed(reference)))
+                continue;
+            return refuse('unresolved-reference', path, reference.kind === 'field' ? reference.pointer : reference.section);
+        }
+        yield ROW_WEIGHT + now.length;
+    }
+    return null;
+}
+function validationOf(validated) {
+    return validated === undefined
+        ? {}
+        : {
+            validation: {
+                identity: validated.snapshot.identity,
+                version: validated.snapshot.version,
+                source: validated.status,
+            },
+        };
+}
+async function batching(input) {
+    const changes = relativeChanges(input);
+    const structural = changes.find((change) => change.kind === 'move' || change.kind === 'remove');
+    if (structural !== undefined && input.unmodeled) {
+        return refuse('model-unavailable', structural.path);
+    }
+    if (changes.length === 0)
+        return refuse('no-change');
+    const rewritten = await stepped(rewrites(changes, input.visible));
+    if (rewritten.kind === 'refused')
+        return rewritten;
+    const refusal = guard(changes, input, WRITE);
+    if (refusal !== null)
+        return refusal;
+    const preconditions = await stepped(preconditionsOf(changes, input.visible, input.bases));
+    const predicted = await stepped(anticipated(changes, preconditions, rewritten.changes, input.visible));
+    const resulting = await stepped(overlaying(input.visible, [{ id: '', baseRoomVersion: input.baseRoomVersion, ...predicted }], input.composition));
+    const judged = await judging(input.visible, resulting, input.composition, input.validate, new Set(changes.filter((change) => change.kind === 'remove').map((change) => change.path)), [...new Set(predicted.changes.flatMap(affected))]);
+    if (judged.kind === 'refused')
+        return judged;
+    const crossing = await stepped(admittedRooms(changes, input.visible, resulting, input.composition));
+    if (crossing !== null)
+        return crossing;
+    const limited = await stepped(exceeding(input.providerLimits, changes, predicted.changes, resulting));
     if (limited !== null)
         return limited;
-    const validated = typedPaths
-        .map((path) => governing(input.composition, path))
-        .find((model) => model.status !== 'unavailable');
     return {
         kind: 'batch',
         batch: immutable({
@@ -496,15 +1004,288 @@ export function buildBatch(input) {
             changes,
             preconditions,
             ...(input.writtenBy === undefined ? {} : { writtenBy: input.writtenBy }),
-            ...(validated === undefined
-                ? {}
-                : {
-                    validation: {
-                        identity: validated.snapshot.identity,
-                        version: validated.snapshot.version,
-                        source: validated.status,
-                    },
-                }),
+            ...validationOf(judged.validated),
         }),
     };
 }
+const MOVE_DOCUMENTS = 'move-documents';
+function heldAt(visible, path) {
+    return visible.documents[path] !== undefined || visible.binaries[path] !== undefined;
+}
+function arrivingText(path, to, source, moved) {
+    const content = source.visible.documents[path];
+    const document = source.visible.collection.document(path);
+    if (document === undefined)
+        return content;
+    const definition = definitionsAt(source.composition, path)(document.type);
+    const changes = crossed(document, definition, path, (named, href) => {
+        const at = moved.get(named);
+        if (at !== undefined)
+            return target(to, href) === at ? undefined : relative(to, at);
+        return heldAt(source.visible, named) ? roomPathOf(source.handle, named) : undefined;
+    });
+    if (changes.length === 0)
+        return content;
+    const applied = apply(document, changes, definition);
+    return applied.outcome === 'applied' ? serialize(applied.document) : content;
+}
+function arrivalOf({ path, to }, source, moved) {
+    const { documents, revisions, fileIds, created, changes, binaries } = source.visible;
+    const kept = {
+        ...(fileIds[path] === undefined ? {} : { fileId: fileIds[path] }),
+        ...(created[path] === undefined ? {} : { created: created[path] }),
+        ...(changes[path] === undefined ? {} : { change: changes[path] }),
+    };
+    const heads = {
+        ...(revisions[path] === undefined ? {} : { revision: revisions[path] }),
+        ...kept,
+    };
+    const binary = binaries[path];
+    if (binary?.state === 'accepted') {
+        const { byteLength, mediaType, sha256 } = binary;
+        return {
+            kind: 'arrival',
+            path: to,
+            binary: { byteLength, mediaType, sha256 },
+            ...heads,
+        };
+    }
+    const content = arrivingText(path, to, source, moved);
+    return {
+        kind: 'arrival',
+        path: to,
+        content,
+        ...(content === documents[path] ? heads : kept),
+    };
+}
+async function moving(input) {
+    const { source, destination, moves } = input;
+    const removals = moves.map(({ path }) => ({ kind: 'remove', path }));
+    const leaves = guard(removals, { ...source, local: input.local, bases: [] }, MOVE_OUT);
+    if (leaves !== null)
+        return leaves;
+    const uploading = moves.find(({ path }) => source.visible.binaries[path]?.state === 'pending');
+    if (uploading !== undefined)
+        return refuse('unknown-revision', uploading.path);
+    const moved = new Map(moves.map(({ path, to }) => [path, to]));
+    const arrivals = moves.map((move) => arrivalOf(move, source, moved));
+    const arrives = guard(arrivals, { ...destination, local: input.local, bases: [] }, WRITE);
+    if (arrives !== null)
+        return arrives;
+    const bound = input.providerLimits.find((limit) => limit.name === MOVE_DOCUMENTS)?.value;
+    if (typeof bound === 'number' && moves.length > bound) {
+        return refuse('provider-limit', undefined, MOVE_DOCUMENTS);
+    }
+    if (source.unmodeled)
+        return refuse('model-unavailable', moves[0].path);
+    const id = changeBatchIdentity();
+    const between = {
+        source: { room: source.room, baseRoomVersion: source.baseRoomVersion },
+        destination: {
+            room: destination.room,
+            baseRoomVersion: destination.baseRoomVersion,
+            handle: destination.handle,
+        },
+        moves,
+    };
+    const written = input.writtenBy === undefined ? {} : { writtenBy: input.writtenBy };
+    const leavingBatch = {
+        id,
+        baseRoomVersion: source.baseRoomVersion,
+        changes: removals,
+        preconditions: moves.map(({ path }) => existence(source.visible, path)),
+        ...written,
+        between,
+    };
+    const effective = await stepped(leavingRewritten(leavingBatch, source.visible));
+    const left = await stepped(overlaying(source.visible, [effective], source.composition));
+    const sourceJudged = await judging(source.visible, left, source.composition, source.validate, new Set(moves.map(({ path }) => path)), [...new Set(effective.changes.map((change) => change.path))]);
+    if (sourceJudged.kind === 'refused')
+        return sourceJudged;
+    const arrivingBatch = {
+        id,
+        baseRoomVersion: destination.baseRoomVersion,
+        changes: arrivals,
+        preconditions: moves.map(({ to }) => ({ kind: 'absent', path: to })),
+        ...written,
+        between,
+    };
+    const arrived = await stepped(overlaying(destination.visible, [arrivingBatch], destination.composition));
+    const destinationJudged = await judging(destination.visible, arrived, destination.composition, destination.validate, new Set(), moves.map(({ to }) => to));
+    if (destinationJudged.kind === 'refused')
+        return destinationJudged;
+    const limited = (await stepped(exceeding(input.providerLimits, removals, effective.changes, left))) ??
+        (await stepped(exceeding(input.providerLimits, arrivals, arrivals, arrived)));
+    if (limited !== null)
+        return limited;
+    return { kind: 'moved', leaving: immutable(leavingBatch), arriving: immutable(arrivingBatch) };
+}
+function changedUnderneath(saved, visible) {
+    const parts = saved.flatMap(({ path, parts: held }) => changedParts(path, held, visible));
+    return parts.length === 0
+        ? null
+        : { kind: 'refused', refusal: { code: 'changed-underneath', retryable: false, parts } };
+}
+function sideOf(room, visible) {
+    const { record } = room;
+    return {
+        room: record.locator,
+        handle: record.declaration.handle,
+        baseRoomVersion: record.roomVersion,
+        composition: room.composition,
+        rule: room.rule,
+        visible,
+        folders: room.folders,
+        queued: queuedDocuments(room.queue),
+        unmodeled: !room.modelled,
+        validate: room.validate,
+    };
+}
+function carriedDrafts(ask, from, into) {
+    return new Map(ask.saved.flatMap(({ path, parts }) => {
+        const record = from.drafts.get(path);
+        if (parts.move === undefined || record === undefined || ask.consumed.has(path))
+            return [];
+        const to = moveTarget(parts.move);
+        if (into.drafts.has(to))
+            return [];
+        const locator = into.record.locator;
+        return [[path, { ...record, locator, path: to, revision: roomDraftRevision() }]];
+    }));
+}
+async function plannedMove(ask, source, into) {
+    const destination = into.record.locator;
+    const mixed = ask.saved.find(({ parts }) => Object.keys(parts).length !== 1 || parts.move?.room !== destination);
+    if (mixed !== undefined)
+        return refuse('mixed-room-move', mixed.path);
+    const leavingVisible = await stepped(source.replay(source.queue));
+    const changed = changedUnderneath(ask.saved, leavingVisible);
+    if (changed !== null)
+        return changed;
+    const moves = ask.saved.map(({ path, parts }) => ({ path, to: moveTarget(parts.move) }));
+    const built = await moving({
+        source: sideOf(source, leavingVisible),
+        destination: sideOf(into, await stepped(into.replay(into.queue))),
+        moves,
+        providerLimits: ask.providerLimits,
+        local: ask.local,
+        ...(ask.writtenBy === undefined ? {} : { writtenBy: ask.writtenBy }),
+    });
+    if (built.kind === 'refused')
+        return built;
+    const { id } = built.leaving;
+    const carried = carriedDrafts(ask, source, into);
+    return {
+        kind: 'planned',
+        identifier: id,
+        rooms: [
+            {
+                locator: source.record.locator,
+                queue: [...source.queue, built.leaving],
+                saved: new Map([[id, ask.saved]]),
+                consumed: [...ask.consumed, ...carried.keys()],
+                carried: [],
+            },
+            {
+                locator: destination,
+                queue: [...into.queue, built.arriving],
+                saved: new Map([
+                    [id, [...carried.values()].map(({ path }) => ({ path, parts: {} }))],
+                ]),
+                consumed: [],
+                carried: [...carried.values()],
+            },
+        ],
+    };
+}
+async function plannedWithin(ask, room) {
+    const { record } = room;
+    const visible = await stepped(room.replay(room.queue));
+    const changed = changedUnderneath(ask.saved, visible);
+    if (changed !== null)
+        return changed;
+    const parts = ask.saved.map(({ path, parts: held }) => changesOf(path, held));
+    const changes = parts.flatMap(({ changes: made }) => made);
+    const requeue = await stepped(requeuing(room.queue, changes, visible, (batch) => room.changeable.has(batch.id), room.replay));
+    if (requeue.kind === 'refused')
+        return requeue;
+    const foreign = [...requeue.withdrawn.keys()].some((origin) => {
+        const writer = room.queue.find((batch) => batch.id === origin)?.writtenBy;
+        return writer?.app !== ask.writtenBy?.app || writer?.release !== ask.writtenBy?.release;
+    });
+    if (foreign)
+        return unqueueable([...requeue.queued].at(-1));
+    const input = {
+        local: ask.local,
+        baseRoomVersion: record.roomVersion,
+        composition: room.composition,
+        rule: room.rule,
+        providerLimits: ask.providerLimits,
+        handle: record.declaration.handle,
+        visible,
+        folders: room.folders,
+        changes,
+        bases: parts.flatMap(({ bases }) => bases),
+        queued: queuedDocuments(room.queue),
+        writtenBy: ask.writtenBy,
+        unmodeled: !room.modelled,
+        validate: room.validate,
+    };
+    const rewritten = requeue.withdrawn.size > 0;
+    if (rewritten) {
+        const whole = await batching({
+            ...input,
+            providerLimits: [],
+            queued: new Set([...input.queued, ...requeue.queued]),
+        });
+        if (whole.kind === 'refused')
+            return whole;
+    }
+    const own = !rewritten
+        ? await batching(input)
+        : requeue.changes.length === 0
+            ? null
+            : await batching({
+                ...input,
+                visible: await stepped(room.replay(requeue.queue)),
+                changes: requeue.changes,
+                queued: queuedDocuments(requeue.queue),
+            });
+    if (own?.kind === 'refused')
+        return own;
+    const queue = own === null ? requeue.queue : [...requeue.queue, own.batch];
+    const saved = new Map();
+    for (const [origin, rebuilt] of requeue.withdrawn) {
+        if (rebuilt === null)
+            continue;
+        const limited = await stepped(limiting(queue, rebuilt, ask.providerLimits, room.replay));
+        if (limited !== null)
+            return { kind: 'refused', refusal: limited };
+        saved.set(rebuilt.id, withdrawnDrafts(room.saved.get(origin) ?? [], changes));
+    }
+    if (own !== null) {
+        saved.set(own.batch.id, ask.saved.filter(({ path }) => !requeue.queued.has(path)));
+    }
+    const carried = carriedDrafts(ask, room, room);
+    return {
+        kind: 'planned',
+        identifier: own?.batch.id ??
+            [...requeue.withdrawn].map(([origin, rebuilt]) => rebuilt?.id ?? origin).at(-1),
+        rooms: [
+            {
+                locator: record.locator,
+                queue,
+                saved,
+                consumed: [...ask.consumed, ...carried.keys()],
+                carried: [...carried.values()],
+            },
+        ],
+    };
+}
+export function destination(locator, saved) {
+    const into = saved.find(({ parts }) => parts.move?.room !== undefined && parts.move.room !== locator);
+    return into?.parts.move?.room ?? null;
+}
+export function planSave(ask, room, into) {
+    return into === undefined ? plannedWithin(ask, room) : plannedMove(ask, room, into);
+}