@agentshouse/mdruntime-adapter 0.1.0-ca80960fd750d → 0.1.0-ca9b5ec924eff

package/dist/adapter.js

@@ -1,210 +1,123 @@
 import { stepped } from '@agentshouse/mdruntime';
-import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
-import { manifestedModels, partModels, streamedModels, viewModels } from './model.js';
-import { gathered, gatheredEach, selections } from './gather.js';
+import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
 import { createSiteAdapter } from './site.js';
-import { authorityRoot, bootstrapping, emptyScope, housePart, manifested, parseEnumeration, parseFileAddress, parseGrant, parseParted, partInventory, refreshFrom, viewOf, wholeView, } from './read.js';
-import { PART_ATTEMPTS, partArrival, partFrame, unverifiedPart } from './part.js';
-import { sha256Hex } from './digest.js';
+import { parseFileAddress, parseGrant } from './read.js';
+import { chunkedHead, chunkLister, chunkPart } from './chunks.js';
+import { spaceSchemas } from './space-schema.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 { houseAction, HOUSE_UNKEPT_READS } from './actions.js';
+import { houseSearch } from './search.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_ROOM_TYPES } from './room-types.js';
-import { followsVersion, logPosition, presented, reachedVersion, roomVersion, } from './version.js';
+import { HOUSE_TYPED_PATHS } from './house-model.js';
+import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.js';
+import { followsVersion, 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';
 }
-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, options.snapshot === true);
     const transport = options.transport;
-    const notifications = houseNotifications(transport, 'credential');
+    const spaces = spaceSchemas();
+    const notifications = houseNotifications(transport, 'credential', {
+        opened: async (frame) => (frame === null ? null : opened(frame)),
+        changed,
+        expired: (authorities) => lister.askAll(authorities.flatMap((authority) => [...tracked.values()].filter((entry) => entry.authority === authority))),
+    }, spaces);
     const tracked = new Map();
-    const handed = new Map();
-    let heldRevisions;
+    const lister = chunkLister(transport, () => declared().max_prefixes);
+    const chunked = new Map();
+    const renewals = new WeakMap();
     let bounds;
     function declared() {
         if (bounds === undefined)
             throw new Error('no Discovery declared the bounds');
         return bounds;
     }
-    async function fetchedPart(entry, continued, listed, received, arriving) {
-        if (received !== undefined) {
-            const kept = new Uint8Array(received);
-            const held = await housePart(continued.room, kept, listed, 'credential');
-            if (held !== null)
-                return 'kind' in held ? held : { scope: held, frame: kept };
-        }
-        for (let attempt = 0; attempt < PART_ATTEMPTS; attempt += 1) {
-            const answered = await transport.door(DOOR_BOOTSTRAP, {
-                prefixes: [authorityRoot(entry.handle)],
-                part: listed.part,
-                ...(continued.held === undefined ? {} : { held: [continued.held] }),
-            }, partArrival(listed, arriving));
-            const failure = classifyRead(answered.status, answered.body, entry.locator);
-            if (failure !== null)
-                return failure;
-            const frame = partFrame(answered.body);
-            if (frame === null)
-                continue;
-            const scope = await housePart(continued.room, frame, listed, 'credential');
-            if (scope !== null)
-                return 'kind' in scope ? scope : { scope, frame };
-        }
-        return unverifiedPart(entry.locator);
-    }
-    async function manifestPage(asked, continued) {
-        const inventory = partInventory(continued.room);
-        if (inventory.parts === 0) {
-            const page = await partPage(asked, continued, undefined, undefined);
-            return page.kind === 'bootstrap' ? { ...page, inventory } : page;
-        }
-        const { models, seen } = await manifestedModels(continued.room, asked.entry);
-        return manifested(continued.room, inventory, JSON.stringify({ ...continued, seen }), models);
-    }
-    async function partPage(asked, continued, received, arriving) {
-        const { entry } = asked;
-        const listed = continued.room.parts[continued.next];
-        const sent = listed === undefined
-            ? { scope: emptyScope(continued.room), frame: null }
-            : await fetchedPart(entry, continued, listed, received, arriving);
-        if ('kind' in sent)
-            return sent;
-        const scope = await reused(sent.scope, asked.held);
-        if (scope === null) {
-            return asked.held === undefined
-                ? UNCERTAIN_READ
-                : 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,
-            ...entry.schemas.filter((schema) => scope.files.some((file) => file.path === schema)),
-        ];
-        const models = await partModels(scope, entry, new Set(seen), !more);
+    function opened(frame) {
+        const document = parseDiscovery(frame);
+        if (document === null)
+            return null;
+        bounds = document.bounds;
+        tracked.clear();
+        lister.forget();
+        for (const entry of trackedFrom(document))
+            tracked.set(entry.locator, entry);
+        notifications.track([...tracked.values()]);
         return {
-            ...(await stepped(bootstrapping(scope))),
-            ...(models === undefined ? {} : { models }),
-            ...(more ? { pageToken: JSON.stringify({ ...continued, next, seen }) } : {}),
-            ...(sent.frame === null ? {} : { received: sent.frame }),
+            ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
+            member: document.member,
         };
     }
-    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 });
+    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 enumeratedRoom(enumeration, ask) {
-        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 = await refreshFrom(view, ask.fromRoomVersion);
-        if (answer.kind !== 'net-advancement')
-            return answer;
-        handed.set(ask.entry.locator, roomVersion(view));
-        const models = await viewModels(view, ask.entry);
-        return models === undefined ? answer : { ...answer, models };
+    async function listedRoom(entry) {
+        const listed = await lister.list(entry);
+        if ('kind' in listed)
+            return listed;
+        const head = await chunkedHead(listed, entry, spaces);
+        if (head.kind === 'bootstrap')
+            chunked.set(entry.locator, listed);
+        return head;
     }
-    async function streamed(entry, request, from) {
-        if (handed.get(entry.locator) !== request.fromRoomVersion)
+    async function chunkRead(entry, id) {
+        const room = chunked.get(entry.locator);
+        const address = room?.chunks.get(id);
+        if (room === undefined || address === undefined)
             return null;
-        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)
+        const read = await transport.download(address.url);
+        if (read.status !== EXPIRED_ADDRESS)
+            return { room, read };
+        const renewed = await renewal(entry, room);
+        if ('kind' in renewed || !renewed.chunks.has(id))
             return null;
-        handed.set(entry.locator, advanced.page.roomVersion);
-        const models = await streamedModels(advanced.schemas, entry, 'credential');
-        return models === undefined ? advanced.page : { ...advanced.page, models };
+        chunked.set(entry.locator, renewed);
+        return { room: renewed, read: await transport.download(renewed.chunks.get(id).url) };
     }
-    function held(rooms) {
-        const kept = rooms.flatMap((room) => {
-            const entry = tracked.get(room.locator);
-            const at = logPosition(room.roomVersion);
-            if (entry === undefined || at === null)
-                return [];
-            handed.set(room.locator, room.roomVersion);
-            notifications.reach(entry.authority, at);
-            return [presented(entry.authority, at)];
-        });
-        notifications.send(kept);
+    function renewal(entry, stale) {
+        const held = renewals.get(stale);
+        if (held !== undefined)
+            return held;
+        const renewed = lister.renew(entry, [...chunked.keys()].flatMap((locator) => tracked.get(locator) ?? []));
+        renewals.set(stale, renewed);
+        return renewed;
     }
-    async function adoptedMove(entry, into, outcome) {
-        if (outcome.kind === 'accepted' && outcome.destination !== undefined) {
-            await adopted(into, { kind: 'accepted', ...outcome.destination });
+    function hold(rooms) {
+        for (const room of rooms) {
+            const listed = chunked.get(room.locator);
+            if (listed !== undefined &&
+                room.roomVersion !== null &&
+                reachedVersion(room.roomVersion, roomVersion(listed), listed.logEpoch))
+                chunked.delete(room.locator);
         }
-        return adopted(entry, outcome);
+        notifications.send(rooms);
     }
-    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, outcome.roomVersion);
-        if (follows)
-            handed.set(entry.locator, outcome.roomVersion);
-        const at = logPosition(outcome.roomVersion);
-        if (follows && at !== null)
-            notifications.reach(entry.authority, at);
-        return outcome;
+    async function chunkPage(entry, id, arriving) {
+        const fetched = await chunkRead(entry, id);
+        if (fetched === null || fetched.read.status !== 200)
+            return UNCERTAIN_READ;
+        return chunkPart(fetched.read.body, fetched.room, id, arriving);
     }
     function authorityFor(locator) {
         return tracked.get(locator);
@@ -223,116 +136,18 @@ export function createAgentsHouseAdapter(options) {
             return result;
         return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
     }
-    async function holding(asks) {
-        const bound = Math.floor(declared().max_held_files / Math.max(1, asks.filter((ask) => ask.held !== undefined).length));
-        const held = [];
-        for (const ask of asks) {
-            if (ask.held === undefined || bound === 0)
-                continue;
-            const files = await heldFiles(ask.entry.authority, ask.held, bound);
-            if (files !== null)
-                held.push(files);
-        }
-        return held;
-    }
-    async function bootstrapped(asks, answer) {
-        let open = asks.map((asked, ask) => ({ entry: asked.entry, asked, ask }));
-        while (open.length > 0) {
-            const unreached = [];
-            for (const part of selections(open, 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 manifestPage(asked.asked, {
-                        room,
-                        next: 0,
-                        seen: [],
-                        ...(kept === undefined ? {} : { held: kept }),
-                    }));
-                }
-            }
-            open = unreached;
-        }
-    }
-    function layered(asks) {
-        const depths = new Map();
-        const layers = [];
-        for (const ask of asks) {
-            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 = [];
-        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.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));
-                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[ask.index] = answered;
-                    open = open.filter((ask) => !gone.includes(ask));
-                    continue;
-                }
-                const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
-                for (const [answerIndex, { ask, index }] of open.entries()) {
-                    const failure = classified[answerIndex];
-                    if (failure !== null && failure !== undefined) {
-                        answers[index] = failure;
-                        continue;
-                    }
-                    answers[index] =
-                        enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask);
-                }
-                open = [];
-            }
-        }
-        return answers;
-    }
-    const bootstrapTogether = gatheredEach(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, runtime: notifications.runtime } };
         }
-        const minted = await transport.door(DOOR_BATCH_UPLOAD, { ...head, paths, bytes, sha256 });
+        const minted = await transport.door(houseDoorRoute('files/batch-upload'), {
+            ...head,
+            paths,
+            bytes,
+            sha256,
+        });
         if (minted.status !== 200) {
             return {
                 outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
@@ -380,11 +195,13 @@ export function createAgentsHouseAdapter(options) {
             : { body: inline };
         if ('outcome' in prepared)
             return prepared.outcome;
-        const answer = await transport.door(DOOR_BATCH, prepared.body);
+        const answer = await transport.door(houseDoorRoute('files/batch'), prepared.body);
         const stagedFiles = await staged(answer, request);
         if (stagedFiles === false)
             return UNCERTAIN;
-        const settled = stagedFiles === null ? answer : await transport.door(DOOR_BATCH, prepared.body);
+        const settled = stagedFiles === null
+            ? answer
+            : await transport.door(houseDoorRoute('files/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
@@ -412,9 +229,22 @@ export function createAgentsHouseAdapter(options) {
     function linked(answer, locator) {
         const address = addressed(answer, locator);
         return address.kind === 'address'
-            ? { kind: 'link', url: address.url, name: address.name }
+            ? { 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')
@@ -439,7 +269,7 @@ export function createAgentsHouseAdapter(options) {
         const entry = authorityFor(request.locator);
         if (entry === undefined)
             return null;
-        return () => transport.door(DOOR_FILES_GET, {
+        return () => transport.door(houseDoorRoute('files/read'), {
             room_ref: entry.authority,
             path: request.path,
             revision: request.revision,
@@ -447,72 +277,19 @@ export function createAgentsHouseAdapter(options) {
     }
     return {
         roomTypes: HOUSE_ROOM_TYPES,
+        nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
+        typedPaths: HOUSE_TYPED_PATHS,
+        unkeptReads: HOUSE_UNKEPT_READS,
         async authorize() {
             return options.authorize();
         },
-        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;
-            const document = parseDiscovery(answer.body);
-            if (document === null)
-                return { kind: 'transport-uncertainty' };
-            bounds = document.bounds;
-            const entries = trackedFrom(document);
-            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([...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 };
-            const asked = { entry, held: request.held };
-            if (request.pageToken !== undefined) {
-                return partPage(asked, JSON.parse(request.pageToken), request.received, request.arriving);
-            }
-            return bootstrapTogether(asked);
-        },
-        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 = await streamed(entry, request, from);
-            if (answered !== null)
-                return answered;
-            return enumerateTogether({ entry, from, fromRoomVersion: request.fromRoomVersion });
+            return request.pageToken === undefined
+                ? listedRoom(entry)
+                : chunkPage(entry, request.pageToken, request.arriving);
         },
         async mutate(_authorization, request, keep) {
             const entry = authorityFor(request.locator);
@@ -529,22 +306,21 @@ export function createAgentsHouseAdapter(options) {
                 : houseMove(batch, entry.handle, into.handle);
             if (mapped.kind === 'unmapped')
                 return rejectedMapping(mapped);
-            const head = operationHead(batch);
+            const head = operationHead(batch, entry.authority);
             const delta = deltaBody(mapped.changes);
             const bytes = deltaBytes(delta);
             const handed = request.upload;
             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 settle(outcome);
-            return settle(await answer(undefined));
+                return outcome;
+            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('files/revisions/list'), revisionBody({
                 path: request.path,
                 handle: entry.handle,
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
@@ -567,6 +343,35 @@ export function createAgentsHouseAdapter(options) {
                 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);
         },
@@ -576,18 +381,12 @@ export function createAgentsHouseAdapter(options) {
         async action(_authorization, request) {
             return withAt(await houseAction(transport, request));
         },
+        search(_authorization, request) {
+            return houseSearch(transport, [...tracked.values()], request);
+        },
         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);
-            },
+            hold,
+            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})$`);