@agentshouse/mdruntime-adapter 0.1.0-cbbc9b36e7fd4 → 0.1.0-cbc5a1c3e1e08

package/dist/adapter.js

@@ -1,46 +1,48 @@
+import { stepped } from '@agentshouse/mdruntime';
 import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
-import { partModels, streamedModels, viewModels } from './model.js';
+import { manifestedModels, partModels, streamedModels, viewModels } from './model.js';
 import { gathered, gatheredEach, selections } from './gather.js';
 import { createSiteAdapter } from './site.js';
-import { bootstrapOf, contentPrefixes, matchesScope, parseEnumeration, parseEnvelope, parseGrant, refreshFrom, viewOf, wholeView, } from './read.js';
+import { authorityRoot, bootstrapping, emptyScope, housePart, manifested, parseEnumeration, parseFileAddress, parseGrant, parseParted, partInventory, refreshFrom, viewOf, wholeView, } from './read.js';
+import { PART_ATTEMPTS, partArrival, partFrame, unverifiedPart } from './part.js';
 import { sha256Hex } from './digest.js';
-import { acceptedHanded, enumeratedHanded, heldHanded, scopeHanded, streamedHanded, } from './handed.js';
+import { finishedUpload, houseUpload } from './upload.js';
 import { houseAction } from './actions.js';
 import { classifyDoor, classifyRead, discoveryFailure, doorRefusal } from './refusal.js';
 import { houseNotifications } from './stream.js';
 import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_FILES_GET, DOOR_REVISIONS, } from './transport.js';
-import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
-import { houseReferrer } from './referrer.js';
+import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, houseMove, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
+import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.js';
 import { followsVersion, logPosition, presented, reachedVersion, roomVersion, } from './version.js';
 const UNCERTAIN = { kind: 'transport-uncertainty' };
 const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
+const EXPIRED_ADDRESS = 403;
 function lapsedGrant(outcome) {
     return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
 }
-function heldFiles(authority, held, after, budget) {
-    if (held === undefined || budget === 0)
-        return null;
-    const paths = Object.keys(held.revisions)
-        .filter((path) => held.documents[path] !== undefined && (after === null || path > after))
-        .sort();
-    if (paths.length === 0)
-        return null;
-    const files = paths.slice(0, budget).map((path) => ({ path, revision: held.revisions[path] }));
-    return { room: authority, through: paths.length > budget ? files.at(-1).path : null, files };
+async function heldFiles(authority, held, bound) {
+    const listed = await held.files(null, bound + 1);
+    const files = listed.slice(0, bound);
+    const through = listed.length > bound ? (files.at(-1)?.path ?? null) : null;
+    return files.length === 0 ? null : { room: authority, through, files };
 }
 async function reused(scope, held) {
     const sent = new Set(scope.contents.map((entry) => entry.path));
     const contents = [...scope.contents];
-    for (const file of scope.files) {
-        if (file.binary !== undefined || sent.has(file.path))
-            continue;
-        const content = held?.documents[file.path];
-        if (content === undefined ||
-            held?.revisions[file.path] !== file.revision ||
-            (await sha256Hex(content)) !== file.sha256) {
+    const asked = scope.files.filter((file) => file.binary === undefined && !sent.has(file.path));
+    if (asked.length === 0)
+        return scope;
+    if (held === undefined)
+        return null;
+    const kept = await held.contents(asked.map(({ path }) => path));
+    for (const file of asked) {
+        const found = kept.get(file.path);
+        if (found === undefined ||
+            found.revision !== file.revision ||
+            (await sha256Hex(found.content)) !== file.sha256) {
             return null;
         }
-        contents.push({ path: file.path, content });
+        contents.push({ path: file.path, content: found.content });
     }
     return { ...scope, contents };
 }
@@ -51,48 +53,83 @@ export function createAgentsHouseAdapter(options) {
     const notifications = houseNotifications(transport, 'credential');
     const tracked = new Map();
     const handed = new Map();
+    let heldRevisions;
     let bounds;
     function declared() {
         if (bounds === undefined)
             throw new Error('no Discovery declared the bounds');
         return bounds;
     }
-    async function bootstrappedRoom(envelope, sent, asked, continued) {
+    async function fetchedPart(entry, continued, listed, received, arriving) {
+        if (received !== undefined) {
+            const kept = new Uint8Array(received);
+            const held = await housePart(continued.room, kept, listed, 'credential');
+            if (held !== null)
+                return 'kind' in held ? held : { scope: held, frame: kept };
+        }
+        for (let attempt = 0; attempt < PART_ATTEMPTS; attempt += 1) {
+            const answered = await transport.door(DOOR_BOOTSTRAP, {
+                prefixes: [authorityRoot(entry.handle)],
+                part: listed.part,
+                ...(continued.held === undefined ? {} : { held: [continued.held] }),
+            }, partArrival(listed, arriving));
+            const failure = classifyRead(answered.status, answered.body, entry.locator);
+            if (failure !== null)
+                return failure;
+            const frame = partFrame(answered.body);
+            if (frame === null)
+                continue;
+            const scope = await housePart(continued.room, frame, listed, 'credential');
+            if (scope !== null)
+                return 'kind' in scope ? scope : { scope, frame };
+        }
+        return unverifiedPart(entry.locator);
+    }
+    async function manifestPage(asked, continued) {
+        const inventory = partInventory(continued.room);
+        if (inventory.parts === 0) {
+            const page = await partPage(asked, continued, undefined, undefined);
+            return page.kind === 'bootstrap' ? { ...page, inventory } : page;
+        }
+        const { models, seen } = await manifestedModels(continued.room, asked.entry);
+        return manifested(continued.room, inventory, JSON.stringify({ ...continued, seen }), models);
+    }
+    async function partPage(asked, continued, received, arriving) {
         const { entry } = asked;
-        if (sent === undefined)
-            return { kind: 'room-not-readable', locator: entry.locator };
-        const scope = await reused(sent, asked.held);
+        const listed = continued.room.parts[continued.next];
+        const sent = listed === undefined
+            ? { scope: emptyScope(continued.room), frame: null }
+            : await fetchedPart(entry, continued, listed, received, arriving);
+        if ('kind' in sent)
+            return sent;
+        const scope = await reused(sent.scope, asked.held);
         if (scope === null) {
             return asked.held === undefined
                 ? UNCERTAIN_READ
-                : continued === null
-                    ? bootstrapTogether({ entry, held: undefined })
-                    : continuedBootstrap({ entry, held: undefined }, continued);
+                : bootstrapTogether({ entry, held: undefined });
         }
-        const cursor = envelope.next?.room === entry.authority ? envelope.next : undefined;
-        const next = cursor?.path ?? null;
-        if (continued === null && next === null)
-            handed.set(entry.locator, scopeHanded(scope));
+        const next = continued.next + 1;
+        const more = next < continued.room.parts.length;
+        if (continued.next === 0 && !more)
+            handed.set(entry.locator, roomVersion(scope));
         else
             handed.delete(entry.locator);
         notifications.reach(entry.authority, scope);
         const seen = [
-            ...(continued?.seen ?? []),
-            ...entry.schemas.filter((schema) => scope.files.some((file) => file.path === schema)),
+            ...continued.seen,
+            ...(scope.files.some((file) => file.path === entry.schema) ? [entry.schema] : []),
         ];
-        const models = await partModels(scope, entry, new Set(seen), next === null);
-        const continuation = next === null
-            ? null
-            : { after: next, seen, ...(cursor?.cut === undefined ? {} : { cut: cursor.cut }) };
+        const models = await partModels(scope, entry, new Set(seen), !more);
         return {
-            ...bootstrapOf(scope),
+            ...(await stepped(bootstrapping(scope))),
             ...(models === undefined ? {} : { models }),
-            ...(continuation === null ? {} : { pageToken: JSON.stringify(continuation) }),
+            ...(more ? { pageToken: JSON.stringify({ ...continued, next, seen }) } : {}),
+            ...(sent.frame === null ? {} : { received: sent.frame }),
         };
     }
     async function enumeratedPage(ask, page) {
         const answer = await transport.door(DOOR_ENUMERATE, {
-            prefixes: contentPrefixes(ask.entry),
+            prefixes: [authorityRoot(ask.entry.handle)],
             positions: [
                 {
                     ...presented(ask.entry.authority, { position: page.after, logEpoch: ask.from.logEpoch }),
@@ -116,52 +153,54 @@ export function createAgentsHouseAdapter(options) {
         if ('kind' in view)
             return view;
         notifications.reach(ask.entry.authority, view);
-        const answer = refreshFrom(view, ask.fromRoomVersion);
+        const answer = await refreshFrom(view, ask.fromRoomVersion);
         if (answer.kind !== 'net-advancement')
             return answer;
-        handed.set(ask.entry.locator, enumeratedHanded(view, handed.get(ask.entry.locator)));
+        handed.set(ask.entry.locator, roomVersion(view));
         const models = await viewModels(view, ask.entry);
         return models === undefined ? answer : { ...answer, models };
     }
     async function streamed(entry, request, from) {
-        const held = handed.get(entry.locator);
-        if (held?.roomVersion !== request.fromRoomVersion)
+        if (handed.get(entry.locator) !== request.fromRoomVersion)
             return null;
-        const advanced = notifications.advance(entry, from, (path, revision) => held.revisions.get(path) === revision);
+        const asked = notifications.edited(entry, from);
+        const kept = asked.length === 0 || heldRevisions === undefined
+            ? new Map()
+            : await heldRevisions(entry.locator, asked);
+        const advanced = await stepped(notifications.advance(entry, from, (path, revision) => kept.get(path) === revision));
         if (advanced === null)
             return null;
-        handed.set(entry.locator, streamedHanded(held, advanced));
+        handed.set(entry.locator, advanced.page.roomVersion);
         const models = await streamedModels(advanced.schemas, entry, 'credential');
         return models === undefined ? advanced.page : { ...advanced.page, models };
     }
-    function held(rooms, demand) {
+    function held(rooms) {
         const kept = rooms.flatMap((room) => {
             const entry = tracked.get(room.locator);
             const at = logPosition(room.roomVersion);
             if (entry === undefined || at === null)
                 return [];
-            handed.set(room.locator, heldHanded(room));
+            handed.set(room.locator, room.roomVersion);
             notifications.reach(entry.authority, at);
             return [presented(entry.authority, at)];
         });
-        notifications.send(kept, demand === null
-            ? null
-            : {
-                rooms: demand.rooms.flatMap((locator) => {
-                    const entry = tracked.get(locator);
-                    return entry === undefined ? [] : [entry.authority];
-                }),
-                conversations: demand.conversations,
-            });
+        notifications.send(kept);
+    }
+    async function adoptedMove(entry, into, outcome) {
+        if (outcome.kind === 'accepted' && outcome.destination !== undefined) {
+            await adopted(into, { kind: 'accepted', ...outcome.destination });
+        }
+        return adopted(entry, outcome);
     }
-    function adopted(entry, outcome) {
+    async function adopted(entry, outcome) {
         if (outcome.kind !== 'accepted')
             return outcome;
         const held = handed.get(entry.locator);
         if (held === undefined)
             return outcome;
-        const follows = followsVersion(held.roomVersion, outcome.roomVersion);
-        handed.set(entry.locator, acceptedHanded(held, outcome, follows ? outcome.roomVersion : held.roomVersion));
+        const follows = followsVersion(held, outcome.roomVersion);
+        if (follows)
+            handed.set(entry.locator, outcome.roomVersion);
         const at = logPosition(outcome.roomVersion);
         if (follows && at !== null)
             notifications.reach(entry.authority, at);
@@ -184,68 +223,61 @@ export function createAgentsHouseAdapter(options) {
             return result;
         return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
     }
-    function weight(entry) {
-        return contentPrefixes(entry).length;
-    }
-    function holding(asks, after) {
-        const budget = Math.floor(declared().max_held_files / Math.max(1, asks.filter((ask) => ask.held !== undefined).length));
-        return asks.flatMap((ask) => heldFiles(ask.entry.authority, ask.held, after, budget) ?? []);
+    async function holding(asks) {
+        const bound = Math.floor(declared().max_held_files / Math.max(1, asks.filter((ask) => ask.held !== undefined).length));
+        const held = [];
+        for (const ask of asks) {
+            if (ask.held === undefined || bound === 0)
+                continue;
+            const files = await heldFiles(ask.entry.authority, ask.held, bound);
+            if (files !== null)
+                held.push(files);
+        }
+        return held;
     }
     async function bootstrapped(asks, answer) {
         let open = asks.map((asked, ask) => ({ entry: asked.entry, asked, ask }));
         while (open.length > 0) {
             const unreached = [];
-            for (const part of selections(open, ({ entry }) => weight(entry), declared().max_prefixes)) {
-                const held = holding(part.map(({ asked }) => asked), null);
+            for (const part of selections(open, declared().max_prefixes)) {
+                const held = await holding(part.map(({ asked }) => asked));
                 const answered = await transport.door(DOOR_BOOTSTRAP, {
-                    prefixes: part.flatMap(({ entry }) => contentPrefixes(entry)),
+                    prefixes: part.map(({ entry }) => authorityRoot(entry.handle)),
                     ...(held.length === 0 ? {} : { held }),
                 });
                 const classified = part.map(({ entry }) => classifyDoor(answered.status, answered.body, entry.locator));
-                const envelope = classified[0] === null ? parseEnvelope(answered.body) : null;
+                const parted = classified[0] === null ? parseParted(answered.body) : null;
                 for (const [index, asked] of part.entries()) {
                     const failure = classified[index];
                     if (failure !== null && failure !== undefined) {
                         answer(asked.ask, failure);
                         continue;
                     }
-                    if (envelope === null) {
+                    if (parted === null) {
                         answer(asked.ask, UNCERTAIN_READ);
                         continue;
                     }
-                    const scope = envelope.scopes.find((candidate) => matchesScope(candidate, asked.entry));
-                    if (scope === undefined && envelope.next !== undefined) {
+                    const room = parted.rooms.find((candidate) => candidate.anchor === asked.entry.authority);
+                    if (room === undefined && parted.next !== undefined) {
                         unreached.push(asked);
                         continue;
                     }
-                    answer(asked.ask, await bootstrappedRoom(envelope, scope, asked.asked, null));
+                    if (room === undefined) {
+                        answer(asked.ask, { kind: 'room-not-readable', locator: asked.entry.locator });
+                        continue;
+                    }
+                    const kept = held.find((files) => files.room === asked.entry.authority);
+                    answer(asked.ask, await manifestPage(asked.asked, {
+                        room,
+                        next: 0,
+                        seen: [],
+                        ...(kept === undefined ? {} : { held: kept }),
+                    }));
                 }
             }
             open = unreached;
         }
     }
-    async function continuedBootstrap(asked, continued) {
-        const { entry } = asked;
-        const after = {
-            room: entry.authority,
-            path: continued.after,
-            ...(continued.cut === undefined ? {} : { cut: continued.cut }),
-        };
-        const held = holding([asked], continued.after);
-        const answered = await transport.door(DOOR_BOOTSTRAP, {
-            prefixes: contentPrefixes(entry),
-            after,
-            ...(held.length === 0 ? {} : { held }),
-        });
-        const failure = classifyRead(answered.status, answered.body, entry.locator);
-        if (failure !== null)
-            return failure;
-        const envelope = parseEnvelope(answered.body);
-        if (envelope === null)
-            return UNCERTAIN_READ;
-        const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
-        return bootstrappedRoom(envelope, scope, asked, continued);
-    }
     function layered(asks) {
         const depths = new Map();
         const layers = [];
@@ -258,12 +290,12 @@ export function createAgentsHouseAdapter(options) {
     }
     async function enumerated(asks) {
         const answers = [];
-        const parts = layered(asks.map((ask, index) => ({ ask, index }))).flatMap((layer) => selections(layer, ({ ask }) => weight(ask.entry), declared().max_prefixes));
+        const parts = layered(asks.map((ask, index) => ({ ask, index }))).flatMap((layer) => selections(layer, declared().max_prefixes));
         for (const part of parts) {
             let open = [...part];
             while (open.length > 0) {
                 const answer = await transport.door(DOOR_ENUMERATE, {
-                    prefixes: open.flatMap(({ ask }) => contentPrefixes(ask.entry)),
+                    prefixes: open.map(({ ask }) => authorityRoot(ask.entry.handle)),
                     positions: open.map(({ ask }) => presented(ask.entry.authority, ask.from)),
                 });
                 const classified = open.map(({ ask }) => classifyRead(answer.status, answer.body, ask.entry.locator));
@@ -302,10 +334,12 @@ export function createAgentsHouseAdapter(options) {
         }
         const minted = await transport.door(DOOR_BATCH_UPLOAD, { ...head, paths, bytes, sha256 });
         if (minted.status !== 200) {
-            return { outcome: mutationOutcome(minted.status, minted.body, entry.locator, entry.handle) };
+            return {
+                outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
+            };
         }
         const grant = parseGrant(minted.body);
-        if (grant === null || grant.method !== 'POST')
+        if (grant === null)
             return { outcome: UNCERTAIN };
         const delivered = await transport.transfer({
             act: 'authored_batch_upload',
@@ -315,36 +349,31 @@ export function createAgentsHouseAdapter(options) {
         if (delivered.status !== 200)
             return { outcome: UNCERTAIN };
         const holding = parseGrant(delivered.body);
-        if (holding === null || holding.method !== 'POST')
+        if (holding === null)
             return { outcome: UNCERTAIN };
         const upload = { url: holding.url, operation: holding.operation, bytes, sha256 };
         await keep(upload);
         return { body: { ...head, paths, upload, runtime: notifications.runtime } };
     }
-    async function staged(answer, batch) {
+    async function staged(answer, { changeBatch: batch, file }) {
         const refusal = doorRefusal(answer.body);
         if (refusal?.code !== 'files_unstaged')
             return null;
-        const grants = refusal.fields.upload;
-        if (!Array.isArray(grants))
+        const uploads = refusal.fields.upload;
+        if (!Array.isArray(uploads))
             return false;
-        for (const grant of grants) {
-            const { url, operation, sha256 } = grant;
-            const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === sha256);
-            if (typeof url !== 'string' || typeof operation !== 'string' || change === undefined)
+        for (const named of uploads) {
+            const upload = houseUpload(named);
+            const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === named.sha256);
+            if (upload === null || change === undefined)
                 return false;
-            const delivered = await transport.transfer({
-                act: 'binary_stage',
-                url,
-                body: change.blob,
-                operation,
-            });
-            if (delivered.status !== 200)
+            const finished = await finishedUpload(transport, upload, await file(change.localId));
+            if (finished?.body?.staged !== true)
                 return false;
         }
         return true;
     }
-    async function submit(batch, head, changes, delta, bytes, entry, handed, keep) {
+    async function submit(request, head, changes, delta, bytes, entry, handed, keep, into) {
         const inline = { ...head, changes, runtime: notifications.runtime };
         const prepared = uploadable(inline, bytes, declared())
             ? await uploaded(head, changes, delta, bytes, entry, handed, keep)
@@ -352,15 +381,20 @@ export function createAgentsHouseAdapter(options) {
         if ('outcome' in prepared)
             return prepared.outcome;
         const answer = await transport.door(DOOR_BATCH, prepared.body);
-        const stagedFiles = await staged(answer, batch);
+        const stagedFiles = await staged(answer, request);
         if (stagedFiles === false)
             return UNCERTAIN;
         const settled = stagedFiles === null ? answer : await transport.door(DOOR_BATCH, prepared.body);
-        if (stagedFiles === true && (await staged(settled, batch)) !== null)
+        if (stagedFiles === true && (await staged(settled, request)) !== null)
             return UNCERTAIN;
-        return mutationOutcome(settled.status, settled.body, entry.locator, entry.handle);
+        return stepped(mutationOutcome(settled.status, settled.body, entry.locator, entry.handle, into === undefined
+            ? undefined
+            : {
+                source: { authority: entry.authority, handle: entry.handle },
+                destination: { authority: into.authority, handle: into.handle },
+            }));
     }
-    async function downloaded(answer, locator) {
+    function addressed(answer, locator) {
         const failure = classifyDoor(answer.status, answer.body, locator);
         if (failure !== null) {
             return failure.kind === 'scoped-refusal'
@@ -372,20 +406,56 @@ export function createAgentsHouseAdapter(options) {
                 }
                 : failure;
         }
-        const grant = parseGrant(answer.body);
-        if (grant === null || grant.method !== 'GET')
-            return UNCERTAIN_READ;
-        const read = await transport.download(grant.url);
-        if (read.status !== 200 || read.blob === null)
+        const address = parseFileAddress(answer.body);
+        return address === null ? UNCERTAIN_READ : { kind: 'address', ...address };
+    }
+    function linked(answer, locator) {
+        const address = addressed(answer, locator);
+        return address.kind === 'address'
+            ? { kind: 'link', url: address.url, name: address.name }
+            : address;
+    }
+    async function downloaded(ask, locator) {
+        let address = addressed(await ask(), locator);
+        if (address.kind !== 'address')
+            return address;
+        let read = await transport.download(address.url);
+        if (read.status === EXPIRED_ADDRESS) {
+            address = addressed(await ask(), locator);
+            if (address.kind !== 'address')
+                return address;
+            read = await transport.download(address.url);
+        }
+        if (read.status !== 200 || read.body === null)
             return UNCERTAIN_READ;
-        return { kind: 'binary', blob: read.blob };
+        return {
+            kind: 'binary',
+            body: read.body,
+            mediaType: address.mediaType,
+            sha256: address.sha256,
+        };
+    }
+    function pathAddress(request) {
+        const entry = authorityFor(request.locator);
+        if (entry === undefined)
+            return null;
+        return () => transport.door(DOOR_FILES_GET, {
+            room_ref: entry.authority,
+            path: request.path,
+            revision: request.revision,
+        });
     }
     return {
+        roomTypes: HOUSE_ROOM_TYPES,
+        nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
         async authorize() {
             return options.authorize();
         },
-        async discover(_authorization) {
-            const answer = await transport.door(DOOR_DISCOVER, { prefixes: [...DISCOVER_PREFIXES] });
+        async discover(_authorization, scope) {
+            const answer = await transport.door(DOOR_DISCOVER, {
+                prefixes: [...DISCOVER_PREFIXES],
+                ...(scope === undefined ? {} : { rooms: scope.authorities }),
+            });
             const failed = discoveryFailure(answer.status, answer.body);
             if (failed !== null)
                 return failed;
@@ -394,16 +464,31 @@ export function createAgentsHouseAdapter(options) {
                 return { kind: 'transport-uncertainty' };
             bounds = document.bounds;
             const entries = trackedFrom(document);
-            tracked.clear();
+            const covered = scope === undefined
+                ? null
+                : [
+                    ...new Set([
+                        ...[...tracked.values()]
+                            .filter((entry) => scope.authorities.includes(entry.authority))
+                            .map((entry) => entry.locator),
+                        ...entries.map((entry) => entry.locator),
+                    ]),
+                ];
+            if (covered === null)
+                tracked.clear();
+            else
+                for (const locator of covered)
+                    tracked.delete(locator);
             for (const entry of entries)
                 tracked.set(entry.locator, entry);
             for (const locator of handed.keys())
                 if (!tracked.has(locator))
                     handed.delete(locator);
-            notifications.track(entries);
+            notifications.track([...tracked.values()]);
             return {
-                ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document)),
+                ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions, [...tracked.values()])),
                 member: document.member,
+                ...(covered === null ? {} : { covered }),
             };
         },
         async bootstrap(_authorization, request) {
@@ -412,7 +497,7 @@ export function createAgentsHouseAdapter(options) {
                 return { kind: 'room-not-readable', locator: request.locator };
             const asked = { entry, held: request.held };
             if (request.pageToken !== undefined) {
-                return continuedBootstrap(asked, JSON.parse(request.pageToken));
+                return partPage(asked, JSON.parse(request.pageToken), request.received, request.arriving);
             }
             return bootstrapTogether(asked);
         },
@@ -434,18 +519,27 @@ export function createAgentsHouseAdapter(options) {
             const entry = authorityFor(request.locator);
             if (entry === undefined)
                 return { kind: 'room-not-readable', locator: request.locator };
-            const mapped = houseChanges(request.changeBatch, entry.handle);
+            const batch = request.changeBatch;
+            const destination = batch.between?.destination.room;
+            const into = destination === undefined ? undefined : authorityFor(destination);
+            if (destination !== undefined && into === undefined) {
+                return { kind: 'room-not-readable', locator: destination };
+            }
+            const mapped = into === undefined
+                ? houseChanges(batch, entry.handle)
+                : houseMove(batch, entry.handle, into.handle);
             if (mapped.kind === 'unmapped')
                 return rejectedMapping(mapped);
-            const head = operationHead(request.changeBatch);
+            const head = operationHead(batch);
             const delta = deltaBody(mapped.changes);
             const bytes = deltaBytes(delta);
             const handed = request.upload;
-            const batch = request.changeBatch;
-            const outcome = await submit(batch, head, mapped.changes, delta, bytes, entry, handed, keep);
+            const answer = (upload) => submit(request, head, mapped.changes, delta, bytes, entry, upload, keep, into);
+            const settle = (outcome) => into === undefined ? adopted(entry, outcome) : adoptedMove(entry, into, outcome);
+            const outcome = await answer(handed);
             if (handed === undefined || !lapsedGrant(outcome))
-                return adopted(entry, outcome);
-            return adopted(entry, await submit(batch, head, mapped.changes, delta, bytes, entry, undefined, keep));
+                return settle(outcome);
+            return settle(await answer(undefined));
         },
         async history(_authorization, request) {
             const entry = authorityFor(request.locator);
@@ -463,35 +557,16 @@ export function createAgentsHouseAdapter(options) {
             });
         },
         async binary(_authorization, request) {
-            if (request.kind === 'path') {
-                const entry = authorityFor(request.locator);
-                if (entry === undefined)
-                    return { kind: 'room-not-readable', locator: request.locator };
-                const answer = await transport.door(DOOR_FILES_GET, {
-                    room_ref: entry.authority,
-                    path: request.path,
-                    revision: request.revision,
-                });
-                return downloaded(answer, request.locator);
-            }
-            const referrer = houseReferrer(request.referrer, tracked);
-            if (referrer === null) {
-                return { kind: 'rejected', code: 'referrer_unknown', fields: {}, retryable: false };
-            }
-            const answer = await transport.door(DOOR_FILES_GET, {
-                file: request.fileRef,
-                referrer: referrer.referrer,
-            });
-            return downloaded(answer, referrer.locator);
+            const ask = pathAddress(request);
+            if (ask === null)
+                return { kind: 'room-not-readable', locator: request.locator };
+            return downloaded(ask, request.locator);
         },
-        referrerScope(referrer) {
-            const held = houseReferrer(referrer, tracked);
-            if (held === null)
-                return null;
-            if (held.locator === '')
-                return { kind: 'conversations' };
-            const { path } = held.referrer;
-            return { kind: 'room', locator: held.locator, ...(path === undefined ? {} : { path }) };
+        async link(_authorization, request) {
+            const ask = pathAddress(request);
+            if (ask === null)
+                return { kind: 'room-not-readable', locator: request.locator };
+            return linked(await ask(), request.locator);
         },
         reached(locator, version, target) {
             return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
@@ -505,7 +580,10 @@ export function createAgentsHouseAdapter(options) {
         roomStream: {
             hold: held,
             reopen: notifications.reopen,
-            observe: notifications.observe,
+            observe(notify, receipts, revisions) {
+                heldRevisions = revisions;
+                return notifications.observe(notify, receipts);
+            },
             published(locator, roomVersion) {
                 const at = logPosition(roomVersion);
                 if (at !== null)

package/dist/app-reference.d.ts

@@ -0,0 +1,2 @@
+export declare const APP_REFERENCE_PATTERN: RegExp;
+//# sourceMappingURL=app-reference.d.ts.map