@agentshouse/mdruntime-adapter 0.1.0-cae3b43168023 → 0.1.0-cb0bbc4ccacd0

package/dist/adapter.js

@@ -1,21 +1,23 @@
 import { stepped } from '@agentshouse/mdruntime';
-import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
-import { partModels, streamedModels, viewModels } from './model.js';
-import { gathered, gatheredEach, selections } from './gather.js';
+import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
 import { createSiteAdapter } from './site.js';
-import { authorityRoot, bootstrapping, emptyScope, housePart, parseEnumeration, parseFileAddress, parseGrant, parseParted, refreshFrom, viewOf, wholeView, } from './read.js';
-import { PART_ATTEMPTS, unverifiedPart } from './part.js';
+import { authorityRoot, bootstrapping, parseFileAddress, parseGrant, } from './read.js';
+import { roomStreams } from './room-stream.js';
+import { spaceSchemas } from './space-schema.js';
 import { sha256Hex } from './digest.js';
+import { finishedUpload, houseUpload } from './upload.js';
 import { houseAction } from './actions.js';
-import { classifyDoor, classifyRead, discoveryFailure, doorRefusal } from './refusal.js';
-import { houseNotifications } from './stream.js';
-import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_FILES_GET, DOOR_REVISIONS, } from './transport.js';
+import { 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 { houseReferrer, houseReferrerScope } from './referrer.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, 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';
@@ -50,142 +52,86 @@ 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,
+    }, spaces);
     const tracked = new Map();
-    const handed = new Map();
-    let heldRevisions;
+    const rooms = roomStreams('credential', spaces);
+    const unreused = new Set();
     let bounds;
     function declared() {
         if (bounds === undefined)
             throw new Error('no Discovery declared the bounds');
         return bounds;
     }
-    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);
+    function opened(frame) {
+        const document = parseDiscovery(frame);
+        if (document === null)
+            return null;
+        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,
+        };
     }
-    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);
+    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 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) {
-            return asked.held === undefined
-                ? UNCERTAIN_READ
-                : bootstrapTogether({ entry, held: undefined });
+            unreused.add(entry.locator);
+            return UNCERTAIN_READ;
         }
-        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);
         return {
             ...(await stepped(bootstrapping(scope))),
-            ...(models === undefined ? {} : { models }),
-            ...(more ? { pageToken: JSON.stringify({ ...continued, next, seen }) } : {}),
+            ...(part.models === undefined ? {} : { models: part.models }),
+            ...(part.pageToken === undefined ? {} : { pageToken: part.pageToken }),
+            bytes: part.bytes,
         };
     }
-    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 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 streamed(entry, request, from) {
-        if (handed.get(entry.locator) !== request.fromRoomVersion)
-            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)
-            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 };
+    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'), {
+            room_ref: entry.authority,
+            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) {
-        const kept = rooms.flatMap((room) => {
+        notifications.send(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);
-    }
-    async function adoptedMove(entry, into, outcome) {
-        if (outcome.kind === 'accepted' && outcome.destination !== undefined) {
-            await adopted(into, { kind: 'accepted', ...outcome.destination });
-        }
-        return adopted(entry, outcome);
-    }
-    async function adopted(entry, outcome) {
-        if (outcome.kind !== 'accepted')
-            return outcome;
-        const held = handed.get(entry.locator);
-        if (held === undefined)
-            return outcome;
-        const follows = followsVersion(held, 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;
+            return entry === undefined || at === null ? [] : [presented(entry.authority, at)];
+        }));
     }
     function authorityFor(locator) {
         return tracked.get(locator);
@@ -204,116 +150,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 partPage(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('batch-upload'), {
+            ...head,
+            paths,
+            bytes,
+            sha256,
+        });
         if (minted.status !== 200) {
             return {
                 outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
@@ -340,21 +188,16 @@ export function createAgentsHouseAdapter(options) {
         const refusal = doorRefusal(answer.body);
         if (refusal?.code !== 'files_unstaged')
             return null;
-        const grants = refusal.fields.upload;
-        if (!Array.isArray(grants))
+        const uploads = refusal.fields.upload;
+        if (!Array.isArray(uploads))
             return false;
-        for (const grant of grants) {
-            const { url, operation, sha256 } = grant;
-            const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === sha256);
-            if (typeof url !== 'string' || typeof operation !== 'string' || change === undefined)
+        for (const named of uploads) {
+            const upload = houseUpload(named);
+            const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === named.sha256);
+            if (upload === null || change === undefined)
                 return false;
-            const delivered = await transport.transfer({
-                act: 'binary_stage',
-                url,
-                body: await file(change.localId),
-                operation,
-            });
-            if (delivered.status !== 200)
+            const finished = await finishedUpload(transport, upload, await file(change.localId));
+            if (finished?.body?.staged !== true)
                 return false;
         }
         return true;
@@ -366,11 +209,11 @@ 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('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('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
@@ -398,9 +241,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')
@@ -425,7 +281,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/get'), {
             room_ref: entry.authority,
             path: request.path,
             revision: request.revision,
@@ -433,72 +289,18 @@ export function createAgentsHouseAdapter(options) {
     }
     return {
         roomTypes: HOUSE_ROOM_TYPES,
+        nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
+        typedPaths: HOUSE_TYPED_PATHS,
         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));
-            }
-            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
+                ? openedRoom(entry, request)
+                : streamedPage(entry, request.pageToken, request.held);
         },
         async mutate(_authorization, request, keep) {
             const entry = authorityFor(request.locator);
@@ -515,22 +317,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('revisions'), revisionBody({
                 path: request.path,
                 handle: entry.handle,
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
@@ -542,17 +343,10 @@ export function createAgentsHouseAdapter(options) {
             });
         },
         async binary(_authorization, request) {
-            if (request.kind === 'path') {
-                const ask = pathAddress(request);
-                if (ask === null)
-                    return { kind: 'room-not-readable', locator: request.locator };
-                return downloaded(ask, request.locator);
-            }
-            const referrer = houseReferrer(request.referrer, tracked);
-            if (referrer === null) {
-                return { kind: 'rejected', code: 'referrer_unknown', fields: {}, retryable: false };
-            }
-            return downloaded(() => transport.door(DOOR_FILES_GET, { file: request.fileRef, referrer: referrer.referrer }), referrer.locator);
+            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);
@@ -560,8 +354,34 @@ export function createAgentsHouseAdapter(options) {
                 return { kind: 'room-not-readable', locator: request.locator };
             return linked(await ask(), request.locator);
         },
-        referrerScope(referrer) {
-            return houseReferrerScope(referrer, tracked);
+        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);
@@ -572,18 +392,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);
-            },
+            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)}]`;