@agentshouse/mdruntime 0.1.0-c1db74d14e5fa → 0.1.0-c1f932245d3d9

package/dist/attached-model.js

@@ -1,47 +1,46 @@
-import { verify } from '@agentshouse/mdmodel';
+import { readTypes } from '@agentshouse/mdmodel';
 import { MD_MODEL } from './collection.js';
-import { sameModel } from './model.js';
-const EMPTY_SCHEMA = { verdict: 'accept', model: { types: {} } };
-export function attachedModel(answer, previous) {
-    if (answer.kind === 'model-unavailable') {
-        return { state: { status: 'unavailable', reason: answer.reason }, refused: null };
-    }
-    if (previous.status !== 'unavailable' &&
-        sameModel(previous.snapshot, answer.snapshot) &&
-        previous.snapshot.schema !== answer.snapshot.schema) {
-        return {
-            state: {
-                status: 'unavailable',
-                reason: 'invalid',
-                schema: answer.snapshot.schema,
-                revision: answer.snapshot.revision,
-            },
-            refused: null,
-        };
+export const NO_ROOM_TYPES = Object.freeze({ types: Object.freeze({}) });
+export function roomTypesOf(schema, nameable = []) {
+    if (schema === undefined)
+        return NO_ROOM_TYPES;
+    return Object.freeze({ ...readTypes(schema), nameable });
+}
+const BUILT_IN = {
+    kind: 'model',
+    snapshot: { identity: 'built-in', version: '', schema: null, revision: null },
+};
+export function builtInModel(roomTypes) {
+    return attachedModel(BUILT_IN, roomTypes);
+}
+const READ_SCHEMAS = 64;
+const read = new WeakMap();
+function typesRead(schema, roomTypes) {
+    let held = read.get(roomTypes);
+    if (held === undefined) {
+        held = new Map();
+        read.set(roomTypes, held);
     }
-    const verified = answer.snapshot.schema === null ? EMPTY_SCHEMA : verify(answer.snapshot.schema);
-    if (verified.verdict === 'refuse') {
-        return {
-            state: {
-                status: 'unavailable',
-                reason: 'invalid',
-                schema: answer.snapshot.schema,
-                revision: answer.snapshot.revision,
-            },
-            refused: {
-                identity: answer.snapshot.identity,
-                rule: verified.rule,
-                ...(verified.location === undefined ? {} : { location: verified.location }),
-            },
-        };
+    const known = held.get(schema);
+    if (known !== undefined)
+        return known;
+    const types = readTypes(schema, roomTypes);
+    if (held.size >= READ_SCHEMAS)
+        held.delete(held.keys().next().value);
+    held.set(schema, types);
+    return types;
+}
+export function schemaTypes(schema, roomTypes) {
+    return (schema === null ? roomTypes : typesRead(schema, roomTypes)).types;
+}
+export function attachedModel(answer, roomTypes) {
+    if (answer.kind === 'model-unavailable') {
+        return { status: 'unavailable', reason: answer.reason };
     }
     return {
-        state: {
-            status: 'current',
-            snapshot: structuredClone(answer.snapshot),
-            verifiedWith: MD_MODEL,
-            types: verified.model.types,
-        },
-        refused: null,
+        status: 'current',
+        snapshot: structuredClone(answer.snapshot),
+        verifiedWith: MD_MODEL,
+        types: schemaTypes(answer.snapshot.schema, roomTypes),
     };
 }

package/dist/binary.d.ts

@@ -3,7 +3,6 @@ export type BinaryFileRecord = {
     readonly state: 'accepted';
     readonly revision: string;
     readonly path: string;
-    readonly fileRef: string;
     readonly byteLength: number;
     readonly mediaType: string;
     readonly sha256: string;
@@ -15,9 +14,5 @@ export type BinaryFileRecord = {
     readonly mediaType: string;
     readonly sha256: string;
 };
-export type BinaryReference = {
-    readonly fileRef: string;
-    readonly referrer: unknown;
-};
 export declare function binaryRecord(path: string, held: HeldBinary, revision: string | undefined): BinaryFileRecord;
 //# sourceMappingURL=binary.d.ts.map

package/dist/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,gBAAgB,GACxB;IACE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IACE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEN,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAEvF,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,gBAAgB,CAKlB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,gBAAgB,GACxB;IACE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IACE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEN,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,gBAAgB,CAKlB"}

package/dist/binary.js

@@ -4,5 +4,5 @@ export function binaryRecord(path, held, revision) {
         return { state: 'pending', localId: held.localId, path, ...facts };
     if (revision === undefined)
         throw new Error(`the accepted binary file ${path} has no revision`);
-    return { state: 'accepted', revision, path, fileRef: held.fileRef, ...facts };
+    return { state: 'accepted', revision, path, ...facts };
 }

package/dist/bootstrap.d.ts

@@ -1,24 +1,44 @@
 import type { ModelState } from './model.js';
-import type { Adapter, AdapterFailure, Authorization, DiscoveredRoom, HeldContent, RetryableRefusal, RoomModels } from './adapter.js';
-import { type ConfirmedLayer } from './replica.js';
-import type { StagedLayer, TransferRecord } from './store.js';
-import { type Refused, type Unconfirmed } from './transfer.js';
+import type { Adapter, TypedPath, AdapterFailure, Authorization, BootstrapPart, DiscoveredRoom, NotReady, RetryableRefusal, RoomModels } from './adapter.js';
+import type { Composition } from './collection.js';
+import type { InstallationStep } from './readiness.js';
+import { type Refreshing } from './refresh.js';
+import type { ReplicaRecord } from './replica.js';
+import type { StagedPage, TransferRecord } from './store.js';
+import { type Unconfirmed } from './transfer.js';
 export type Bootstrapped = {
     kind: 'staged';
-    confirmed: ConfirmedLayer;
-    stored: StagedLayer;
+    record: ReplicaRecord;
+    refreshed: boolean;
 };
-export type BootstrapOutcome = Bootstrapped | Refused | Unconfirmed | RetryableRefusal | AdapterFailure;
+export type BootstrapOutcome = Bootstrapped | Unconfirmed | NotReady | RetryableRefusal | AdapterFailure;
 export type HeldModels = {
     collection: ModelState;
-    selection: ModelState;
 };
 export type Remodel = (models: RoomModels | undefined, held: HeldModels) => HeldModels;
+export type Reads = Pick<Adapter, 'bootstrap' | 'refresh' | 'reached'>;
+export type Arriving = {
+    at(bytes: number): void;
+    end(): void;
+};
+export type Resumed = {
+    readonly record: TransferRecord | null;
+    readonly staged: ReadonlySet<string>;
+};
 export type Staging = {
     held(locator: string): TransferRecord | null;
-    staged(record: TransferRecord): Promise<StagedLayer>;
-    stage(record: TransferRecord, page: StagedLayer): Promise<boolean>;
+    turn(locator: string, step: InstallationStep): Promise<() => void>;
+    unqueued(): Promise<void>;
+    queued(text: number): () => void;
+    arriving(locator: string): Arriving;
+    readonly streamed: boolean;
+    stage(record: TransferRecord, page: StagedPage, composition: Composition): Promise<TransferRecord | null>;
+    resume(record: TransferRecord, parts: readonly BootstrapPart[], composition: Composition): Promise<Resumed | null>;
+    derive(locator: string, key: number, composition: Composition): Promise<boolean>;
+    refreshing(locator: string, key: number, composition: Composition): Promise<Refreshing>;
     abandon(locator: string): Promise<void>;
+    setAside(locator: string): Promise<void>;
+    release(key: number): Promise<void>;
 };
-export declare function bootstrapRoom(adapter: Adapter, authorization: Authorization, room: DiscoveredRoom, held: HeldModels, remodel: Remodel, continuing: () => boolean, staging: Staging, reuse: HeldContent | null): Promise<BootstrapOutcome>;
+export declare function bootstrapRoom(adapter: Reads, authorization: Authorization, room: DiscoveredRoom, held: HeldModels, builtIn: ModelState, typedPaths: readonly TypedPath[], remodel: Remodel, continuing: () => boolean, staging: Staging): Promise<BootstrapOutcome>;
 //# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,aAAa,EAEb,cAAc,EAEd,WAAW,EACX,gBAAgB,EAChB,UAAU,EACX,MAAM,cAAc,CAAC;AAItB,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAiB,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAe,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5E,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC;AAE9F,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ,OAAO,GACP,WAAW,GACX,gBAAgB,GAChB,cAAc,CAAC;AAEnB,MAAM,MAAM,UAAU,GAAG;IAAE,UAAU,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,UAAU,CAAA;CAAE,CAAC;AAE3E,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;AAEvF,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC;IAC7C,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACrD,KAAK,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC,CAAC;AAyCF,wBAAsB,aAAa,CACjC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,OAAO,EACzB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,WAAW,GAAG,IAAI,GACxB,OAAO,CAAC,gBAAgB,CAAC,CA4B3B"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"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"}

package/dist/bootstrap.js

@@ -1,129 +1,341 @@
 import { transferIdentity } from './identity.js';
-import { advancement } from './refresh.js';
-import { acceptedBinaries } from './overlay.js';
-import { readStaged } from './replica.js';
+import { advancement, pageEntries } from './refresh.js';
+import { entriesIn } from './shared.js';
 import { unconfirmed } from './transfer.js';
-const RESUMABLE = new Set([
-    'transport-uncertainty',
-    'retryable-refusal',
-    'unconfirmed',
-]);
-function pageLayer(page) {
+const NOTHING_PRIOR = () => Promise.resolve(new Map());
+const PARTS_IN_FLIGHT = 6;
+function textOf(page) {
+    let text = 0;
+    for (const [, content] of entriesIn(page.documents))
+        text += content.length;
+    return text;
+}
+async function pageOf(page, part) {
     return {
-        documents: page.documents,
-        revisions: page.revisions,
-        changes: page.changes,
-        written: Object.fromEntries(Object.keys(page.documents).map((path) => [path, page.roomVersion])),
-        binaries: acceptedBinaries(page.binaryFiles),
+        entries: await pageEntries(page, [], page.roomVersion, NOTHING_PRIOR),
+        folders: page.folders ?? [],
+        ...(part === undefined ? {} : { part }),
     };
 }
-async function heldTransfer(staging, room) {
-    const record = staging.held(room.locator);
-    if (record === null)
-        return null;
-    if (record.selection === room.replica.selection) {
-        return { record, layer: await staging.staged(record) };
+export async function bootstrapRoom(adapter, authorization, room, held, builtIn, typedPaths, remodel, continuing, staging) {
+    if (staging.held(room.locator) !== null)
+        await staging.abandon(room.locator);
+    const begun = () => started(adapter, authorization, room, held, builtIn, typedPaths, remodel, continuing, staging);
+    const first = await begun();
+    if (first.kind !== 'expired')
+        return first;
+    await staging.setAside(room.locator);
+    try {
+        const replacement = await begun();
+        if (replacement.kind !== 'expired')
+            return replacement;
+        await staging.abandon(room.locator);
+        return unconfirmed;
     }
-    await staging.abandon(room.locator);
-    return null;
+    finally {
+        if (first.key !== null)
+            await staging.release(first.key);
+    }
+}
+function dropped(ahead) {
+    void ahead?.fetched.then(({ next, written }) => {
+        written();
+        dropped(next);
+    }, () => { });
 }
-function pooled(pool, layer) {
+function compositionFor(room, models, builtIn, typedPaths) {
     return {
-        documents: { ...pool?.documents, ...layer.documents },
-        revisions: { ...pool?.revisions, ...layer.revisions },
+        model: models.collection,
+        selection: room.typedSelection === undefined
+            ? null
+            : { roots: room.typedSelection.roots, model: builtIn },
+        typedPaths,
     };
 }
-export async function bootstrapRoom(adapter, authorization, room, held, remodel, continuing, staging, reuse) {
-    const first = await bundle(adapter, authorization, room, held, remodel, continuing, staging, await heldTransfer(staging, room), reuse);
-    if (first.kind !== 'expired')
-        return first;
-    await staging.abandon(room.locator);
-    const replacement = await bundle(adapter, authorization, room, held, remodel, continuing, staging, null, pooled(reuse, first.held));
-    if (replacement.kind !== 'expired')
-        return replacement;
-    await staging.abandon(room.locator);
-    return unconfirmed;
+async function started(adapter, authorization, room, held, builtIn, typedPaths, remodel, continuing, staging) {
+    const mode = { paged: false };
+    let outcome;
+    try {
+        outcome = await bundle(adapter, authorization, room, held, builtIn, typedPaths, remodel, continuing, staging, mode);
+    }
+    catch (error) {
+        await stopped(staging, room.locator, mode).catch(() => { });
+        throw error;
+    }
+    if (outcome.kind !== 'staged' && outcome.kind !== 'expired') {
+        await stopped(staging, room.locator, mode);
+    }
+    return outcome;
 }
-async function bundle(adapter, authorization, room, held, remodel, continuing, staging, kept, pool) {
+function stopped(staging, locator, mode) {
+    return mode.paged ? staging.abandon(locator) : staging.setAside(locator);
+}
+async function bundle(adapter, authorization, room, held, builtIn, typedPaths, remodel, continuing, staging, mode) {
     const locator = room.locator;
     const selection = room.replica.selection;
-    const documents = { ...kept?.layer.documents };
-    const revisions = { ...kept?.layer.revisions };
-    const changes = { ...kept?.layer.changes };
-    const written = { ...kept?.layer.written };
-    const binaries = { ...kept?.layer.binaries };
-    let transfer = kept?.record ?? null;
-    while (transfer === null || transfer.pageToken !== null) {
-        if (!continuing())
-            return unconfirmed;
-        const page = await adapter.bootstrap(authorization, {
+    const ending = new AbortController();
+    const arriving = staging.arriving(locator);
+    const downloaded = await staging.turn(locator, 'downloading');
+    const asking = (token) => adapter.bootstrap(authorization, {
+        locator,
+        selection,
+        signal: ending.signal,
+        ...(token === null
+            ? { arriving: (bytes) => arriving.at(bytes) }
+            : { pageToken: token }),
+    });
+    const fetching = (token) => {
+        const fetched = (async () => {
+            await staging.unqueued();
+            const page = continuing() ? await asking(token) : unconfirmed;
+            if (page.kind !== 'bootstrap')
+                return { page, next: null, written: () => { } };
+            const written = staging.queued(textOf(page));
+            const later = page.pageToken;
+            if (later === undefined && page.parts === undefined) {
+                downloaded();
+                arriving.end();
+            }
+            return { page, written, next: later === undefined || !continuing() ? null : fetching(later) };
+        })();
+        fetched.catch(() => { });
+        return { fetched };
+    };
+    let transfer = null;
+    let ahead = fetching(null);
+    try {
+        while (ahead !== null) {
+            if (!continuing())
+                return unconfirmed;
+            const fetched = await ahead.fetched;
+            ahead = fetched.next;
+            try {
+                if (!continuing())
+                    return unconfirmed;
+                const page = fetched.page;
+                if (page.kind === 'beyond-horizon')
+                    return { kind: 'expired', key: transfer?.key ?? null };
+                if (page.kind !== 'bootstrap')
+                    return page;
+                if (transfer === null && page.parts !== undefined) {
+                    const parted = await parts(page, page.parts);
+                    if (parted.kind !== 'parted')
+                        return parted;
+                    transfer = parted.transfer;
+                    continue;
+                }
+                if (transfer === null)
+                    mode.paged = true;
+                const models = remodel(page.models, transfer?.models ?? held);
+                const staged = await staging.stage({
+                    locator,
+                    transfer: transfer?.transfer ?? transferIdentity(),
+                    selection,
+                    from: transfer !== null && adapter.reached(locator, page.roomVersion, transfer.from)
+                        ? transfer.from
+                        : page.roomVersion,
+                    last: transfer !== null && !adapter.reached(locator, page.roomVersion, transfer.last)
+                        ? transfer.last
+                        : page.roomVersion,
+                    done: { bytes: (transfer?.done.bytes ?? 0) + (page.bytes ?? 0) },
+                    models,
+                    key: transfer?.key ?? null,
+                }, await pageOf(page), compositionFor(room, models, builtIn, typedPaths));
+                if (staged === null)
+                    return unconfirmed;
+                transfer = staged;
+            }
+            finally {
+                fetched.written();
+            }
+        }
+    }
+    finally {
+        ending.abort();
+        downloaded();
+        arriving.end();
+        dropped(ahead);
+    }
+    if (transfer === null)
+        return unconfirmed;
+    return installed(transfer);
+    async function parts(head, listed) {
+        const models = remodel(head.models, held);
+        const composition = compositionFor(room, models, builtIn, typedPaths);
+        const resumed = await staging.resume({
             locator,
+            transfer: transferIdentity(),
             selection,
-            ...(transfer?.pageToken == null ? {} : { pageToken: transfer.pageToken }),
-            ...(pool === null ? {} : { held: pool }),
-        });
-        if (page.kind === 'beyond-horizon')
-            return { kind: 'expired', held: { documents, revisions } };
-        if (page.kind !== 'bootstrap') {
-            if (!RESUMABLE.has(page.kind))
-                await staging.abandon(locator);
-            return page;
-        }
-        transfer = {
+            from: head.roomVersion,
+            last: head.roomVersion,
+            done: { bytes: 0 },
+            models,
+            key: null,
+        }, listed, composition);
+        if (resumed === null)
+            return unconfirmed;
+        let staged = resumed.record ?? {
             locator,
-            transfer: transfer?.transfer ?? transferIdentity(),
+            transfer: transferIdentity(),
             selection,
-            from: transfer !== null && adapter.reached(locator, page.roomVersion, transfer.from)
-                ? transfer.from
-                : page.roomVersion,
-            last: transfer !== null && !adapter.reached(locator, page.roomVersion, transfer.last)
-                ? transfer.last
-                : page.roomVersion,
-            pageToken: page.pageToken ?? null,
-            models: remodel(page.models, transfer?.models ?? held),
+            from: head.roomVersion,
+            last: head.roomVersion,
+            done: { bytes: 0 },
+            models,
+            key: null,
         };
-        const staged = pageLayer(page);
-        if (!(await staging.stage(transfer, staged)))
-            return unconfirmed;
-        Object.assign(documents, staged.documents);
-        Object.assign(revisions, staged.revisions);
-        Object.assign(changes, staged.changes);
-        Object.assign(written, staged.written);
-        Object.assign(binaries, staged.binaries);
-    }
-    const record = {
-        locator,
-        name: room.name,
-        handle: room.handle,
-        operations: room.operations,
-        replica: room.replica,
-        model: transfer.models.collection,
-        typedSelection: room.typedSelection ?? null,
-        selectionModel: transfer.models.selection,
-        providerOwnedPaths: room.providerOwnedPaths,
-        roomVersion: transfer.from,
-        transfer: transfer.transfer,
-        documents,
-        binaries,
-        revisions,
-        changes,
-        written,
-    };
-    const reconciled = transfer.last === transfer.from
-        ? { kind: 'still-current' }
-        : await advancement(adapter, authorization, record, remodel, continuing);
-    if (reconciled.kind === 'advanced' || reconciled.kind === 'still-current') {
-        const read = readStaged(reconciled.kind === 'advanced' ? reconciled.record : record);
-        if (read.kind === 'refused') {
-            await staging.abandon(locator);
-            return read;
+        const wanted = listed.filter((part) => !resumed.staged.has(part.id));
+        let arrived = staged.done.bytes;
+        const partial = new Map();
+        const report = () => {
+            let bytes = arrived;
+            for (const held of partial.values())
+                bytes += held;
+            arriving.at(bytes);
+        };
+        report();
+        const arrivals = [];
+        let woken = null;
+        let next = 0;
+        let flying = 0;
+        let halted = false;
+        let stopped = false;
+        let admitted = Promise.resolve();
+        const fetched = () => {
+            if ((next < wanted.length && !halted) || flying > 0)
+                return;
+            downloaded();
+            arriving.end();
+        };
+        const landed = (one) => {
+            flying -= 1;
+            if (stopped)
+                one.written();
+            else
+                arrivals.push(one);
+            woken?.();
+            ask();
+            fetched();
+        };
+        const fetch = async (part) => {
+            let written = () => { };
+            const admission = admitted.then(async () => {
+                await staging.unqueued();
+                written = staging.queued(part.bytes);
+            });
+            admitted = admission;
+            await admission;
+            const page = continuing()
+                ? await adapter.bootstrap(authorization, {
+                    locator,
+                    selection,
+                    signal: ending.signal,
+                    pageToken: part.id,
+                    arriving: (bytes) => {
+                        partial.set(part.id, Math.min(bytes, part.bytes));
+                        report();
+                    },
+                })
+                : unconfirmed;
+            landed({ part, page, written });
+        };
+        const ask = () => {
+            while (!stopped && !halted && flying < PARTS_IN_FLIGHT && next < wanted.length) {
+                const part = wanted[next];
+                next += 1;
+                flying += 1;
+                fetch(part).catch((error) => landed({ part, page: unconfirmed, written: () => { }, error }));
+            }
+        };
+        let failed = null;
+        ask();
+        fetched();
+        try {
+            for (;;) {
+                while (arrivals.length === 0) {
+                    if (flying === 0 && (halted || next >= wanted.length))
+                        break;
+                    await new Promise((wake) => (woken = wake));
+                    woken = null;
+                }
+                const one = arrivals.shift();
+                if (one === undefined)
+                    break;
+                const { part, page, written, error } = one;
+                try {
+                    if (error !== undefined)
+                        throw error;
+                    if (!continuing())
+                        return unconfirmed;
+                    if (page.kind !== 'bootstrap') {
+                        halted = true;
+                        failed ??= page.kind === 'beyond-horizon' ? unconfirmed : page;
+                        continue;
+                    }
+                    partial.delete(part.id);
+                    arrived += part.bytes;
+                    report();
+                    const kept = await staging.stage({ ...staged, done: { bytes: staged.done.bytes + part.bytes } }, await pageOf({ ...page, roomVersion: head.roomVersion }, part.id), composition);
+                    if (kept === null)
+                        return unconfirmed;
+                    staged = kept;
+                }
+                finally {
+                    written();
+                }
+            }
+        }
+        finally {
+            stopped = true;
+            for (const one of arrivals.splice(0))
+                one.written();
+        }
+        if (failed !== null)
+            return failed;
+        if (staged.key === null) {
+            const empty = await staging.stage(staged, { entries: [], folders: [] }, composition);
+            if (empty === null)
+                return unconfirmed;
+            staged = empty;
         }
-        return { kind: 'staged', confirmed: read.confirmed, stored: record };
+        return { kind: 'parted', transfer: staged };
     }
-    if (reconciled.kind === 'beyond-horizon') {
-        return { kind: 'expired', held: { documents, revisions } };
+    async function installed(transfer) {
+        const composition = compositionFor(room, transfer.models, builtIn, typedPaths);
+        if (!(await staging.derive(locator, transfer.key, composition)))
+            return unconfirmed;
+        await staging.turn(locator, 'replaying');
+        if (!continuing())
+            return unconfirmed;
+        const record = {
+            locator,
+            name: room.name,
+            handle: room.handle,
+            operations: room.operations,
+            replica: room.replica,
+            model: transfer.models.collection,
+            typedSelection: room.typedSelection ?? null,
+            providerOwnedPaths: room.providerOwnedPaths,
+            roomVersion: transfer.from,
+            transfer: transfer.transfer,
+            inventory: transfer.done,
+            key: transfer.key,
+        };
+        const last = transfer.last;
+        const refresh = adapter.refresh;
+        const reconciled = last === transfer.from &&
+            (staging.streamed || adapter.reached(locator, last, room.roomVersion))
+            ? { kind: 'still-current' }
+            : refresh === undefined
+                ? unconfirmed
+                : await advancement(refresh, authorization, record, remodel, continuing, await staging.refreshing(locator, record.key, composition));
+        if (reconciled.kind === 'advanced') {
+            return { kind: 'staged', record: reconciled.record, refreshed: true };
+        }
+        if (reconciled.kind === 'still-current')
+            return { kind: 'staged', record, refreshed: false };
+        if (reconciled.kind === 'beyond-horizon')
+            return { kind: 'expired', key: record.key };
+        return reconciled;
     }
-    if (!RESUMABLE.has(reconciled.kind))
-        await staging.abandon(locator);
-    return reconciled;
 }