@agentshouse/mdruntime 0.1.0-ca7c26c6bc27e → 0.1.0-ca92b54804c33

package/dist/readiness.d.ts

@@ -0,0 +1,50 @@
+import type { Open } from './open.js';
+export type CodeAvailability = Open<'stored' | 'absent'>;
+export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'unadmitted'>;
+export type RoomCoverage = {
+    readonly room: string;
+    readonly state: RoomPreparation;
+};
+export type ConversationCoverage = Open<'complete' | 'acquiring' | 'undeclared'>;
+export type TargetCoverage = {
+    readonly complete: boolean;
+    readonly listed: boolean;
+    readonly rooms: readonly RoomCoverage[];
+    readonly conversations: ConversationCoverage;
+};
+export type Persistence = Open<'granted' | 'denied' | 'unavailable'>;
+export type Durability = Open<'persistent' | 'best-effort'>;
+export type ConnectionAvailability = Open<'connected' | 'connecting' | 'unreachable'>;
+export type HouseOutcome = Open<'open' | 'write-halted' | 'refused'>;
+export type Space = Open<'full'>;
+export type InstallationStep = Open<'downloading' | 'writing' | 'replaying'>;
+export type InstallationAmount = {
+    readonly done: number;
+    readonly total: number;
+};
+export type Installation = {
+    readonly step: InstallationStep | null;
+    readonly rooms: InstallationAmount;
+    readonly bytes: InstallationAmount;
+};
+export type ReadinessStatus = Open<'preparing' | 'paused' | 'ready' | 'lost'>;
+export type Readiness = {
+    readonly status: ReadinessStatus;
+    readonly ready: boolean;
+    readonly usable: boolean;
+    readonly code: CodeAvailability;
+    readonly coverage: TargetCoverage;
+    readonly durability: Durability;
+    readonly persistence: Persistence;
+    readonly connection: ConnectionAvailability;
+    readonly house: HouseOutcome;
+    readonly space: Space | null;
+    readonly installation: Installation;
+    readonly lost: boolean;
+};
+export type ReadinessFacts = Omit<Readiness, 'status' | 'ready' | 'usable' | 'durability' | 'coverage'> & {
+    readonly coverage: Omit<TargetCoverage, 'complete'>;
+    readonly established: boolean;
+};
+export declare function readinessOf(facts: ReadinessFacts): Readiness;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../src/readiness.ts"],"names":[],"mappings":"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"}

package/dist/readiness.js

@@ -0,0 +1,27 @@
+const COMPLETE_ROOMS = new Set(['complete', 'unadmitted']);
+export function readinessOf(facts) {
+    const { established, coverage: held, ...reported } = facts;
+    const settledConversations = held.conversations === 'complete' || held.conversations === 'undeclared';
+    const complete = held.listed &&
+        settledConversations &&
+        held.rooms.every((room) => COMPLETE_ROOMS.has(room.state));
+    const coverage = { ...held, complete };
+    const stored = facts.code === 'stored';
+    const ready = stored && complete;
+    const usable = stored && (ready || established);
+    const status = ready
+        ? 'ready'
+        : facts.space !== null
+            ? 'paused'
+            : facts.lost && !established
+                ? 'lost'
+                : 'preparing';
+    return {
+        ...reported,
+        coverage,
+        status,
+        ready,
+        usable,
+        durability: facts.persistence === 'granted' ? 'persistent' : 'best-effort',
+    };
+}

package/dist/recovery.d.ts

@@ -0,0 +1,26 @@
+export type Attempted = 'done' | 'again' | {
+    readonly at: number;
+};
+export type Attempt = (signal: AbortSignal) => Promise<Attempted>;
+export type AttemptOptions = {
+    readonly at?: number;
+    readonly again?: boolean;
+};
+export type RecoveryOptions = {
+    readonly firstMs?: number;
+    readonly maxMs?: number;
+    readonly attempts?: number;
+    readonly inFlight?: number;
+};
+export type Recovery = {
+    attempt(intent: string, run: Attempt, options?: AttemptOptions): Promise<boolean>;
+    pending(intent: string): boolean;
+    resume(): void;
+    cancel(intent: string): void;
+    scope(inFlight?: number): Recovery;
+    retire(): Promise<void>;
+};
+export declare function retryDelay(tries: number, firstMs?: number, maxMs?: number): number;
+export declare function untilAnswered<T>(ask: () => Promise<T>, signal: AbortSignal, answered?: (answer: T) => boolean): Promise<T>;
+export declare function createRecovery(options?: RecoveryOptions): Recovery;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClF,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,MAAM,IAAI,IAAI,CAAC;IACf,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACnC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAsBF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAW,EAAE,KAAK,SAAS,GAAG,MAAM,CAGpF;AAED,wBAAsB,aAAa,CAAC,CAAC,EACnC,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,WAAW,EACnB,QAAQ,GAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAoB,GAC5C,OAAO,CAAC,CAAC,CAAC,CAsBZ;AA8KD,wBAAgB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAStE"}

package/dist/recovery.js

@@ -0,0 +1,232 @@
+// A first retry waits about a second, so a passing failure clears before the next attempt.
+const FIRST_MS = 1_000;
+// Waits stop doubling at half a minute, so work resumes soon after a long failure ends.
+const MAX_MS = 30_000;
+const ATTEMPTS = 8;
+export function retryDelay(tries, firstMs = FIRST_MS, maxMs = MAX_MS) {
+    const longest = Math.min(maxMs, firstMs * 2 ** tries);
+    return longest / 2 + (Math.random() * longest) / 2;
+}
+export async function untilAnswered(ask, signal, answered = () => true) {
+    for (let tries = 0;; tries += 1) {
+        try {
+            const answer = await ask();
+            if (answered(answer) || signal.aborted)
+                return answer;
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+        }
+        await new Promise((resume) => {
+            const stop = () => {
+                clearTimeout(again);
+                resume();
+            };
+            // A read that failed is asked again on the doubling backoff, so its asker is answered once the failure clears.
+            const again = setTimeout(() => {
+                signal.removeEventListener('abort', stop);
+                resume();
+            }, retryDelay(tries));
+            signal.addEventListener('abort', stop, { once: true });
+        });
+        signal.throwIfAborted();
+    }
+}
+function owner(backoff, inFlight, release = () => { }) {
+    const intents = new Map();
+    const children = new Set();
+    const running = new Set();
+    const queued = [];
+    let free = inFlight;
+    let retired = false;
+    function finish(key, intent, done) {
+        if (intents.get(key) === intent)
+            intents.delete(key);
+        if (intent.timer !== null)
+            clearTimeout(intent.timer);
+        intent.timer = null;
+        intent.end(done);
+    }
+    function wait(key, intent, at, guided) {
+        if (intent.timer !== null)
+            clearTimeout(intent.timer);
+        intent.due = at;
+        intent.guided = guided;
+        intent.timer = setTimeout(() => {
+            intent.timer = null;
+            launch(key, intent);
+        }, Math.max(0, at - Date.now()));
+    }
+    function launch(key, intent) {
+        intent.due = null;
+        intent.guided = false;
+        const controller = new AbortController();
+        intent.controller = controller;
+        const run = start(key, intent, controller);
+        running.add(run);
+        void run.finally(() => running.delete(run));
+    }
+    async function start(key, intent, controller) {
+        while (free === 0)
+            await new Promise((admit) => queued.push(admit));
+        if (controller.signal.aborted) {
+            queued.shift()?.();
+            return;
+        }
+        free -= 1;
+        const abandoned = new Promise((resolve) => {
+            controller.signal.addEventListener('abort', () => resolve(null), { once: true });
+        });
+        let result;
+        try {
+            result = await Promise.race([intent.run(controller.signal), abandoned]);
+        }
+        catch {
+            result = 'again';
+        }
+        finally {
+            free += 1;
+            queued.shift()?.();
+        }
+        if (result === null || controller.signal.aborted || intents.get(key) !== intent)
+            return;
+        intent.controller = null;
+        const again = intent.again;
+        intent.again = null;
+        if (result === 'done') {
+            intent.tries = 0;
+            if (again === null)
+                finish(key, intent, true);
+            else if (again === 'now')
+                launch(key, intent);
+            else
+                wait(key, intent, again, true);
+            return;
+        }
+        intent.tries += 1;
+        if (intent.tries >= backoff.attempts) {
+            if (again === null) {
+                finish(key, intent, false);
+                return;
+            }
+            intent.tries = 0;
+            if (again === 'now')
+                launch(key, intent);
+            else
+                wait(key, intent, again, true);
+            return;
+        }
+        if (result === 'again') {
+            // The next attempt waits the doubling backoff, up to its maximum.
+            const delay = retryDelay(intent.tries - 1, backoff.firstMs, backoff.maxMs);
+            wait(key, intent, Date.now() + delay, false);
+        }
+        else
+            wait(key, intent, result.at, true);
+    }
+    const recovery = {
+        attempt(key, run, options = {}) {
+            if (retired)
+                return Promise.resolve(false);
+            const held = intents.get(key);
+            if (held !== undefined) {
+                held.run = run;
+                if (held.controller !== null) {
+                    const at = options.at;
+                    held.again =
+                        at === undefined || held.again === 'now'
+                            ? 'now'
+                            : Math.min(at, held.again ?? Number.POSITIVE_INFINITY);
+                }
+                else if (held.due !== null && held.due <= Date.now()) {
+                    if (held.timer !== null)
+                        clearTimeout(held.timer);
+                    held.timer = null;
+                    launch(key, held);
+                }
+                else if (options.at !== undefined && (held.due === null || options.at < held.due)) {
+                    wait(key, held, options.at, true);
+                }
+                return held.ended;
+            }
+            let end = () => { };
+            const ended = new Promise((resolve) => {
+                end = resolve;
+            });
+            const intent = {
+                run,
+                tries: 0,
+                timer: null,
+                due: null,
+                guided: false,
+                controller: null,
+                again: null,
+                ended,
+                end,
+            };
+            intents.set(key, intent);
+            if (options.at !== undefined)
+                wait(key, intent, options.at, true);
+            else if (options.again === true) {
+                intent.tries = 1;
+                wait(key, intent, Date.now() + retryDelay(0, backoff.firstMs, backoff.maxMs), false);
+            }
+            else
+                launch(key, intent);
+            return ended;
+        },
+        pending(key) {
+            const intent = intents.get(key);
+            return intent !== undefined && intent.controller === null;
+        },
+        resume() {
+            if (retired)
+                return;
+            for (const [key, intent] of [...intents]) {
+                if (intent.guided && intent.due !== null && intent.due > Date.now())
+                    continue;
+                if (intent.timer !== null)
+                    clearTimeout(intent.timer);
+                intent.timer = null;
+                intent.controller?.abort();
+                intent.again = null;
+                intent.tries = 0;
+                launch(key, intent);
+            }
+        },
+        cancel(key) {
+            const intent = intents.get(key);
+            if (intent === undefined)
+                return;
+            intent.controller?.abort();
+            finish(key, intent, false);
+        },
+        scope(bound = Infinity) {
+            const child = owner(backoff, bound, () => children.delete(child));
+            if (retired)
+                void child.retire();
+            else
+                children.add(child);
+            return child;
+        },
+        async retire() {
+            retired = true;
+            release();
+            for (const [key, intent] of [...intents]) {
+                intent.controller?.abort();
+                finish(key, intent, false);
+            }
+            await Promise.all([...children].map((child) => child.retire()));
+            await Promise.all(running);
+        },
+    };
+    return recovery;
+}
+export function createRecovery(options = {}) {
+    return owner({
+        firstMs: options.firstMs ?? FIRST_MS,
+        maxMs: options.maxMs ?? MAX_MS,
+        attempts: options.attempts ?? ATTEMPTS,
+    }, options.inFlight ?? Infinity);
+}

package/dist/refresh.d.ts

@@ -1,14 +1,27 @@
-import type { Adapter, AdapterFailure, Authorization, RetryableRefusal } from './adapter.js';
+import type { AdapterFailure, Authorization, RefreshPage, RefreshRequest, RefreshResult, RetryableRefusal } from './adapter.js';
 import type { Remodel } from './bootstrap.js';
-import { type ConfirmedLayer } from './replica.js';
-import { type Refused, type Unconfirmed } from './transfer.js';
-export type RefreshOutcome = {
+import type { ReplicaRecord } from './replica.js';
+import type { RefreshedPage } from './store.js';
+import type { HeldEntry, StoredEntry } from './tables.js';
+import { type Unconfirmed } from './transfer.js';
+export type Advancement = {
     kind: 'still-current';
 } | {
     kind: 'advanced';
-    confirmed: ConfirmedLayer;
+    record: ReplicaRecord;
+    changed: ReadonlySet<string>;
 } | {
     kind: 'beyond-horizon';
-} | RetryableRefusal | Unconfirmed | Refused | AdapterFailure;
-export declare function refreshRoom(adapter: Adapter, authorization: Authorization, confirmed: ConfirmedLayer, remodel: Remodel, continuing: () => boolean): Promise<RefreshOutcome>;
+} | RetryableRefusal | Unconfirmed | AdapterFailure;
+export type Refresher = (authorization: Authorization, request: RefreshRequest) => Promise<RefreshResult>;
+export type Refreshing = {
+    turn(): void;
+    prior(paths: readonly string[]): Promise<ReadonlyMap<string, HeldEntry>>;
+    later(paths: readonly string[], roomVersion: string): Promise<ReadonlySet<string>>;
+    stage(page: RefreshedPage): Promise<boolean>;
+};
+type PageContent = Pick<RefreshPage, 'documents' | 'facts' | 'revisions' | 'fileIds' | 'created' | 'changes' | 'binaryFiles'>;
+export declare function pageEntries(page: PageContent, removals: readonly string[], roomVersion: string, prior: (paths: readonly string[]) => Promise<ReadonlyMap<string, HeldEntry>>): Promise<StoredEntry[]>;
+export declare function advancement(refresh: Refresher, authorization: Authorization, held: ReplicaRecord, remodel: Remodel, continuing: () => boolean, staging: Refreshing): Promise<Advancement>;
+export {};
 //# sourceMappingURL=refresh.d.ts.map

package/dist/refresh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../src/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,aAAa,EAGb,gBAAgB,EAEjB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAe,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5E,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,cAAc,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B,gBAAgB,GAChB,WAAW,GACX,OAAO,GACP,cAAc,CAAC;AAEnB,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,OAAO,GACxB,OAAO,CAAC,cAAc,CAAC,CA8EzB"}
+{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../src/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,WAAW,EACX,cAAc,EACd,aAAa,EACb,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAG9D,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,GACzE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B,gBAAgB,GAChB,WAAW,GACX,cAAc,CAAC;AAEnB,MAAM,MAAM,SAAS,GAAG,CACtB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,cAAc,KACpB,OAAO,CAAC,aAAa,CAAC,CAAC;AAE5B,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACzE,KAAK,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;IACnF,KAAK,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;AASF,KAAK,WAAW,GAAG,IAAI,CACrB,WAAW,EACX,WAAW,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CACxF,CAAC;AAwFF,wBAAsB,WAAW,CAC/B,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,GAC3E,OAAO,CAAC,WAAW,EAAE,CAAC,CAKxB;AAgDD,wBAAsB,WAAW,CAC/B,OAAO,EAAE,SAAS,EAClB,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,OAAO,EACzB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,WAAW,CAAC,CA8CtB"}

package/dist/refresh.js

@@ -1,61 +1,160 @@
-import { declaredAttachments } from './attachment.js';
-import { readStaged } from './replica.js';
 import { unconfirmed } from './transfer.js';
-export async function refreshRoom(adapter, authorization, confirmed, remodel, continuing) {
-    const locator = confirmed.record.locator;
-    const fromRoomVersion = confirmed.record.roomVersion;
-    const first = await adapter.refresh(authorization, {
+import { ROW_WEIGHT, stepped, yielded } from './turn.js';
+function* listing(page, removals) {
+    const removed = new Set();
+    for (const path of removals) {
+        removed.add(path);
+        yield ROW_WEIGHT;
+    }
+    const documents = [];
+    const binaries = [];
+    const asked = [];
+    const written = new Set();
+    for (const [kept, named] of [
+        [documents, page.documents],
+        [binaries, page.binaryFiles],
+    ]) {
+        for (const path of Object.keys(named)) {
+            yield ROW_WEIGHT;
+            if (removed.has(path))
+                continue;
+            kept.push(path);
+            written.add(path);
+            if (page.revisions[path] === undefined)
+                asked.push(path);
+        }
+    }
+    const others = [];
+    const seen = new Set();
+    for (const named of [page.revisions, page.fileIds ?? {}, page.changes]) {
+        for (const path of Object.keys(named)) {
+            yield ROW_WEIGHT;
+            if (seen.has(path))
+                continue;
+            seen.add(path);
+            if (!written.has(path) && !removed.has(path))
+                others.push(path);
+        }
+    }
+    return { documents, binaries, others, asked: [...asked, ...others] };
+}
+function* entering(page, roomVersion, listed, prior) {
+    const entries = [];
+    for (const path of listed.documents) {
+        yield ROW_WEIGHT;
+        entries.push({
+            path,
+            content: page.documents[path],
+            facts: page.facts[path] ?? null,
+            binary: null,
+            revision: page.revisions[path] ?? prior.get(path)?.revision ?? null,
+            fileId: page.fileIds?.[path] ?? null,
+            created: page.created?.[path] ?? null,
+            change: page.changes[path] ?? null,
+            written: roomVersion,
+        });
+    }
+    for (const path of listed.binaries) {
+        yield ROW_WEIGHT;
+        entries.push({
+            path,
+            content: null,
+            facts: null,
+            binary: { state: 'accepted', ...page.binaryFiles[path] },
+            revision: page.revisions[path] ?? prior.get(path)?.revision ?? null,
+            fileId: page.fileIds?.[path] ?? null,
+            created: page.created?.[path] ?? null,
+            change: page.changes[path] ?? null,
+            written: null,
+        });
+    }
+    for (const path of listed.others) {
+        yield ROW_WEIGHT;
+        const held = prior.get(path);
+        if (held === undefined)
+            continue;
+        const { type: _type, ...kept } = held;
+        entries.push({
+            ...kept,
+            revision: page.revisions[path] ?? held.revision,
+            fileId: page.fileIds?.[path] ?? held.fileId,
+            created: page.created?.[path] ?? held.created,
+            change: page.changes[path] ?? held.change,
+        });
+    }
+    return entries;
+}
+export async function pageEntries(page, removals, roomVersion, prior) {
+    await yielded();
+    const listed = await stepped(listing(page, removals));
+    const held = listed.asked.length === 0 ? new Map() : await prior(listed.asked);
+    return stepped(entering(page, roomVersion, listed, held));
+}
+function without(named, kept) {
+    return Object.fromEntries(Object.entries(named).filter(([path]) => !kept.has(path)));
+}
+function unwritten(page, kept) {
+    if (kept.size === 0)
+        return page;
+    return {
+        ...page,
+        documents: without(page.documents, kept),
+        facts: without(page.facts, kept),
+        revisions: without(page.revisions, kept),
+        ...(page.fileIds === undefined ? {} : { fileIds: without(page.fileIds, kept) }),
+        ...(page.created === undefined ? {} : { created: without(page.created, kept) }),
+        changes: without(page.changes, kept),
+        binaryFiles: without(page.binaryFiles, kept),
+        removals: page.removals.filter((path) => !kept.has(path)),
+    };
+}
+async function pageOf(answered, roomVersion, staging) {
+    const page = unwritten(answered, await staging.later([
+        ...Object.keys(answered.documents),
+        ...Object.keys(answered.binaryFiles),
+        ...answered.removals,
+    ], roomVersion));
+    return {
+        entries: await pageEntries(page, page.removals, roomVersion, (paths) => staging.prior(paths)),
+        removals: page.removals,
+        folders: page.folders ?? [],
+        folderRemovals: page.folderRemovals ?? [],
+    };
+}
+export async function advancement(refresh, authorization, held, remodel, continuing, staging) {
+    const locator = held.locator;
+    const fromRoomVersion = held.roomVersion;
+    staging.turn();
+    if (!continuing())
+        return unconfirmed;
+    const first = await refresh(authorization, {
         locator,
-        selection: confirmed.record.replica.selection,
+        selection: held.replica.selection,
         fromRoomVersion,
     });
     if (first.kind !== 'net-advancement')
         return first;
     const roomVersion = first.roomVersion;
-    const models = remodel(first.models, {
-        collection: confirmed.record.model,
-        selection: confirmed.record.selectionModel,
-    });
-    const documents = { ...confirmed.record.documents };
-    const revisions = { ...confirmed.record.revisions };
-    const changes = { ...confirmed.record.changes };
-    const written = { ...confirmed.record.written };
-    const binaryTargets = new Set(confirmed.record.binaryTargets);
-    const attachments = [];
-    const stage = (page) => {
-        if (page.attachments !== undefined)
-            attachments.push(page.attachments);
-        Object.assign(documents, page.documents);
-        Object.assign(revisions, page.revisions);
-        for (const path of Object.keys(page.documents)) {
-            binaryTargets.delete(path);
-            delete changes[path];
-            written[path] = roomVersion;
-        }
-        for (const target of page.binaryTargets) {
-            delete documents[target];
-            delete revisions[target];
-            delete changes[target];
-            delete written[target];
-            binaryTargets.add(target);
-        }
-        Object.assign(changes, page.changes);
-        for (const path of page.removals) {
-            delete documents[path];
-            delete revisions[path];
-            delete changes[path];
-            delete written[path];
-            binaryTargets.delete(path);
-        }
+    const models = remodel(first.models, { collection: held.model });
+    const changed = new Set();
+    const staged = async (page) => {
+        const read = await pageOf(page, roomVersion, staging);
+        for (const { path } of read.entries)
+            changed.add(path);
+        for (const path of read.removals)
+            changed.add(path);
+        return staging.stage(read);
     };
-    stage(first);
+    if (!(await staged(first)))
+        return unconfirmed;
     let pageToken = first.pageToken;
     while (pageToken !== undefined) {
+        await staging.turn();
         if (!continuing())
             return unconfirmed;
-        const page = await adapter.refresh(authorization, {
+        const page = await refresh(authorization, {
             locator,
-            selection: confirmed.record.replica.selection,
+            selection: held.replica.selection,
             fromRoomVersion,
             pageToken,
         });
@@ -65,20 +164,17 @@ export async function refreshRoom(adapter, authorization, confirmed, remodel, co
             return page;
         if (page.roomVersion !== roomVersion)
             return unconfirmed;
-        stage(page);
+        if (!(await staged(page)))
+            return unconfirmed;
         pageToken = page.pageToken;
     }
-    const staged = readStaged({
-        ...confirmed.record,
-        model: models.collection,
-        selectionModel: models.selection,
-        roomVersion,
-        documents,
-        binaryTargets: [...binaryTargets].sort(),
-        revisions,
-        changes,
-        written,
-        attachments: attachments.length === 0 ? confirmed.record.attachments : declaredAttachments(attachments),
-    }, confirmed);
-    return staged.kind === 'staged' ? { kind: 'advanced', confirmed: staged.confirmed } : staged;
+    return {
+        kind: 'advanced',
+        record: {
+            ...held,
+            model: models.collection,
+            roomVersion,
+        },
+        changed,
+    };
 }