@agentshouse/mdruntime-adapter 0.1.0-ce3fe65a95f49 → 0.1.0-ce5ef9afd7e9a

package/dist/adapter.js

@@ -1,75 +1,158 @@
+import { stepped } from '@agentshouse/mdruntime';
 import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
 import { 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, } from './read.js';
-import { acceptedHanded, enumeratedHanded, heldHanded, scopeHanded, streamedHanded, } from './handed.js';
+import { authorityRoot, bootstrapping, emptyScope, housePart, parseEnumeration, parseFileAddress, parseGrant, parseParted, refreshFrom, viewOf, wholeView, } from './read.js';
+import { PART_ATTEMPTS, unverifiedPart } from './part.js';
+import { sha256Hex } from './digest.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 { houseReferrer, houseReferrerScope } from './referrer.js';
+import { 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';
 }
+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];
+    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: found.content });
+    }
+    return { ...scope, contents };
+}
 export function createAgentsHouseAdapter(options) {
     if ('site' in options)
-        return createSiteAdapter(options.site);
+        return createSiteAdapter(options.site, options.snapshot === true);
     const transport = options.transport;
     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, scope, entry, continued) {
-        if (scope === undefined)
-            return { kind: 'room-not-readable', locator: entry.locator };
-        const next = envelope.next?.room === entry.authority ? envelope.next.path : null;
-        if (continued === null && next === null)
-            handed.set(entry.locator, scopeHanded(scope));
+    async function fetchedPart(entry, continued, listed) {
+        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] }),
+            });
+            const failure = classifyRead(answered.status, answered.body, entry.locator);
+            if (failure !== null)
+                return failure;
+            const scope = await housePart(continued.room, answered.body, listed, 'credential');
+            if (scope !== null)
+                return scope;
+        }
+        return unverifiedPart(entry.locator);
+    }
+    async function partPage(asked, continued) {
+        const { entry } = asked;
+        const listed = continued.room.parts[continued.next];
+        const sent = listed === undefined
+            ? emptyScope(continued.room)
+            : await fetchedPart(entry, continued, listed);
+        if ('kind' in sent)
+            return sent;
+        const scope = await reused(sent, asked.held);
+        if (scope === null) {
+            return asked.held === undefined
+                ? UNCERTAIN_READ
+                : bootstrapTogether({ entry, held: undefined });
+        }
+        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 ?? []),
+            ...continued.seen,
             ...entry.schemas.filter((schema) => scope.files.some((file) => file.path === schema)),
         ];
-        const models = await partModels(scope, entry, new Set(seen), next === null);
-        const continuation = next === null ? null : { after: next, seen };
+        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 }) } : {}),
         };
     }
+    async function enumeratedPage(ask, page) {
+        const answer = await transport.door(DOOR_ENUMERATE, {
+            prefixes: [authorityRoot(ask.entry.handle)],
+            positions: [
+                {
+                    ...presented(ask.entry.authority, { position: page.after, logEpoch: ask.from.logEpoch }),
+                    page: { through: page.through, read: page.read },
+                },
+            ],
+        });
+        const failure = classifyRead(answer.status, answer.body, ask.entry.locator);
+        if (failure !== null)
+            return failure;
+        const enumeration = parseEnumeration(answer.body, 'credential');
+        if (enumeration === null)
+            return UNCERTAIN_READ;
+        return (viewOf(enumeration, ask.entry) ?? { kind: 'room-not-readable', locator: ask.entry.locator });
+    }
     async function enumeratedRoom(enumeration, ask) {
-        const view = viewOf(enumeration, ask.entry);
-        if (view === undefined)
+        const first = viewOf(enumeration, ask.entry);
+        if (first === undefined)
             return { kind: 'room-not-readable', locator: ask.entry.locator };
+        const view = await wholeView(first, (page) => enumeratedPage(ask, page));
+        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 };
     }
@@ -79,20 +162,27 @@ export function createAgentsHouseAdapter(options) {
             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);
     }
-    function adopted(entry, outcome) {
+    async function adoptedMove(entry, into, outcome) {
+        if (outcome.kind === 'accepted' && outcome.destination !== undefined) {
+            await adopted(into, { kind: 'accepted', ...outcome.destination });
+        }
+        return 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);
@@ -115,99 +205,106 @@ export function createAgentsHouseAdapter(options) {
             return result;
         return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
     }
-    function weight(entry) {
-        return contentPrefixes(entry).length;
+    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(entries, answer) {
-        let open = entries.map((entry, ask) => ({ entry, ask }));
+    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)) {
+            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.entry, 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 partPage(asked.asked, {
+                        room,
+                        next: 0,
+                        seen: [],
+                        ...(kept === undefined ? {} : { held: kept }),
+                    }));
                 }
             }
             open = unreached;
         }
     }
-    async function continuedBootstrap(entry, continued) {
-        const after = { room: entry.authority, path: continued.after };
-        const answered = await transport.door(DOOR_BOOTSTRAP, {
-            prefixes: contentPrefixes(entry),
-            after,
-        });
-        const failure = classifyDoor(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, entry, continued);
-    }
     function layered(asks) {
         const depths = new Map();
         const layers = [];
         for (const ask of asks) {
-            const depth = depths.get(ask.entry.authority) ?? 0;
-            depths.set(ask.entry.authority, depth + 1);
+            const depth = depths.get(ask.ask.entry.authority) ?? 0;
+            depths.set(ask.ask.entry.authority, depth + 1);
             (layers[depth] ??= []).push(ask);
         }
         return layers;
     }
     async function enumerated(asks) {
-        const answers = new Map();
-        const parts = layered(asks).flatMap((layer) => selections(layer, (ask) => weight(ask.entry), declared().max_prefixes));
+        const answers = [];
+        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)),
-                    positions: open.map((ask) => presented(ask.entry.authority, ask.from)),
+                    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));
+                const classified = open.map(({ ask }) => classifyRead(answer.status, answer.body, ask.entry.locator));
                 if (classified[0]?.kind === 'beyond-horizon') {
                     const named = doorRefusal(answer.body)?.fields.authority;
-                    const expired = open.filter((ask) => ask.entry.authority === named);
+                    const expired = open.filter(({ ask }) => ask.entry.authority === named);
                     const answered = expired.length === 0 ? UNCERTAIN_READ : { kind: 'beyond-horizon' };
                     const gone = expired.length === 0 ? open : expired;
                     for (const ask of gone)
-                        answers.set(ask, answered);
+                        answers[ask.index] = answered;
                     open = open.filter((ask) => !gone.includes(ask));
                     continue;
                 }
                 const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
-                for (const [index, ask] of open.entries()) {
-                    const failure = classified[index];
+                for (const [answerIndex, { ask, index }] of open.entries()) {
+                    const failure = classified[answerIndex];
                     if (failure !== null && failure !== undefined) {
-                        answers.set(ask, failure);
+                        answers[index] = failure;
                         continue;
                     }
-                    answers.set(ask, enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask));
+                    answers[index] =
+                        enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask);
                 }
                 open = [];
             }
         }
-        return asks.map((ask) => answers.get(ask) ?? UNCERTAIN_READ);
+        return answers;
     }
     const bootstrapTogether = gatheredEach(bootstrapped);
     const enumerateTogether = gathered(enumerated);
@@ -219,10 +316,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',
@@ -232,36 +331,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)
@@ -269,15 +363,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'
@@ -289,20 +388,55 @@ 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,
         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;
@@ -311,26 +445,42 @@ 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) {
             const entry = authorityFor(request.locator);
             if (entry === undefined)
                 return { kind: 'room-not-readable', locator: request.locator };
+            const asked = { entry, held: request.held };
             if (request.pageToken !== undefined) {
-                return continuedBootstrap(entry, JSON.parse(request.pageToken));
+                return partPage(asked, JSON.parse(request.pageToken));
             }
-            return bootstrapTogether(entry);
+            return bootstrapTogether(asked);
         },
         async refresh(_authorization, request) {
             const entry = authorityFor(request.locator);
@@ -350,18 +500,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);
@@ -380,34 +539,25 @@ export function createAgentsHouseAdapter(options) {
         },
         async binary(_authorization, request) {
             if (request.kind === 'path') {
-                const entry = authorityFor(request.locator);
-                if (entry === undefined)
+                const ask = pathAddress(request);
+                if (ask === null)
                     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);
+                return downloaded(ask, 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);
+            return downloaded(() => transport.door(DOOR_FILES_GET, { file: request.fileRef, referrer: referrer.referrer }), referrer.locator);
+        },
+        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);
         },
         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 }) };
+            return houseReferrerScope(referrer, tracked);
         },
         reached(locator, version, target) {
             return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
@@ -418,7 +568,19 @@ export function createAgentsHouseAdapter(options) {
         async action(_authorization, request) {
             return withAt(await houseAction(transport, request));
         },
-        roomStream: { hold: held, reopen: notifications.reopen, observe: notifications.observe },
+        roomStream: {
+            hold: held,
+            reopen: notifications.reopen,
+            observe(notify, receipts, revisions) {
+                heldRevisions = revisions;
+                return notifications.observe(notify, receipts);
+            },
+            published(locator, roomVersion) {
+                const at = logPosition(roomVersion);
+                if (at !== null)
+                    notifications.published(locator, at);
+            },
+        },
         conversations: notifications.conversations,
         serviceMode: notifications.serviceMode,
     };