@agentshouse/mdruntime 0.1.0-cd26b960b7262 → 0.1.0-cd35ccee27a19

package/dist/saves.js

@@ -1,403 +1,85 @@
 import { parseFrontmatter } from '@agentshouse/mdmodel';
 import { binaryRecord } from './binary.js';
-import { changeSet, mergeChangeSets } from './change-set.js';
-import { leaving as leavingIn, partnerOf, queuedFile, } from './change.js';
-import { available, composedOf } from './collection.js';
+import { queuedFile } from './change.js';
+import { available } from './collection.js';
 import { runtimeError } from './failure.js';
 import { attachedFile } from './file.js';
-import { roomDraftRevision } from './identity.js';
-import { confirmedAgain } from './install.js';
 import { compositionFor } from './listing.js';
+import { scoped } from './models.js';
 import { absentBinary, attachAnswer, binaryAnswer, binaryLinkAnswer, failure, OFFLINE, UNCERTAIN, } from './outcome.js';
 import { sameBinary } from './overlay.js';
 import { ancestors } from './paths.js';
-import { connectionNow, prepare } from './preparation.js';
-import { entryAt, landed, movedBy, overlayOf, replaying, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
-import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, moveTarget, readSavedParts, returnedBy, returnedInto, withdrawnDrafts, } from './room-draft.js';
+import { connectionNow } from './preparation.js';
+import { append, sliceAt, withdrawable } from './queue.js';
+import { entryAt, replaying, slicing, } from './replica.js';
+import { binaryBase, changesOf, held, heldFile, moveTarget, readSavedParts, } from './room-draft.js';
 import { refuse } from './refusal.js';
 import { visibleOf } from './room-drafts.js';
-import { documentKey } from './rows.js';
-import { buildBatch, buildMove, joined, limiting, queuedDocuments, requeuing, } from './save.js';
+import { destination, planSave, } from './save.js';
 import { pendingShown } from './shown.js';
 import { paced, ROW_WEIGHT, stepped } from './turn.js';
 import { validatedNeighbourhood } from './validation.js';
-export function withdrawable(states) {
-    return (batch) => {
-        const state = states.get(batch.id);
-        return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
-    };
-}
-export async function sliceAt(store, record, view, queue, extra = [], moved = []) {
-    const local = await store.open();
-    const needed = new Set([...touchedBy(queue), ...extra]);
-    const movedPaths = [...new Set([...movedBy(queue, record.locator), ...moved])];
-    if (movedPaths.length > 0) {
-        for (const { path } of await local.referrers(record.key, view, movedPaths)) {
-            needed.add(path);
-        }
-    }
-    const paths = [...needed];
-    return stepped(slicing(await local.entries(record.key, view, paths), paths));
-}
-export async function landedWhole(store, locator, batch, confirmedLayer, current) {
-    if (!landed(batch, confirmedLayer, current))
-        return false;
-    const partner = partnerOf(batch, locator);
-    if (partner === null)
-        return true;
-    const other = await store.replica(partner);
-    const half = other?.queue.find((one) => one.id === batch.id);
-    if (other === undefined || half === undefined)
-        return false;
-    return landed(half, await sliceAt(store, other.record, 'confirmed', [half]));
-}
-async function carriedBack(store, locator, unlanded, written) {
-    const back = new Map();
-    const taken = [];
-    for (const batch of unlanded) {
-        const between = batch.between;
-        if (between === undefined)
-            continue;
-        const source = between.source.room;
-        const destination = between.destination.room;
-        const local = await store.open();
-        const arrived = (await local.pending(destination, batch.id)).state?.drafts ?? [];
-        for (const { path: to } of arrived) {
-            const record = await store.draft(destination, to);
-            const path = between.moves.find((move) => move.to === to)?.path;
-            if (record === undefined || path === undefined)
-                continue;
-            const [into, key] = source === locator ? [written, path] : [back, documentKey(source, path)];
-            const existing = into.get(key) ?? (await store.draft(source, path));
-            taken.push({ locator: destination, path: to });
-            into.set(key, {
-                locator: source,
-                path,
-                revision: roomDraftRevision(),
-                parts: returnedInto(existing?.parts, record.parts),
-                returned: existing?.returned ?? null,
-            });
-        }
-    }
-    const records = [...back.values()];
-    const elsewhere = taken.filter((one) => one.locator !== locator);
-    const rooms = new Set([...records, ...elsewhere].map((one) => one.locator));
-    return {
-        taken: taken.filter((one) => one.locator === locator).map(({ path }) => path),
-        writes: [...rooms].map((room) => ({
-            locator: room,
-            roomDrafts: records.filter((record) => record.locator === room),
-            consumedRoomDrafts: elsewhere.filter((one) => one.locator === room).map(({ path }) => path),
-        })),
-        changes: [...rooms].map((room) => changeSet(room, {
-            drafts: [...records, ...elsewhere]
-                .filter((one) => one.locator === room)
-                .map(({ path }) => path),
-        })),
-    };
-}
-export function preparedAfter(runtime, locator, answer) {
-    if (answer.indexed[locator] === false)
-        prepare(runtime, [locator]);
-}
-export function replayed(store, record, confirmedLayer, queue) {
-    return stepped(replaying(confirmedLayer, queue, record.locator, store.composed(record)));
-}
-export async function overlayDiff(record, before, visible, touched) {
-    const kept = before !== undefined && before.record.key === record.key ? before.overlaid : new Set();
-    return {
-        overlay: {
-            set: await stepped(overlayOf(visible, touched)),
-            cleared: [...kept].filter((path) => !touched.has(path)),
-        },
-        touched,
-    };
-}
-export async function settle(runtime, local, locator, work, record, queue, settling = {}) {
-    return together(runtime, local, [
-        await settlement(runtime, local, locator, work, record, queue, settling),
-    ]);
-}
-async function unpairedIn(store, locator, batch) {
-    const { state } = await (await store.open()).pending(locator, batch.id);
-    if (state === undefined)
-        return false;
-    return !leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch);
-}
-export async function together(runtime, local, settlements) {
-    const settled = new Set(settlements.map(({ locator }) => locator));
-    const all = [...settlements];
-    for (let wave = settlements; wave.length > 0;) {
-        const partnered = new Map();
-        for (const { locator, left } of wave) {
-            for (const batch of left) {
-                const partner = partnerOf(batch, locator);
-                if (partner === null ||
-                    settled.has(partner) ||
-                    !(await unpairedIn(runtime.store, partner, batch))) {
-                    continue;
-                }
-                partnered.set(partner, [...(partnered.get(partner) ?? []), batch]);
-            }
-        }
-        const partners = [];
-        for (const [partner, batches] of partnered) {
-            settled.add(partner);
-            partners.push(await unpairing(runtime, local, partner, batches));
-        }
-        all.push(...partners);
-        wave = partners;
-    }
-    const answer = await local.commit({
-        rooms: all.flatMap(({ commit }) => commit.rooms),
-        writes: all.flatMap(({ commit }) => commit.writes),
-    });
-    return mergeChangeSets(all.map((one) => one.apply(answer)));
-}
-export async function settlement(runtime, local, locator, work, record, queue, settling = {}) {
-    const { store, journal, localSaves } = runtime;
-    const before = work.replica;
-    const view = settling.view ?? 'confirmed';
-    const previousQueue = work.queue;
-    const overrides = settling.changes;
-    const read = await sliceAt(store, record, view, queue, [
-        ...(before !== undefined && before.record.key === record.key ? before.overlaid : []),
-        ...(overrides?.set.map(({ path }) => path) ?? []),
-        ...(overrides?.removed ?? []),
-    ]);
-    const confirmedLayer = overrides === undefined
-        ? read
-        : await stepped(slicingWith(read, overrides.set, overrides.removed));
-    const composition = store.composed(record);
-    const shown = queue.filter((batch) => {
-        const held = store.landed.of(locator, batch.id);
-        return (held !== undefined &&
-            Object.entries(held).some(([path, revision]) => confirmedLayer.revisions[path] !== revision));
-    });
-    const unshown = queue.filter((batch) => !shown.includes(batch));
-    const { withdrawn, kept } = await stepped(standing(confirmedLayer, unshown, withdrawable(work.states), localSaves, locator, composition));
-    const founded = kept.filter((batch) => !unshown.includes(batch));
-    const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
-    const unqueued = shown.map((batch) => ({ batch, landed: true }));
-    for (const batch of withdrawn) {
-        unqueued.push({ batch, landed: await landedWhole(store, locator, batch, confirmedLayer) });
-    }
-    const returning = [
-        ...[...unqueued].reverse().map(({ batch, landed: held }) => ({
-            batch,
-            returned: localSaves || held ? null : returnedBy(),
-        })),
-        ...(settling.leaving ?? []),
-    ];
-    const written = new Map();
-    for (const { batch, returned: reason } of returning) {
-        if (reason === null || batch.between?.destination.room === locator)
-            continue;
-        for (const saved of work.states.get(batch.id)?.drafts ?? []) {
-            const existing = written.get(saved.path) ?? (await store.draft(locator, saved.path));
-            written.set(saved.path, {
-                locator,
-                path: saved.path,
-                revision: roomDraftRevision(),
-                parts: returnedInto(existing?.parts, saved.parts),
-                returned: reason,
-            });
-        }
-    }
-    const carried = await carriedBack(store, locator, [
-        ...[...unqueued].reverse().flatMap(({ batch, landed: held }) => (held ? [] : [batch])),
-        ...(settling.leaving ?? []).flatMap(({ batch, returned }) => returned === null ? [] : [batch]),
-    ], written);
-    const replayedLayer = await replayed(store, record, confirmedLayer, kept);
-    const { overlay } = await overlayDiff(record, before, replayedLayer.visible, replayedLayer.touched);
-    const commit = {
-        rooms: [
-            {
-                locator,
-                key: record.key,
-                record: storedRecord(record),
-                roots: record.typedSelection?.roots ?? [],
-                composed: composedOf(composition),
-                ...settling.commit,
-                ...(overrides === undefined
-                    ? {}
-                    : { confirmed: { set: overrides.set, removed: overrides.removed } }),
-                overlay,
-            },
-        ],
-        writes: [
-            {
-                locator,
-                queue: kept,
-                stored: previousQueue,
-                founded,
-                roomDrafts: [...written.values()],
-                consumedRoomDrafts: carried.taken,
-            },
-            ...carried.writes,
-        ],
-    };
-    const staying = new Set(kept.map((batch) => batch.id));
-    return {
-        locator,
-        left: previousQueue.filter((batch) => !staying.has(batch.id)),
-        commit,
-        apply: (answer) => {
-            for (const batch of previousQueue) {
-                if (!staying.has(batch.id))
-                    store.landed.drop(locator, batch.id);
-            }
-            const drafts = [...written.keys(), ...carried.taken];
-            for (const { batch, landed: held } of unqueued) {
-                const outcome = localSaves ? 'dropped' : held ? 'landed' : 'withdrawn';
-                journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
-            }
-            const changed = answer.changed[locator];
-            if (settling.commit?.published !== undefined ||
-                settling.commit?.refreshed === true ||
-                overrides !== undefined) {
-                confirmedAgain(store, locator);
-            }
-            preparedAfter(runtime, locator, answer);
-            return mergeChangeSets([
-                changeSet(locator, {
-                    documents: changed === undefined ? [] : changed,
-                    room: settling.room,
-                    queue: queueChanged,
-                    drafts,
-                }),
-                ...carried.changes,
-            ]);
-        },
-    };
-}
-export async function unpairing(runtime, local, locator, batches) {
-    const { store, journal, localSaves, submitLater } = runtime;
-    const ids = new Set(batches.map(({ id }) => id));
-    const leaving = batches.map((batch) => ({
-        batch,
-        returned: !localSaves && leavingIn(batch, locator) ? returnedBy() : null,
-    }));
-    const outcome = localSaves ? 'dropped' : 'unpaired';
-    const work = await store.work(locator);
-    const current = work.replica;
-    if (current !== undefined) {
-        const settled = await settlement(runtime, local, locator, work, current.record, current.queue.filter((one) => !ids.has(one.id)), { leaving });
-        return {
-            ...settled,
-            apply(answer) {
-                for (const batch of batches)
-                    journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
-                const set = settled.apply(answer);
-                submitLater(locator);
-                return set;
-            },
-        };
-    }
-    const queue = work.queue.filter((one) => !ids.has(one.id));
-    const written = new Map();
-    for (const { batch, returned } of leaving) {
-        if (returned === null)
-            continue;
-        for (const saved of work.states.get(batch.id)?.drafts ?? []) {
-            written.set(saved.path, {
-                locator,
-                path: saved.path,
-                revision: roomDraftRevision(),
-                parts: returnedInto((written.get(saved.path) ?? (await store.draft(locator, saved.path)))?.parts, saved.parts),
-                returned,
-            });
-        }
-    }
-    const carried = await carriedBack(store, locator, leaving.flatMap(({ batch, returned }) => (returned === null ? [] : [batch])), written);
-    return {
-        locator,
-        left: batches,
-        commit: {
-            rooms: [],
-            writes: [
-                {
-                    locator,
-                    queue,
-                    stored: work.queue,
-                    roomDrafts: [...written.values()],
-                    consumedRoomDrafts: carried.taken,
-                },
-                ...carried.writes,
-            ],
-        },
-        apply() {
-            for (const batch of batches)
-                journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
-            submitLater(locator);
-            return mergeChangeSets([
-                changeSet(locator, {
-                    queue: true,
-                    drafts: [...written.keys(), ...carried.taken],
-                }),
-                ...carried.changes,
-            ]);
-        },
-    };
-}
-async function savedRoom(store, locator) {
-    const local = await store.open();
+const FULL = { outcome: 'refused', code: 'durable-write', retryable: true };
+async function savedRoom({ store, presence }, locator) {
     const replica = await store.replica(locator);
-    if (replica === undefined || store.fences.has(locator)) {
+    if (replica === undefined || presence.lost(locator)) {
         throw runtimeError('unknown-room', `Unknown Room ${locator}`);
     }
-    return { local, replica };
+    return replica;
 }
-export async function saveRoomDrafts(runtime, locator, named, writtenBy) {
+export function saveRoomDrafts(runtime, locator, named, writtenBy) {
     const { store } = runtime;
-    const target = await savedRoom(store, locator);
-    const drafts = new Map((await store.drafts(locator, named.map(({ path }) => path))).map((record) => [record.path, record]));
-    const saved = [];
-    for (const { path, revision } of named) {
-        const record = drafts.get(path);
-        if (record === undefined || record.revision !== revision) {
-            return { outcome: 'refused', code: 'stale', retryable: false, file: path };
+    return store.exclusive(async () => {
+        if (store.space.full())
+            return FULL;
+        const replica = await savedRoom(runtime, locator);
+        const drafts = new Map((await store.drafts(locator, named.map(({ path }) => path))).map((record) => [record.path, record]));
+        const saved = [];
+        for (const { path, revision } of named) {
+            const record = drafts.get(path);
+            if (record === undefined || record.revision !== revision) {
+                return { outcome: 'refused', code: 'stale', retryable: false, file: path };
+            }
+            if (!saved.some((draft) => draft.path === path))
+                saved.push({ path, parts: record.parts });
         }
-        if (!saved.some((draft) => draft.path === path))
-            saved.push({ path, parts: record.parts });
-    }
-    return committed(runtime, locator, target, saved, new Set(saved.map(({ path }) => path)), writtenBy);
+        return loaded(runtime, locator, replica, saved, new Set(saved.map(({ path }) => path)), [], writtenBy);
+    });
 }
-export async function saveParts(runtime, locator, named, writtenBy) {
+export function saveParts(runtime, locator, named, writtenBy) {
     const { store } = runtime;
-    const read = readSavedParts(named);
-    const target = await savedRoom(store, locator);
-    const saved = [];
-    const files = [];
-    const filed = read.filter(({ parts }) => parts.file !== undefined).map(({ path }) => path);
-    const visible = filed.length === 0 ? undefined : await visibleOf(store, locator, filed);
-    for (const { path, parts } of read) {
-        const file = parts.file === undefined
-            ? undefined
-            : await heldFile(parts.file.blob, parts.file.base === undefined ? binaryBase(visible, path) : parts.file.base);
-        if (parts.file !== undefined && file !== undefined) {
-            files.push({ key: file.localId, blob: parts.file.blob });
+    return store.exclusive(async () => {
+        const read = readSavedParts(named);
+        if (store.space.full())
+            return FULL;
+        const replica = await savedRoom(runtime, locator);
+        const saved = [];
+        const files = [];
+        const filed = read.filter(({ parts }) => parts.file !== undefined).map(({ path }) => path);
+        const visible = filed.length === 0 ? undefined : await visibleOf(store, locator, filed);
+        for (const { path, parts } of read) {
+            const file = parts.file === undefined
+                ? undefined
+                : await heldFile(parts.file.blob, parts.file.base === undefined ? binaryBase(visible, path) : parts.file.base);
+            if (parts.file !== undefined && file !== undefined) {
+                files.push({ key: file.localId, blob: parts.file.blob });
+            }
+            saved.push({ path, parts: held(undefined, parts, file) });
         }
-        saved.push({ path, parts: held(undefined, parts, file) });
-    }
-    return committed(runtime, locator, target, saved, new Set(), writtenBy, files);
+        return loaded(runtime, locator, replica, saved, new Set(), files, writtenBy);
+    });
 }
-async function carriedDrafts(store, locator, saved, consumed) {
-    if (!saved.some(({ parts }) => parts.move !== undefined))
-        return new Map();
-    const holding = new Map((await store.drafts(locator)).map((record) => [record.path, record]));
-    return new Map(saved.flatMap(({ path, parts }) => {
-        const record = holding.get(path);
-        if (parts.move === undefined || record === undefined || consumed.has(path))
-            return [];
-        const to = moveTarget(parts.move);
-        if (to === path || holding.has(to))
-            return [];
-        return [[path, { ...record, path: to, revision: roomDraftRevision() }]];
-    }));
+async function unmodeledIn(runtime, record) {
+    const composition = compositionFor(runtime, record);
+    if (available(composition))
+        return false;
+    const local = await runtime.store.open();
+    const roots = record.declaration.typedSelection?.roots ?? [];
+    return local.typedWithin(record.key, 'visible', roots, false);
 }
-async function savingIn(store, replica, changes, extra) {
-    const record = replica.record;
+async function savingRoom(runtime, replica, changes, extra, drafted) {
+    const { store } = runtime;
+    const { record, queue, states } = replica;
     const local = await store.open();
     const paths = [
         ...extra,
@@ -408,26 +90,55 @@ async function savingIn(store, replica, changes, extra) {
     const referring = removed.length === 0
         ? []
         : (await local.referrers(record.key, 'confirmed', removed)).map(({ path }) => path);
-    const confirmedLayer = await sliceAt(store, record, 'confirmed', replica.queue, [...paths, ...paths.flatMap(ancestors), ...referring], moved);
-    const { visible } = await replayed(store, record, confirmedLayer, replica.queue);
+    const confirmed = await sliceAt(store, record, 'confirmed', queue, [...paths, ...paths.flatMap(ancestors), ...referring], moved);
     const composition = store.composed(record);
+    const changeable = withdrawable(states);
     return {
-        record,
-        confirmed: confirmedLayer,
-        visible,
-        folders: new Set(await local.folders(record.key, paths)),
-        *visibleOver(queue) {
-            return (yield* replaying(confirmedLayer, queue, record.locator, composition)).visible;
+        held: { replica, confirmed },
+        room: {
+            record,
+            rule: runtime.writeRule(record.declaration),
+            composition: compositionFor(runtime, record),
+            queue,
+            changeable: new Set(queue.filter(changeable).map(({ id }) => id)),
+            saved: new Map([...states].map(([id, state]) => [id, state.drafts])),
+            *replay(over) {
+                return (yield* replaying(confirmed, over, record.locator, composition)).visible;
+            },
+            folders: new Set(await local.folders(record.key, paths)),
+            modelled: !(await unmodeledIn(runtime, record)),
+            drafts: new Map(drafted.length === 0
+                ? []
+                : (await store.drafts(record.locator, drafted)).map((held) => [held.path, held])),
+            validate: validatorOf(runtime, record, confirmed),
         },
     };
 }
-async function unmodeledIn(runtime, record) {
-    const composition = compositionFor(runtime, record);
-    if (available(composition))
-        return false;
-    const local = await runtime.store.open();
-    const roots = record.typedSelection?.roots ?? [];
-    return local.typedWithin(record.key, 'visible', roots, false);
+function targetsOf(saved) {
+    return saved.flatMap(({ parts }) => (parts.move === undefined ? [] : [moveTarget(parts.move)]));
+}
+async function loaded(runtime, locator, replica, saved, consumed, files, writtenBy) {
+    const { store, localSaves } = runtime;
+    const into = destination(locator, saved);
+    const target = into === null ? undefined : await savedRoom(runtime, into);
+    const paths = saved.map(({ path }) => path);
+    const targets = targetsOf(saved);
+    const parts = saved.map(({ path, parts: held }) => changesOf(path, held));
+    const source = target === undefined
+        ? await savingRoom(runtime, replica, parts.flatMap(({ changes }) => changes), [...paths, ...parts.flatMap(({ bases }) => bases.map(({ path }) => path))], targets.length === 0 ? [] : [...paths, ...targets])
+        : await savingRoom(runtime, replica, paths.map((path) => ({ kind: 'remove', path })), paths, paths);
+    const arriving = target === undefined ? undefined : await savingRoom(runtime, target, [], targets, targets);
+    const { providerLimits } = await (await store.open()).facts();
+    const plan = await planSave({ saved, consumed, writtenBy, local: localSaves, providerLimits }, source.room, arriving?.room);
+    return append(runtime, {
+        plan,
+        files,
+        held: new Map([source, ...(arriving === undefined ? [] : [arriving])].map(({ room, held }) => [
+            room.record.locator,
+            held,
+        ])),
+        after: () => pendingShown(runtime),
+    });
 }
 function textDiffers(left, right) {
     return ((left?.content ?? undefined) !== (right?.content ?? undefined) ||
@@ -503,309 +214,6 @@ function referrersOf(local, key, view) {
         ...new Set((await local.referrers(key, view, targets)).map(({ path }) => path)),
     ];
 }
-async function sideOf(runtime, locator, replica, saving) {
-    const record = replica.record;
-    return {
-        room: locator,
-        handle: record.handle,
-        baseRoomVersion: record.roomVersion,
-        composition: compositionFor(runtime, record),
-        operations: record.operations,
-        providerOwnedPaths: record.providerOwnedPaths,
-        authoredPaths: record.authoredPaths,
-        visible: saving.visible,
-        folders: saving.folders,
-        queued: queuedDocuments(replica.queue),
-        unmodeled: await unmodeledIn(runtime, record),
-        validate: validatorOf(runtime, record, saving.confirmed),
-    };
-}
-function movedInto(locator, saved) {
-    const into = saved.find(({ parts }) => parts.move?.room !== undefined && parts.move.room !== locator);
-    return into?.parts.move?.room ?? null;
-}
-async function saveCommit(store, local, files, rooms) {
-    const commits = [];
-    for (const { locator, saving, before, queue } of rooms) {
-        const replayedLayer = await replayed(store, saving.record, saving.confirmed, queue);
-        const diff = await overlayDiff(saving.record, before, replayedLayer.visible, replayedLayer.touched);
-        commits.push({
-            locator,
-            key: saving.record.key,
-            roots: saving.record.typedSelection?.roots ?? [],
-            composed: composedOf(store.composed(saving.record)),
-            overlay: diff.overlay,
-        });
-    }
-    try {
-        return await local.commit({
-            rooms: commits,
-            writes: rooms.map(({ write }) => write),
-            files,
-            whole: true,
-        });
-    }
-    catch {
-        return null;
-    }
-}
-async function committedMove(runtime, locator, destination, { local, replica }, saved, consumed, writtenBy, files) {
-    const { store, localSaves } = runtime;
-    const mixed = saved.find(({ parts }) => Object.keys(parts).length !== 1 || parts.move?.room !== destination);
-    if (mixed !== undefined) {
-        return { outcome: 'refused', code: 'mixed-room-move', retryable: false, file: mixed.path };
-    }
-    const moves = saved.map(({ path, parts }) => ({ path, to: moveTarget(parts.move) }));
-    const sourceSaving = await savingIn(store, replica, moves.map(({ path }) => ({ kind: 'remove', path })), saved.map(({ path }) => path));
-    const changed = saved.flatMap(({ path, parts }) => changedParts(path, parts, sourceSaving.visible));
-    if (changed.length > 0)
-        return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
-    const target = await store.replica(destination);
-    if (target === undefined || store.fences.has(destination)) {
-        throw runtimeError('unknown-room', `Unknown Room ${destination}`);
-    }
-    const arriving = await savingIn(store, target, [], moves.map(({ to }) => to));
-    const built = await buildMove({
-        source: await sideOf(runtime, locator, replica, sourceSaving),
-        destination: await sideOf(runtime, destination, target, arriving),
-        moves,
-        providerLimits: (await local.facts()).providerLimits,
-        pathRule: runtime.pathRule,
-        local: localSaves,
-        ...(writtenBy === undefined ? {} : { writtenBy }),
-    });
-    if (built.kind === 'refused')
-        return { outcome: 'refused', ...built.refusal };
-    const id = built.leaving.id;
-    const leavingDrafts = new Map((await store.drafts(locator, saved.map(({ path }) => path))).map((record) => [record.path, record]));
-    const arrivingDrafts = new Set((await store.drafts(destination, moves.map(({ to }) => to))).map(({ path }) => path));
-    const carrying = saved.flatMap(({ path, parts }) => {
-        const record = leavingDrafts.get(path);
-        const to = moveTarget(parts.move);
-        if (record === undefined || consumed.has(path) || arrivingDrafts.has(to)) {
-            return [];
-        }
-        const moved = {
-            ...record,
-            locator: destination,
-            path: to,
-            revision: roomDraftRevision(),
-        };
-        return [{ from: path, record: moved }];
-    });
-    const carried = carrying.map(({ record }) => record);
-    const marked = carried.map(({ path }) => ({ path, parts: {} }));
-    const left = [...consumed, ...carrying.map(({ from }) => from)];
-    const leavingQueue = [...replica.queue, built.leaving];
-    const arrivingQueue = [...target.queue, built.arriving];
-    const answer = await saveCommit(store, local, files, [
-        {
-            locator,
-            saving: sourceSaving,
-            before: replica,
-            queue: leavingQueue,
-            write: {
-                locator,
-                queue: leavingQueue,
-                stored: replica.queue,
-                saved: new Map([[id, saved]]),
-                consumedRoomDrafts: left,
-            },
-        },
-        {
-            locator: destination,
-            saving: arriving,
-            before: target,
-            queue: arrivingQueue,
-            write: {
-                locator: destination,
-                queue: arrivingQueue,
-                stored: target.queue,
-                saved: new Map([[id, marked]]),
-                roomDrafts: carried,
-            },
-        },
-    ]);
-    if (answer === null)
-        return { outcome: 'refused', code: 'durable-write', retryable: true };
-    if (answer.fenced !== null) {
-        throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
-    }
-    if (store.fences.has(locator) || store.fences.has(destination)) {
-        throw runtimeError('unknown-room', `Unknown Room ${locator}`);
-    }
-    preparedAfter(runtime, locator, answer);
-    preparedAfter(runtime, destination, answer);
-    const shownNow = store.changed(mergeChangeSets([
-        changeSet(locator, {
-            documents: answer.changed[locator] ?? [],
-            queue: true,
-            drafts: left,
-        }),
-        changeSet(destination, {
-            documents: answer.changed[destination] ?? [],
-            queue: true,
-            drafts: carried.map(({ path }) => path),
-        }),
-    ]));
-    await Promise.all([shownNow, queuedSave(runtime, locator)]);
-    return { outcome: 'saved', identifier: id };
-}
-function queuedSave(runtime, locator) {
-    const shownNow = pendingShown(runtime);
-    runtime.submitLater(locator);
-    return shownNow;
-}
-async function committed(runtime, locator, target, saved, consumed, writtenBy, files = []) {
-    const { store, localSaves } = runtime;
-    if (store.space.full())
-        return { outcome: 'refused', code: 'durable-write', retryable: true };
-    const into = movedInto(locator, saved);
-    if (into !== null) {
-        return committedMove(runtime, locator, into, target, saved, consumed, writtenBy, files);
-    }
-    const { local, replica } = target;
-    const { providerLimits } = await local.facts();
-    const parts = saved.map(({ path, parts: held }) => changesOf(path, held));
-    const changes = parts.flatMap(({ changes: made }) => made);
-    const saving = await savingIn(store, replica, changes, [
-        ...saved.map(({ path }) => path),
-        ...parts.flatMap(({ bases }) => bases.map(({ path }) => path)),
-    ]);
-    const changed = saved.flatMap(({ path, parts: held }) => changedParts(path, held, saving.visible));
-    if (changed.length > 0)
-        return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
-    const requeue = await stepped(requeuing(replica.queue, changes, saving.visible, withdrawable(replica.states), saving.visibleOver));
-    if (requeue.kind === 'refused')
-        return { outcome: 'refused', ...requeue.refusal };
-    const foreign = [...requeue.withdrawn.keys()].some((origin) => {
-        const writer = replica.queue.find((batch) => batch.id === origin)?.writtenBy;
-        return writer?.app !== writtenBy?.app || writer?.release !== writtenBy?.release;
-    });
-    if (foreign) {
-        return {
-            outcome: 'refused',
-            code: 'unknown-revision',
-            retryable: false,
-            file: [...requeue.queued].at(-1),
-        };
-    }
-    const withdrawing = requeue.withdrawn.size > 0;
-    const input = {
-        local: localSaves,
-        baseRoomVersion: replica.record.roomVersion,
-        composition: compositionFor(runtime, replica.record),
-        operations: replica.record.operations,
-        providerOwnedPaths: replica.record.providerOwnedPaths,
-        authoredPaths: replica.record.authoredPaths,
-        providerLimits,
-        pathRule: runtime.pathRule,
-        handle: replica.record.handle,
-        visible: saving.visible,
-        folders: saving.folders,
-        changes,
-        bases: parts.flatMap(({ bases }) => bases),
-        queued: queuedDocuments(replica.queue),
-        writtenBy,
-        unmodeled: await unmodeledIn(runtime, replica.record),
-        validate: validatorOf(runtime, replica.record, saving.confirmed),
-    };
-    const checked = withdrawing
-        ? await buildBatch({ ...input, queued: new Set([...input.queued, ...requeue.queued]) })
-        : null;
-    if (checked?.kind === 'refused')
-        return { outcome: 'refused', ...checked.refusal };
-    const owners = [...requeue.owners].flatMap((origin) => {
-        const batch = requeue.withdrawn.get(origin);
-        return batch === undefined || batch === null ? [] : [{ origin, batch }];
-    });
-    if (owners.length > 1) {
-        return {
-            outcome: 'refused',
-            code: 'unknown-revision',
-            retryable: false,
-            file: [...requeue.queued].at(-1),
-        };
-    }
-    const built = !withdrawing
-        ? await buildBatch(input)
-        : requeue.changes.length === 0
-            ? null
-            : await buildBatch({
-                ...input,
-                visible: await stepped(saving.visibleOver(requeue.queue)),
-                changes: requeue.changes,
-                queued: queuedDocuments(requeue.queue),
-            });
-    if (built?.kind === 'refused')
-        return { outcome: 'refused', ...built.refusal };
-    const [owner] = owners;
-    const join = built === null || owner === undefined ? null : joined(requeue.queue, owner.batch, built.batch);
-    if (join?.kind === 'refused')
-        return { outcome: 'refused', ...join.refusal };
-    const withdrawn = new Map(requeue.withdrawn);
-    if (join !== null && owner !== undefined)
-        withdrawn.set(owner.origin, join.batch);
-    const drafted = new Map();
-    for (const [origin, replaced] of withdrawn) {
-        if (replaced === null)
-            continue;
-        const carried = withdrawnDrafts(replica.states.get(origin)?.drafts ?? [], changes);
-        drafted.set(replaced.id, replaced === join?.batch
-            ? [
-                ...carried.map((held) => joinedDraft(held, saved)),
-                ...saved.filter((draft) => !carried.some((held) => held.path === draft.path)),
-            ]
-            : carried);
-    }
-    if (built !== null && join === null)
-        drafted.set(built.batch.id, saved);
-    const batches = join !== null ? join.queue : built === null ? requeue.queue : [...requeue.queue, built.batch];
-    for (const replaced of withdrawn.values()) {
-        if (replaced === null || !batches.includes(replaced))
-            continue;
-        const limited = await stepped(limiting(batches, replaced, providerLimits, saving.visibleOver));
-        if (limited !== null)
-            return { outcome: 'refused', ...limited };
-    }
-    const carried = await carriedDrafts(store, locator, saved, consumed);
-    const left = [...consumed, ...carried.keys()];
-    const arrived = [...carried.values()];
-    const answer = await saveCommit(store, local, files, [
-        {
-            locator,
-            saving,
-            before: replica,
-            queue: batches,
-            write: {
-                locator,
-                queue: batches,
-                stored: replica.queue,
-                saved: drafted,
-                consumedRoomDrafts: left,
-                roomDrafts: arrived,
-            },
-        },
-    ]);
-    if (answer === null)
-        return { outcome: 'refused', code: 'durable-write', retryable: true };
-    if (answer.fenced !== null) {
-        throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
-    }
-    if (store.fences.has(locator))
-        throw runtimeError('unknown-room', `Unknown Room ${locator}`);
-    preparedAfter(runtime, locator, answer);
-    const shownNow = store.changed(changeSet(locator, {
-        documents: answer.changed[locator] ?? [],
-        queue: true,
-        drafts: [...left, ...arrived.map(({ path }) => path)],
-    }));
-    await Promise.all([shownNow, queuedSave(runtime, locator)]);
-    const identifier = join?.batch.id ??
-        built?.batch.id ??
-        [...requeue.withdrawn].map(([origin, replaced]) => replaced?.id ?? origin).at(-1);
-    return { outcome: 'saved', identifier };
-}
 async function queuedFacts(store, locator, path, localId) {
     for (const batch of (await store.replica(locator))?.queue ?? []) {
         const change = batch.changes[queuedFile(batch, path, localId)];
@@ -822,7 +230,7 @@ export function batchFile(store, batch) {
     };
 }
 async function transferBinary(runtime, request, transfer, answer) {
-    const { store, socket, journal } = runtime;
+    const { store, socket, presence, journal } = runtime;
     const { session } = socket;
     if (socket.closed() || session.now().refusal !== null)
         return UNCERTAIN;
@@ -838,18 +246,18 @@ async function transferBinary(runtime, request, transfer, answer) {
     const { closed, authorization, refusal } = session.now();
     if (closed || authorization === undefined || refusal !== null)
         return UNCERTAIN;
-    const since = store.fences.count();
+    const since = presence.losses();
     journal.record(`transfer binary ${request.locator} ${request.path}`);
     try {
         const result = await transfer(authorization);
         const settled = result;
         journal.record(`outcome binary ${settled.kind}`);
-        if (store.fences.since(request.locator, since))
+        if (presence.lostSince(request.locator, since))
             return failure({ kind: 'room-not-readable', locator: request.locator });
         if (settled.kind === 'scoped-refusal') {
             const room = await store.record(settled.locator);
             if (room !== undefined)
-                await runtime.scoped(settled, room, await store.open());
+                await scoped(runtime, settled, room.locator, room.declaration);
         }
         if (settled.kind === 'revoked-authorization')
             await refuse(runtime, 'revoked-authorization');