@agentshouse/mdruntime 0.1.0-cf04ede9fb796 → 0.1.0-cf08ada271a7f

package/dist/save.js

@@ -1,11 +1,11 @@
-import { definitionOf } from './model.js';
-import { apply, ARRAY_INDEX, ATTACHMENT, links, parse, pointerSegments, references, relative, relativize, retarget, roomReferences, serialize, target, } from '@agentshouse/mdmodel';
+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, documentsOf, governing, } from './collection.js';
-import { changeBatchIdentity } from './identity.js';
+import { collectionOf, definitionsAt, documentsOf, governing, } from './collection.js';
+import { changeBatchIdentity, roomDraftRevision } from './identity.js';
 import { overlaying } from './overlay.js';
-import { ancestors, authoredAt, covered, normalize } from './paths.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) {
@@ -20,9 +20,6 @@ function refuse(code, file, location) {
     };
 }
 function repointed(document, definition, from, to, moves, settled) {
-    const parsed = parse(document.content, from);
-    if (!parsed.ok)
-        return [];
     const changes = [];
     const names = new Set();
     for (const { pointer, value } of definition === undefined
@@ -45,13 +42,13 @@ function repointed(document, definition, from, to, moves, settled) {
     }
     if (changes.length === 0)
         return [];
-    const applied = apply(parsed.document, changes);
+    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, changes) {
+function edited(document, changes, definition) {
     const parts = new Map();
     for (const change of changes) {
         if (change.kind === 'preamble')
@@ -66,7 +63,7 @@ function edited(document, changes) {
     }
     if (parts.size === 0)
         return document;
-    const applied = apply(document, [...parts.values()]);
+    const applied = apply(document, [...parts.values()], definition);
     return applied.outcome === 'applied' ? applied.document : document;
 }
 function bodies(path, before, after) {
@@ -81,7 +78,7 @@ function bodies(path, before, after) {
     }
     return changes;
 }
-function relinks(path, moved, before, moves) {
+function relinks(path, moved, before, moves, definition) {
     const changes = [];
     for (const link of links(before, path)) {
         const destination = moves.get(link.target) ?? link.target;
@@ -94,7 +91,7 @@ function relinks(path, moved, before, moves) {
     }
     if (changes.length === 0)
         return { kind: 'changes', changes: [] };
-    const applied = apply(before, changes);
+    const applied = apply(before, changes, definition);
     if (applied.outcome === 'refuse') {
         return {
             kind: 'refused',
@@ -117,6 +114,15 @@ function relinks(path, moved, before, moves) {
 function partKey(change) {
     return change.kind === 'section' ? `section ${change.name}` : change.kind;
 }
+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();
@@ -142,17 +148,20 @@ function* rewrites(changes, visible) {
     }
     if (moves.size === 0)
         return { kind: 'changes', changes };
+    const names = movedNames(moves);
     const merged = [...changes];
     const added = [];
     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);
+        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 = relinks(path, moved, edited(document, own.map((index) => merged[index])), moves);
+        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();
@@ -221,10 +230,10 @@ function crossed(document, definition, path, to) {
     }
     return changes;
 }
-function rewritten(path, document, changes) {
+function rewritten(path, document, changes, definition) {
     if (changes.length === 0)
         return [];
-    const applied = apply(document, changes);
+    const applied = apply(document, changes, definition);
     if (applied.outcome !== 'applied')
         return [];
     const after = applied.document;
@@ -239,7 +248,7 @@ function rewritten(path, document, changes) {
 function roomPathOf(handle, path) {
     return `/rooms/${handle}/${path}`;
 }
-export function* leavingRewritten(batch, visible) {
+function* leavingRewritten(batch, visible) {
     const between = batch.between;
     if (between === undefined)
         return batch;
@@ -248,8 +257,8 @@ export function* leavingRewritten(batch, visible) {
     for (const [path, document] of yield* documentsOf(visible.collection)) {
         if (moved.has(path))
             continue;
-        const definition = definitionOf(governing(visible.collection.composition, path), document.type);
-        derived.push(...rewritten(path, document, crossed(document, definition, path, (named) => moved.get(named))));
+        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)
@@ -291,7 +300,7 @@ function* incoming(collection, removed, candidates) {
     for (const [path, document] of candidates === null
         ? yield* documentsOf(collection)
         : read(candidates)) {
-        const definition = definitionOf(governing(collection.composition, path), document.type);
+        const definition = definitionsAt(collection.composition, path)(document.type);
         for (const { value, to } of definition === undefined ? [] : references(document, definition)) {
             if (to.includes(ATTACHMENT))
                 continue;
@@ -334,18 +343,9 @@ function guard(changes, input, removing) {
     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) ||
-                (input.authoredPaths !== undefined && !authoredAt(input.authoredPaths, normalized))) {
-                return refuse('provider-owned-path', normalized);
-            }
-            if (!input.pathRule(normalized))
-                return refuse('invalid-path', normalized);
-            for (const operation of change.kind === 'remove' ? removing : 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' || change.kind === 'arrival') {
             const taken = existing.has(change.path) ? change.path : occupied(change.path);
@@ -406,9 +406,9 @@ function guard(changes, input, removing) {
     return null;
 }
 function unrevised(input, path) {
-    return (!input.local && input.queued?.has(path) !== true && input.visible.revisions[path] === undefined);
+    return !input.local && !input.queued.has(path) && input.visible.revisions[path] === undefined;
 }
-export function queuedDocuments(queue) {
+function queuedDocuments(queue) {
     const paths = new Set();
     for (const batch of queue) {
         for (const change of batch.changes) {
@@ -544,19 +544,16 @@ function* exceeding(limits, changes, effective, 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);
@@ -564,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);
@@ -593,7 +590,7 @@ function relativeChanges(input) {
     });
 }
 function unqueueable(file) {
-    return { kind: 'refused', refusal: { code: 'unknown-revision', retryable: false, file } };
+    return refuse('unknown-revision', file);
 }
 function isPart(change) {
     return change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble';
@@ -601,8 +598,9 @@ function isPart(change) {
 function touched(change) {
     return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
-function partsApplied(content, path, changes) {
-    const parsed = parse(content, 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;
@@ -625,12 +623,12 @@ function partsApplied(content, path, changes) {
         else
             parts.set('preamble', { kind: 'preamble', value: change.value, prior: document.preamble });
     }
-    const applied = apply(document, [...parts.values()]);
+    const applied = apply(document, [...parts.values()], definitions(document.type));
     return applied.outcome === 'applied' ? serialize(applied.document) : null;
 }
-function settledParts(changes, deferred) {
+function settledParts(changes, deferred, composition) {
     for (const [held, parts] of deferred) {
-        const content = partsApplied(held.content, held.path, parts);
+        const content = partsApplied(held.content, held.path, parts, composition);
         if (content === null)
             return held.path;
         changes[changes.indexOf(held)] = { ...held, content };
@@ -705,7 +703,9 @@ function* relinked(batch, move, before, after, appending) {
     for (const change of derived.changes) {
         if (change === move)
             continue;
-        const unsettled = isPart(change) ? null : settledParts(changes, deferred);
+        const unsettled = isPart(change)
+            ? null
+            : settledParts(changes, deferred, after.collection.composition);
         if (unsettled !== null)
             return unqueueable(unsettled);
         const outcome = folded(changes, change, appending, deferred);
@@ -716,7 +716,7 @@ function* relinked(batch, move, before, after, appending) {
         if (outcome !== 'skipped')
             changed = true;
     }
-    const unsettled = settledParts(changes, deferred);
+    const unsettled = settledParts(changes, deferred, after.collection.composition);
     if (unsettled !== null)
         return unqueueable(unsettled);
     if (!changed)
@@ -777,11 +777,10 @@ function withdrawnFile(batch, change, at) {
     ];
     return immutable({ ...batch, id: changeBatchIdentity(), changes, preconditions });
 }
-export function* requeuing(queue, changes, visible, changeable, state) {
+function* requeuing(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;
@@ -827,7 +826,6 @@ export function* requeuing(queue, changes, visible, changeable, state) {
             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);
     }
@@ -837,56 +835,13 @@ export function* requeuing(queue, changes, visible, changeable, state) {
         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];
-    const deferred = new Map();
-    for (const change of extra.changes) {
-        const unsettled = isPart(change) ? null : settledParts(changes, deferred);
-        if (unsettled !== null)
-            return unqueueable(unsettled);
-        if (folded(changes, change, true, deferred) === 'refused')
-            return unqueueable(change.path);
-    }
-    const unsettled = settledParts(changes, deferred);
-    if (unsettled !== null)
-        return unqueueable(unsettled);
-    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* limiting(queue, batch, limits, state) {
+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?.kind === 'refused' ? limited.refusal : null;
+    return limited?.refusal ?? null;
 }
 function typedText(content) {
     if (content === undefined)
@@ -912,7 +867,7 @@ function touchedLibrary(resulting, touched, composition) {
             if (binaries.has(path))
                 known.set(path, { type: undefined, binary: true });
             else if (content !== undefined && content !== null) {
-                const read = parse(content, path);
+                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);
@@ -976,10 +931,11 @@ function placed(reference) {
 function roomReferencesIn(path, content, composition) {
     if (content === undefined)
         return [];
-    const parsed = parse(content, path);
+    const definitions = definitionsAt(composition, path);
+    const parsed = parse(content, path, definitions);
     if (!parsed.ok)
         return [];
-    return roomReferences(parsed.document, definitionOf(governing(composition, path), parsed.document.type));
+    return roomReferences(parsed.document, definitions(parsed.document.type));
 }
 function* admittedRooms(changes, visible, resulting, composition) {
     const from = new Map();
@@ -1030,7 +986,7 @@ async function batching(input) {
         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 }]));
+    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;
@@ -1052,7 +1008,7 @@ async function batching(input) {
         }),
     };
 }
-export const MOVE_DOCUMENTS = 'move-documents';
+const MOVE_DOCUMENTS = 'move-documents';
 function heldAt(visible, path) {
     return visible.documents[path] !== undefined || visible.binaries[path] !== undefined;
 }
@@ -1061,7 +1017,7 @@ function arrivingText(path, to, source, moved) {
     const document = source.visible.collection.document(path);
     if (document === undefined)
         return content;
-    const definition = definitionOf(governing(source.composition, path), document.type);
+    const definition = definitionsAt(source.composition, path)(document.type);
     const changes = crossed(document, definition, path, (named, href) => {
         const at = moved.get(named);
         if (at !== undefined)
@@ -1070,7 +1026,7 @@ function arrivingText(path, to, source, moved) {
     });
     if (changes.length === 0)
         return content;
-    const applied = apply(document, changes);
+    const applied = apply(document, changes, definition);
     return applied.outcome === 'applied' ? serialize(applied.document) : content;
 }
 function arrivalOf({ path, to }, source, moved) {
@@ -1103,11 +1059,9 @@ function arrivalOf({ path, to }, source, moved) {
     };
 }
 async function moving(input) {
-    const { source, destination, moves, pathRule } = input;
-    if (moves.length === 0)
-        return refuse('no-change');
+    const { source, destination, moves } = input;
     const removals = moves.map(({ path }) => ({ kind: 'remove', path }));
-    const leaves = guard(removals, { ...source, local: input.local, bases: [], pathRule }, MOVE_OUT);
+    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');
@@ -1115,7 +1069,7 @@ async function moving(input) {
         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: [], pathRule }, WRITE);
+    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;
@@ -1144,7 +1098,7 @@ async function moving(input) {
         between,
     };
     const effective = await stepped(leavingRewritten(leavingBatch, source.visible));
-    const left = await stepped(overlaying(source.visible, [effective]));
+    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;
@@ -1156,7 +1110,7 @@ async function moving(input) {
         ...written,
         between,
     };
-    const arrived = await stepped(overlaying(destination.visible, [arrivingBatch]));
+    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;
@@ -1166,9 +1120,172 @@ async function moving(input) {
         return limited;
     return { kind: 'moved', leaving: immutable(leavingBatch), arriving: immutable(arrivingBatch) };
 }
-export function buildMove(input) {
-    return moving(input);
+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 buildBatch(input) {
-    return batching(input);
+export function planSave(ask, room, into) {
+    return into === undefined ? plannedWithin(ask, room) : plannedMove(ask, room, into);
 }

package/dist/saves.d.ts

@@ -1,11 +1,9 @@
-import { type ChangeSet } from './change-set.js';
 import { type ChangeBatch, type WrittenBy } from './change.js';
 import { type AttachAnswer, type BinaryLinkAnswer, type HeldBinaryAnswer, type HeldShownAnswer } from './outcome.js';
-import { type HeldReplica, type ReplicaRecord, type Slice, type VisibleLayer } from './replica.js';
-import { type ReturnReason, type RoomDraftParts } from './room-draft.js';
+import { type RoomDraftParts } from './room-draft.js';
 import type { Runtime } from './runtime.js';
 import { type SaveRefusal } from './save.js';
-import type { AuthoredWrite, CommittedWrite, PendingState, RoomCommit, RuntimeStore, Store, StoredEntry, View, Work } from './store.js';
+import type { Store } from './store.js';
 export type SaveResult = {
     outcome: 'saved';
     identifier: string;
@@ -27,42 +25,6 @@ export type BinaryFileSurface = {
     attach(room: string, file: File): Promise<AttachAnswer>;
     part(file: string, part: number): Promise<Uint8Array | null>;
 };
-export type Leaving = {
-    batch: ChangeBatch;
-    returned: ReturnReason | null;
-};
-export declare function withdrawable(states: ReadonlyMap<string, PendingState>): (batch: ChangeBatch) => boolean;
-export declare function sliceAt(store: Store, record: ReplicaRecord, view: View, queue: readonly ChangeBatch[], extra?: Iterable<string>, moved?: Iterable<string>): Promise<Slice>;
-export declare function landedWhole(store: Store, locator: string, batch: ChangeBatch, confirmedLayer: Slice, current?: Readonly<Record<string, string>>): Promise<boolean>;
-export type Settling = {
-    leaving?: readonly Leaving[];
-    room?: boolean;
-    view?: View;
-    commit?: Pick<RoomCommit, 'published' | 'refreshed'>;
-    changes?: {
-        readonly set: readonly StoredEntry[];
-        readonly removed: readonly string[];
-    };
-};
-export declare function preparedAfter(runtime: Runtime, locator: string, answer: CommittedWrite): void;
-export declare function replayed(store: Store, record: ReplicaRecord, confirmedLayer: Slice, queue: readonly ChangeBatch[]): import("./turn.js").Later<import("./replica.js").Replayed>;
-export declare function overlayDiff(record: ReplicaRecord, before: HeldReplica | undefined, visible: VisibleLayer, touched: ReadonlySet<string>): Promise<{
-    overlay: NonNullable<RoomCommit['overlay']>;
-    touched: ReadonlySet<string>;
-}>;
-export type Settlement = {
-    readonly locator: string;
-    readonly left: readonly ChangeBatch[];
-    readonly commit: {
-        readonly rooms: readonly RoomCommit[];
-        readonly writes: readonly AuthoredWrite[];
-    };
-    apply(answer: CommittedWrite): ChangeSet;
-};
-export declare function settle(runtime: Runtime, local: RuntimeStore, locator: string, work: Work, record: ReplicaRecord, queue: readonly ChangeBatch[], settling?: Settling): Promise<ChangeSet>;
-export declare function together(runtime: Runtime, local: RuntimeStore, settlements: readonly Settlement[]): Promise<ChangeSet>;
-export declare function settlement(runtime: Runtime, local: RuntimeStore, locator: string, work: Work, record: ReplicaRecord, queue: readonly ChangeBatch[], settling?: Settling): Promise<Settlement>;
-export declare function unpairing(runtime: Runtime, local: RuntimeStore, locator: string, batches: readonly ChangeBatch[]): Promise<Settlement>;
 export declare function saveRoomDrafts(runtime: Runtime, locator: string, named: readonly SavedRoomDraft[], writtenBy: WrittenBy | undefined): Promise<SaveResult>;
 export declare function saveParts(runtime: Runtime, locator: string, named: readonly SavedParts[], writtenBy: WrittenBy | undefined): Promise<SaveResult>;
 export declare function batchFile(store: Store, batch: ChangeBatch): (localId: string) => Promise<Blob>;