@agentshouse/mdruntime-adapter 0.1.0-cd028205a5103 → 0.1.0-cd23c45caa798

package/dist/adapter.js

@@ -1,23 +1,66 @@
+import { sortedKeys, stepped } from '@agentshouse/mdruntime';
 import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
-import { scopeModels, streamedModels, viewModels } from './model.js';
-import { gathered, selections } from './gather.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 { acceptedLinks, enumeratedLinks, heldLinks, scopeLinks, streamedLinks, } from './links.js';
+import { authorityRoot, bootstrapping, emptyScope, housePart, parseEnumeration, parseGrant, parseParted, refreshFrom, viewOf, wholeView, } from './read.js';
+import { PART_ATTEMPTS, unverifiedPart } from './part.js';
+import { sha256Hex } from './digest.js';
+import { acceptedHanded, enumeratedHanded, heldHanded, scopeHanded, streamedHanded, } from './handed.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_REVISIONS, } from './transport.js';
-import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.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, houseMove, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
+import { houseReferrer } from './referrer.js';
 import { followsVersion, logPosition, presented, reachedVersion, roomVersion, } from './version.js';
 const UNCERTAIN = { kind: 'transport-uncertainty' };
 const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
 function lapsedGrant(outcome) {
     return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
 }
+const heldPaths = new WeakMap();
+async function sortedHeld(held) {
+    const known = heldPaths.get(held.documents);
+    if (known !== undefined)
+        return known;
+    const sorted = await stepped(sortedKeys(held.documents));
+    heldPaths.set(held.documents, sorted);
+    return sorted;
+}
+function heldFiles(authority, held, paths, bound) {
+    const files = [];
+    let through = null;
+    for (let at = 0; at < paths.length && through === null; at += 1) {
+        const revision = held.revisions[paths[at]];
+        if (revision === undefined)
+            continue;
+        if (files.length === bound)
+            through = files.at(-1).path;
+        else
+            files.push({ path: paths[at], revision });
+    }
+    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) {
+            return null;
+        }
+        contents.push({ path: file.path, 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();
@@ -28,38 +71,109 @@ export function createAgentsHouseAdapter(options) {
             throw new Error('no Discovery declared the bounds');
         return bounds;
     }
-    async function bootstrappedRoom(envelope, entry) {
-        const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
-        if (scope === undefined)
-            return { kind: 'room-not-readable', locator: entry.locator };
-        handed.set(entry.locator, scopeLinks(scope));
+    function hand(locator, steps) {
+        const held = handed.get(locator);
+        const next = stepped(steps);
+        if (!(next instanceof Promise)) {
+            handed.set(locator, next);
+            return;
+        }
+        return next.then((room) => {
+            if (handed.get(locator) === held)
+                handed.set(locator, room);
+            else
+                handed.delete(locator);
+        });
+    }
+    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)
+            await hand(entry.locator, scopeHanded(scope));
+        else
+            handed.delete(entry.locator);
         notifications.reach(entry.authority, scope);
-        const models = await scopeModels(scope, entry);
-        return { ...bootstrapOf(scope), ...(models === undefined ? {} : { models }) };
+        const seen = [
+            ...continued.seen,
+            ...entry.schemas.filter((schema) => scope.files.some((file) => file.path === schema)),
+        ];
+        const models = await partModels(scope, entry, new Set(seen), !more);
+        return {
+            ...(await stepped(bootstrapping(scope))),
+            ...(models === undefined ? {} : { models }),
+            ...(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, enumeratedLinks(view, handed.get(ask.entry.locator)));
+        await hand(ask.entry.locator, enumeratedHanded(view, handed.get(ask.entry.locator)));
         const models = await viewModels(view, ask.entry);
         return models === undefined ? answer : { ...answer, models };
     }
     async function streamed(entry, request, from) {
-        const links = handed.get(entry.locator);
-        if (links?.roomVersion !== request.fromRoomVersion)
+        const held = handed.get(entry.locator);
+        if (held?.roomVersion !== request.fromRoomVersion)
             return null;
-        const advanced = notifications.advance(entry, from, (path, revision) => links.revisions.get(path) === revision);
+        const advanced = await stepped(notifications.advance(entry, from, (path, revision) => held.revisions[path] === revision));
         if (advanced === null)
             return null;
-        const relinked = streamedLinks(links, advanced);
-        if (relinked === null)
-            return null;
-        handed.set(entry.locator, relinked);
+        await hand(entry.locator, streamedHanded(held, advanced));
         const models = await streamedModels(advanced.schemas, entry, 'credential');
         return models === undefined ? advanced.page : { ...advanced.page, models };
     }
@@ -69,28 +183,30 @@ export function createAgentsHouseAdapter(options) {
             const at = logPosition(room.roomVersion);
             if (entry === undefined || at === null)
                 return [];
-            handed.set(room.locator, heldLinks(room));
+            handed.set(room.locator, heldHanded(room));
             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 { originals, ...accepted } = outcome;
-        const links = handed.get(entry.locator);
-        if (links === undefined)
-            return accepted;
-        const follows = followsVersion(links.roomVersion, accepted.roomVersion);
-        const relinked = acceptedLinks(links, accepted, follows ? accepted.roomVersion : links.roomVersion, originals);
-        handed.set(entry.locator, relinked.links);
-        const at = logPosition(accepted.roomVersion);
+        const held = handed.get(entry.locator);
+        if (held === undefined)
+            return outcome;
+        const follows = followsVersion(held.roomVersion, outcome.roomVersion);
+        await hand(entry.locator, acceptedHanded(held, outcome, follows ? outcome.roomVersion : held.roomVersion));
+        const at = logPosition(outcome.roomVersion);
         if (follows && at !== null)
             notifications.reach(entry.authority, at);
-        return relinked.attachments === undefined
-            ? accepted
-            : { ...accepted, attachments: relinked.attachments };
+        return outcome;
     }
     function authorityFor(locator) {
         return tracked.get(locator);
@@ -109,88 +225,109 @@ export function createAgentsHouseAdapter(options) {
             return result;
         return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
     }
-    async function bundled(body) {
-        const grant = parseGrant(body);
-        if (grant === null)
-            return body;
-        if (grant.method !== 'GET')
-            return null;
-        const answer = await transport.transfer({
-            act: 'local_copy_bundle',
-            method: 'GET',
-            url: grant.url,
-            answer: 'json',
-        });
-        return answer.status === 200 ? answer.body : null;
-    }
-    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 paths = await sortedHeld(ask.held);
+            const files = heldFiles(ask.entry.authority, ask.held, paths, bound);
+            if (files !== null)
+                held.push(files);
+        }
+        return held;
     }
-    async function bootstrapped(entries) {
-        const answers = [];
-        for (const part of selections(entries, weight, declared().max_prefixes)) {
-            const answer = await transport.door(DOOR_BOOTSTRAP, {
-                prefixes: part.flatMap((entry) => contentPrefixes(entry)),
-            });
-            const classified = part.map((entry) => classifyDoor(answer.status, answer.body, entry.locator));
-            const envelope = classified[0] === null ? parseEnvelope(await bundled(answer.body)) : null;
-            for (const [index, entry] of part.entries()) {
-                const failure = classified[index];
-                if (failure === null || failure === undefined) {
-                    answers.push(envelope === null ? UNCERTAIN_READ : await bootstrappedRoom(envelope, entry));
-                    continue;
+    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, declared().max_prefixes)) {
+                const held = await holding(part.map(({ asked }) => asked));
+                const answered = await transport.door(DOOR_BOOTSTRAP, {
+                    prefixes: part.map(({ entry }) => authorityRoot(entry.handle)),
+                    ...(held.length === 0 ? {} : { held }),
+                });
+                const classified = part.map(({ entry }) => classifyDoor(answered.status, answered.body, entry.locator));
+                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 (parted === null) {
+                        answer(asked.ask, UNCERTAIN_READ);
+                        continue;
+                    }
+                    const room = parted.rooms.find((candidate) => candidate.anchor === asked.entry.authority);
+                    if (room === undefined && parted.next !== undefined) {
+                        unreached.push(asked);
+                        continue;
+                    }
+                    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 }),
+                    }));
                 }
-                answers.push(failure);
             }
+            open = unreached;
         }
-        return answers;
     }
     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 = gathered(bootstrapped);
+    const bootstrapTogether = gatheredEach(bootstrapped);
     const enumerateTogether = gathered(enumerated);
     async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
         const paths = batchPaths(changes);
@@ -200,16 +337,16 @@ 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')
             return { outcome: UNCERTAIN };
         const delivered = await transport.transfer({
             act: 'authored_batch_upload',
-            method: 'POST',
             url: grant.url,
-            answer: 'json',
             body: `${grant.operation}\n${delta}`,
         });
         if (delivered.status !== 200)
@@ -221,7 +358,30 @@ export function createAgentsHouseAdapter(options) {
         await keep(upload);
         return { body: { ...head, paths, upload, runtime: notifications.runtime } };
     }
-    async function submit(head, changes, delta, bytes, entry, handed, keep) {
+    async function staged(answer, batch) {
+        const refusal = doorRefusal(answer.body);
+        if (refusal?.code !== 'files_unstaged')
+            return null;
+        const grants = refusal.fields.upload;
+        if (!Array.isArray(grants))
+            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)
+                return false;
+            const delivered = await transport.transfer({
+                act: 'binary_stage',
+                url,
+                body: change.blob,
+                operation,
+            });
+            if (delivered.status !== 200)
+                return false;
+        }
+        return true;
+    }
+    async function submit(batch, 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)
@@ -229,14 +389,66 @@ export function createAgentsHouseAdapter(options) {
         if ('outcome' in prepared)
             return prepared.outcome;
         const answer = await transport.door(DOOR_BATCH, prepared.body);
-        return mutationOutcome(answer.status, answer.body, entry.locator, entry.handle);
+        const stagedFiles = await staged(answer, batch);
+        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)
+            return UNCERTAIN;
+        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 },
+            }));
+    }
+    function granted(answer, locator) {
+        const failure = classifyDoor(answer.status, answer.body, locator);
+        if (failure !== null) {
+            return failure.kind === 'scoped-refusal'
+                ? {
+                    kind: 'rejected',
+                    code: failure.code,
+                    fields: failure.fields,
+                    retryable: failure.retryable,
+                }
+                : failure;
+        }
+        const grant = parseGrant(answer.body);
+        const name = answer.body.name;
+        if (grant === null || grant.method !== 'GET' || typeof name !== 'string') {
+            return UNCERTAIN_READ;
+        }
+        return { kind: 'link', url: grant.url, name };
+    }
+    async function downloaded(answer, locator) {
+        const link = granted(answer, locator);
+        if (link.kind !== 'link')
+            return link;
+        const read = await transport.download(link.url);
+        if (read.status !== 200 || read.blob === null)
+            return UNCERTAIN_READ;
+        return { kind: 'binary', blob: read.blob };
+    }
+    function pathGrant(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 {
         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;
@@ -245,22 +457,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);
-            return mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document));
+            notifications.track([...tracked.values()]);
+            return {
+                ...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 };
-            if (request.pageToken !== undefined)
-                return { kind: 'transport-uncertainty' };
-            return bootstrapTogether(entry);
+            const asked = { entry, held: request.held };
+            if (request.pageToken !== undefined) {
+                return partPage(asked, JSON.parse(request.pageToken));
+            }
+            return bootstrapTogether(asked);
         },
         async refresh(_authorization, request) {
             const entry = authorityFor(request.locator);
@@ -280,17 +512,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 outcome = await submit(head, mapped.changes, delta, bytes, entry, handed, keep);
+            const answer = (upload) => submit(batch, 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(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);
@@ -307,6 +549,36 @@ export function createAgentsHouseAdapter(options) {
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
             });
         },
+        async binary(_authorization, request) {
+            if (request.kind === 'path') {
+                const asked = pathGrant(request);
+                if (asked === null)
+                    return { kind: 'room-not-readable', locator: request.locator };
+                return downloaded(await asked, 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);
+        },
+        async link(_authorization, request) {
+            const asked = pathGrant(request);
+            if (asked === null)
+                return { kind: 'room-not-readable', locator: request.locator };
+            return granted(await asked, request.locator);
+        },
+        referrerScope(referrer) {
+            const held = houseReferrer(referrer, tracked);
+            if (held === null)
+                return null;
+            const { path } = held.referrer;
+            return { locator: held.locator, ...(path === undefined ? {} : { path }) };
+        },
         reached(locator, version, target) {
             return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
         },
@@ -316,7 +588,16 @@ 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: notifications.observe,
+            published(locator, roomVersion) {
+                const at = logPosition(roomVersion);
+                if (at !== null)
+                    notifications.published(locator, at);
+            },
+        },
         conversations: notifications.conversations,
         serviceMode: notifications.serviceMode,
     };