@agentshouse/mdruntime-adapter 0.1.0-cc63dd043d0e2 → 0.1.0-cc7da2d4669a3

package/dist/adapter.js

@@ -1,107 +1,132 @@
-import { DISCOVER_PREFIXES, capabilities, discoveredRoom, locatorOf, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
-import { MODEL_ABSENT, failedModel, heldModel, modelKey, modelShelf, } from './model.js';
-import { gathered, selections } from './gather.js';
+import { stepped } from '@agentshouse/mdruntime';
+import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
 import { createSiteAdapter } from './site.js';
-import { bootstrapOf, contentPrefixes, matchesScope, parseEnumeration, parseEnvelope, parseGrant, refreshFrom, schemaFrom, schemaPath, viewOf, } from './read.js';
-import { enumeratedLinks, scopeLinks, streamedLinks } from './links.js';
+import { authorityRoot, bootstrapping, parseFileAddress, parseGrant, } from './read.js';
+import { roomStreams } from './room-stream.js';
+import { sha256Hex } from './digest.js';
+import { finishedUpload, houseUpload } from './upload.js';
 import { houseAction } from './actions.js';
-import { classifyDoor, discoveryFailure, doorRefusal } from './refusal.js';
-import { houseNotifications } from './stream.js';
-import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_REVISIONS, PRIVATE_LOCATOR, } from './transport.js';
-import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
-import { logPosition, presented, reachedVersion, roomVersion, } from './version.js';
+import { classifyDoor, doorRefusal } from './refusal.js';
+import { houseNotifications, } from './stream.js';
+import { houseDoorRoute, } from './transport.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 OCTET_STREAM = 'application/octet-stream';
+const EXPIRED_ADDRESS = 403;
 function lapsedGrant(outcome) {
     return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
 }
-function modelFailure(classified, envelope) {
-    if (classified === null) {
-        return envelope === null ? { kind: 'transport-uncertainty' } : MODEL_ABSENT;
+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 failedModel(classified);
+    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 notifications = houseNotifications(transport, 'credential', {
+        opened: async (frame) => (frame === null ? null : opened(frame)),
+        changed,
+    });
     const tracked = new Map();
-    const handed = new Map();
-    const models = modelShelf();
+    const rooms = roomStreams('credential');
+    const unreused = new Set();
     let bounds;
     function declared() {
         if (bounds === undefined)
             throw new Error('no Discovery declared the bounds');
         return bounds;
     }
-    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));
-        notifications.hold(entry.authority, scope);
-        return bootstrapOf(scope);
-    }
-    function enumeratedRoom(enumeration, ask) {
-        const view = viewOf(enumeration, ask.entry);
-        if (view === undefined)
-            return { kind: 'room-not-readable', locator: ask.entry.locator };
-        notifications.hold(ask.entry.authority, view);
-        const answer = refreshFrom(view, ask.fromRoomVersion);
-        if (answer.kind === 'net-advancement') {
-            handed.set(ask.entry.locator, enumeratedLinks(view, handed.get(ask.entry.locator)));
-        }
-        return answer;
-    }
-    function streamed(entry, request, from) {
-        const links = handed.get(entry.locator);
-        if (links?.roomVersion !== request.fromRoomVersion)
-            return null;
-        const advanced = notifications.advance(entry, from, (path, revision) => links.revisions.get(path) === revision);
-        if (advanced === null)
-            return null;
-        if (request.minPosition !== undefined &&
-            !reachedVersion(advanced.page.roomVersion, request.minPosition, entry.logEpoch))
-            return null;
-        const relinked = streamedLinks(links, advanced);
-        if (relinked === null)
+    function opened(frame) {
+        const document = parseDiscovery(frame);
+        if (document === null)
             return null;
-        handed.set(entry.locator, relinked);
-        return advanced.page;
+        bounds = document.bounds;
+        tracked.clear();
+        for (const entry of trackedFrom(document))
+            tracked.set(entry.locator, entry);
+        notifications.track([...tracked.values()]);
+        return {
+            ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
+            member: document.member,
+        };
     }
-    function held(envelope, entry, schema, failure) {
-        return heldModel(envelope === null ? null : schemaFrom(envelope, entry, schema), schemaPath(entry.handle, schema), failure);
-    }
-    function modelPrefixes(entry) {
-        return entry.schemas.map((schema) => schemaPath(entry.handle, schema));
+    function changed(frame) {
+        const change = parseAuthorityChange(frame);
+        if (change === null)
+            return null;
+        for (const locator of change.left)
+            tracked.delete(locator);
+        for (const entry of trackedFrom(change))
+            tracked.set(entry.locator, entry);
+        notifications.track([...tracked.values()]);
+        return {
+            kind: 'authority-changed',
+            rooms: change.authorities.map((authority) => discoveredRoom(authority)),
+            left: change.left,
+            member: change.member,
+        };
     }
-    async function acquireModels(entries) {
-        const acquired = new Map();
-        for (const part of selections(entries, (entry) => modelPrefixes(entry).length, declared().max_prefixes)) {
-            const answer = await transport.door(DOOR_BOOTSTRAP, {
-                prefixes: part.flatMap((entry) => modelPrefixes(entry)),
-            });
-            const classified = classifyDoor(answer.status, answer.body, PRIVATE_LOCATOR);
-            const envelope = classified === null ? parseEnvelope(await bundled(answer.body)) : null;
-            const failure = modelFailure(classified, envelope);
-            for (const entry of part) {
-                acquired.set(modelKey(entry.locator, 'collection'), await held(envelope, entry, entry.schema, failure));
-                if (entry.houseModel === null)
-                    continue;
-                acquired.set(modelKey(entry.locator, 'typed-selection'), await held(envelope, entry, entry.houseModel.root, failure));
-            }
+    async function streamedPage(entry, token, held) {
+        const part = await rooms.part(entry, token);
+        if ('kind' in part)
+            return part;
+        const scope = await reused(part.scope, held);
+        if (scope === null) {
+            unreused.add(entry.locator);
+            return UNCERTAIN_READ;
         }
-        return acquired;
+        return {
+            ...(await stepped(bootstrapping(scope))),
+            ...(part.models === undefined ? {} : { models: part.models }),
+            ...(part.pageToken === undefined ? {} : { pageToken: part.pageToken }),
+            bytes: part.bytes,
+        };
     }
-    function roomOf(authority, acquired) {
-        const locator = locatorOf(authority);
-        const key = modelKey(locator, 'collection');
-        const collection = models.retain(key, acquired.get(key));
-        const selection = authority.houseModel === null
-            ? undefined
-            : models.retain(modelKey(locator, 'typed-selection'), acquired.get(modelKey(locator, 'typed-selection')));
-        return discoveredRoom(authority, collection?.identity ?? null, selection?.identity ?? null);
+    async function openedRoom(entry, request) {
+        const reusing = unreused.delete(entry.locator) ? undefined : request.held;
+        const files = reusing === undefined
+            ? null
+            : await heldFiles(entry.authority, reusing, declared().max_held_files);
+        const answered = await transport.streamed(houseDoorRoute('bootstrap'), {
+            prefixes: [authorityRoot(entry.handle)],
+            ...(files === null ? {} : { held: [files] }),
+        }, request.signal ?? new AbortController().signal);
+        if (answered.room === null)
+            return classifyDoor(answered.status, answered.body, entry.locator) ?? UNCERTAIN_READ;
+        return rooms.head(entry, answered.room, request.arriving, request.signal);
+    }
+    function held(rooms) {
+        notifications.send(rooms.flatMap((room) => {
+            const entry = tracked.get(room.locator);
+            const at = logPosition(room.roomVersion);
+            return entry === undefined || at === null ? [] : [presented(entry.authority, at)];
+        }));
     }
     function authorityFor(locator) {
         return tracked.get(locator);
@@ -115,227 +140,192 @@ export function createAgentsHouseAdapter(options) {
         const { authority, position, log_epoch: logEpoch } = body;
         if (typeof position !== 'string' || typeof logEpoch !== 'string')
             return result;
-        const locator = authority === undefined
-            ? PRIVATE_LOCATOR
-            : [...tracked.values()].find((entry) => entry.authority === authority)?.locator;
+        const locator = [...tracked.values()].find((entry) => entry.authority === authority)?.locator;
         if (locator === undefined)
             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 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;
-            part.forEach((entry, index) => {
-                const failure = classified[index];
-                if (failure === null || failure === undefined) {
-                    answers.push(envelope === null ? UNCERTAIN_READ : bootstrappedRoom(envelope, entry));
-                    return;
-                }
-                answers.push(failure.kind === 'beyond-horizon' ? UNCERTAIN_READ : failure);
-            });
-        }
-        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);
-            (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));
-        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),
-                        ...(ask.minPosition === undefined ? {} : { min_position: ask.minPosition }),
-                    })),
-                });
-                const refusal = doorRefusal(answer.body);
-                if (refusal?.code === 'replica_behind') {
-                    const named = open.filter((ask) => ask.entry.authority === refusal.fields.authority);
-                    const behind = named.length === 0 ? open : named;
-                    for (const ask of behind) {
-                        answers.set(ask, refusal.retryable
-                            ? { kind: 'retryable-refusal', code: refusal.code, fields: refusal.fields }
-                            : (classifyDoor(answer.status, answer.body, ask.entry.locator) ?? UNCERTAIN_READ));
-                    }
-                    open = open.filter((ask) => !behind.includes(ask));
-                    continue;
-                }
-                const classified = open.map((ask) => classifyDoor(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 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);
-                    open = open.filter((ask) => !gone.includes(ask));
-                    continue;
-                }
-                const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
-                open.forEach((ask, index) => {
-                    const failure = classified[index];
-                    if (failure !== null && failure !== undefined) {
-                        answers.set(ask, failure);
-                        return;
-                    }
-                    answers.set(ask, enumeration === null ? UNCERTAIN_READ : enumeratedRoom(enumeration, ask));
-                });
-                open = [];
-            }
-        }
-        return asks.map((ask) => answers.get(ask) ?? UNCERTAIN_READ);
-    }
-    const bootstrapTogether = gathered(bootstrapped);
-    const enumerateTogether = gathered(enumerated);
     async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
         const paths = batchPaths(changes);
         const sha256 = await deltaDigest(delta);
         if (handed !== undefined && handed.sha256 === sha256) {
-            return { body: { ...head, paths, upload: handed } };
+            return { body: { ...head, paths, upload: handed, runtime: notifications.runtime } };
         }
-        const minted = await transport.door(DOOR_BATCH_UPLOAD, { ...head, paths, bytes, sha256 });
+        const minted = await transport.door(houseDoorRoute('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',
-            method: 'POST',
             url: grant.url,
-            answer: 'json',
             body: `${grant.operation}\n${delta}`,
         });
         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 } };
+        return { body: { ...head, paths, upload, runtime: notifications.runtime } };
     }
-    async function submit(head, changes, delta, bytes, entry, handed, keep) {
-        const inline = { ...head, changes };
+    async function staged(answer, { changeBatch: batch, file }) {
+        const refusal = doorRefusal(answer.body);
+        if (refusal?.code !== 'files_unstaged')
+            return null;
+        const uploads = refusal.fields.upload;
+        if (!Array.isArray(uploads))
+            return false;
+        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 finished = await finishedUpload(transport, upload, await file(change.localId));
+            if (finished?.body?.staged !== true)
+                return false;
+        }
+        return true;
+    }
+    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)
             : { body: inline };
         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 answer = await transport.door(houseDoorRoute('batch'), prepared.body);
+        const stagedFiles = await staged(answer, request);
+        if (stagedFiles === false)
+            return UNCERTAIN;
+        const settled = stagedFiles === null ? answer : await transport.door(houseDoorRoute('batch'), prepared.body);
+        if (stagedFiles === true && (await staged(settled, request)) !== 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 addressed(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 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, mediaType: address.mediaType }
+            : address;
+    }
+    function refusedAttach(answer, locator) {
+        const failure = classifyDoor(answer.status, answer.body, locator);
+        if (failure === null)
+            return null;
+        return failure.kind === 'scoped-refusal'
+            ? {
+                kind: 'rejected',
+                code: failure.code,
+                fields: failure.fields,
+                retryable: failure.retryable,
+            }
+            : failure;
+    }
+    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',
+            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(houseDoorRoute('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 model(_authorization, request) {
-            return models.answer(request);
-        },
-        async discover(_authorization) {
-            const answer = await transport.door(DOOR_DISCOVER, { prefixes: [...DISCOVER_PREFIXES] });
-            const classified = classifyDoor(answer.status, answer.body, PRIVATE_LOCATOR);
-            if (classified !== null)
-                return discoveryFailure(classified);
-            const document = parseDiscovery(answer.body);
-            if (document === null)
-                return { kind: 'transport-uncertainty' };
-            bounds = document.bounds;
-            const entries = trackedFrom(document);
-            tracked.clear();
-            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);
-            const acquired = await acquireModels(entries);
-            models.keep(entries.map((entry) => entry.locator));
-            return mapDiscovery(document, document.authorities.map((authority) => roomOf(authority, acquired)), capabilities(document.actions));
-        },
         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);
-        },
-        async refresh(_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' };
-            const from = logPosition(request.fromRoomVersion);
-            if (from === null)
-                return { kind: 'beyond-horizon' };
-            const answered = streamed(entry, request, from);
-            if (answered !== null)
-                return answered;
-            const minPosition = request.minPosition === undefined ? null : logPosition(request.minPosition);
-            return enumerateTogether({
-                entry,
-                from,
-                fromRoomVersion: request.fromRoomVersion,
-                ...(minPosition?.logEpoch === from.logEpoch ? { minPosition: minPosition.position } : {}),
-            });
+            return request.pageToken === undefined
+                ? openedRoom(entry, request)
+                : streamedPage(entry, request.pageToken, request.held);
         },
         async mutate(_authorization, request, keep) {
             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(request, head, mapped.changes, delta, bytes, entry, upload, keep, into);
+            const outcome = await answer(handed);
             if (handed === undefined || !lapsedGrant(outcome))
                 return outcome;
-            return submit(head, mapped.changes, delta, bytes, entry, undefined, keep);
+            return answer(undefined);
         },
         async history(_authorization, request) {
             const entry = authorityFor(request.locator);
             if (entry === undefined)
                 return { kind: 'room-not-readable', locator: request.locator };
-            const answer = await transport.door(DOOR_REVISIONS, revisionBody({
+            const answer = await transport.door(houseDoorRoute('revisions'), revisionBody({
                 path: request.path,
                 handle: entry.handle,
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
@@ -346,13 +336,60 @@ export function createAgentsHouseAdapter(options) {
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
             });
         },
+        async binary(_authorization, request) {
+            const ask = pathAddress(request);
+            if (ask === null)
+                return { kind: 'room-not-readable', locator: request.locator };
+            return downloaded(ask, request.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);
+        },
+        async attach(_authorization, request) {
+            const entry = authorityFor(request.locator);
+            if (entry === undefined)
+                return { kind: 'room-not-readable', locator: request.locator };
+            const declared = await transport.door(houseDoorRoute('files/attach'), {
+                room_ref: entry.authority,
+                name: request.name,
+                bytes: request.byteLength,
+                sha256: request.sha256,
+                media_type: request.mediaType.length > 0 ? request.mediaType : OCTET_STREAM,
+            });
+            const refused = refusedAttach(declared, request.locator);
+            if (refused !== null)
+                return refused;
+            const upload = houseUpload(declared.body?.upload);
+            if (upload === null)
+                return UNCERTAIN_READ;
+            const finished = await finishedUpload(transport, upload, request.blob);
+            if (finished === null)
+                return UNCERTAIN_READ;
+            const unfinished = refusedAttach(finished, request.locator);
+            if (unfinished !== null)
+                return unfinished;
+            const { path, revision } = (finished.body ?? {});
+            const root = `/rooms/${entry.handle}/`;
+            return typeof path === 'string' && path.startsWith(root) && typeof revision === 'string'
+                ? { kind: 'attached', path: path.slice(root.length), revision }
+                : UNCERTAIN_READ;
+        },
         reached(locator, version, target) {
             return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
         },
+        follows(_locator, version, next) {
+            return followsVersion(version, next);
+        },
         async action(_authorization, request) {
             return withAt(await houseAction(transport, request));
         },
-        roomVersions: notifications,
+        roomStream: {
+            hold: held,
+            observe: notifications.observe,
+        },
         conversations: notifications.conversations,
         serviceMode: notifications.serviceMode,
     };

package/dist/app-reference.d.ts

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

package/dist/app-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-reference.d.ts","sourceRoot":"","sources":["../src/app-reference.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,QAEjC,CAAC"}

package/dist/app-reference.js

@@ -0,0 +1,2 @@
+import { CROCKFORD_CHARACTER } from './crockford.js';
+export const APP_REFERENCE_PATTERN = new RegExp(`^a_(${CROCKFORD_CHARACTER}+)\\.(${CROCKFORD_CHARACTER})$`);

package/dist/crockford.d.ts

@@ -0,0 +1,4 @@
+export declare const CROCKFORD_ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
+export declare const CROCKFORD_CHARACTER = "[0123456789abcdefghjkmnpqrstvwxyz]";
+export declare const CROCKFORD_LEADING_CHARACTER: string;
+//# sourceMappingURL=crockford.d.ts.map

package/dist/crockford.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crockford.d.ts","sourceRoot":"","sources":["../src/crockford.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,qCAAqC,CAAC;AAErE,eAAO,MAAM,mBAAmB,uCAA4B,CAAC;AAE7D,eAAO,MAAM,2BAA2B,QAAqC,CAAC"}

package/dist/crockford.js

@@ -0,0 +1,3 @@
+export const CROCKFORD_ALPHABET = '0123456789abcdefghjkmnpqrstvwxyz';
+export const CROCKFORD_CHARACTER = `[${CROCKFORD_ALPHABET}]`;
+export const CROCKFORD_LEADING_CHARACTER = `[${CROCKFORD_ALPHABET.slice(1)}]`;