@agentshouse/mdruntime-adapter 0.1.0-cf6a7cf003c4b → 0.1.0-cf863e7a50d6e

package/dist/adapter.js

@@ -1,108 +1,133 @@
-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 { 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, viewOf, } from './read.js';
-import { acceptedLinks, enumeratedLinks, heldLinks, 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, classifyRead, discoveryFailure, doorRefusal } from './refusal.js';
-import { houseNotifications } from './stream.js';
-import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_REVISIONS, } from './transport.js';
-import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
-import { followsVersion, 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';
 }
+async function heldFiles(authority, held, bound) {
+    const listed = await held.files(null, bound + 1);
+    const files = listed.slice(0, bound);
+    const through = listed.length > bound ? (files.at(-1)?.path ?? null) : null;
+    return files.length === 0 ? null : { room: authority, through, files };
+}
+async function reused(scope, held) {
+    const sent = new Set(scope.contents.map((entry) => entry.path));
+    const contents = [...scope.contents];
+    const asked = scope.files.filter((file) => file.binary === undefined && !sent.has(file.path));
+    if (asked.length === 0)
+        return scope;
+    if (held === undefined)
+        return null;
+    const kept = await held.contents(asked.map(({ path }) => path));
+    for (const file of asked) {
+        const found = kept.get(file.path);
+        if (found === undefined ||
+            found.revision !== file.revision ||
+            (await sha256Hex(found.content)) !== file.sha256) {
+            return null;
+        }
+        contents.push({ path: file.path, content: found.content });
+    }
+    return { ...scope, contents };
+}
 export function createAgentsHouseAdapter(options) {
     if ('site' in options)
-        return createSiteAdapter(options.site);
+        return createSiteAdapter(options.site, options.snapshot === true);
     const transport = options.transport;
-    const notifications = houseNotifications(transport, 'credential');
+    const notifications = houseNotifications(transport, 'credential', {
+        opened: async (frame) => (frame === null ? null : opened(frame)),
+        changed,
+    });
     const tracked = new Map();
-    const handed = new Map();
+    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;
     }
-    async function bootstrappedRoom(envelope, scope, entry, continued) {
-        if (scope === undefined)
-            return { kind: 'room-not-readable', locator: entry.locator };
-        const next = envelope.next?.room === entry.authority ? envelope.next.path : null;
-        if (continued === null && next === null)
-            handed.set(entry.locator, scopeLinks(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), next === null);
-        const continuation = next === null ? null : { after: next, seen };
+    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 {
-            ...bootstrapOf(scope),
-            ...(models === undefined ? {} : { models }),
-            ...(continuation === null ? {} : { pageToken: JSON.stringify(continuation) }),
+            ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
+            member: document.member,
         };
     }
-    async function enumeratedRoom(enumeration, ask) {
-        const view = viewOf(enumeration, ask.entry);
-        if (view === undefined)
-            return { kind: 'room-not-readable', locator: ask.entry.locator };
-        notifications.reach(ask.entry.authority, view);
-        const answer = refreshFrom(view, ask.fromRoomVersion);
-        if (answer.kind !== 'net-advancement')
-            return answer;
-        handed.set(ask.entry.locator, enumeratedLinks(view, handed.get(ask.entry.locator)));
-        const models = await viewModels(view, ask.entry);
-        return models === undefined ? answer : { ...answer, models };
-    }
-    async function streamed(entry, request, from) {
-        const links = handed.get(entry.locator);
-        if (links?.roomVersion !== request.fromRoomVersion)
-            return null;
-        const advanced = notifications.advance(entry, from, (path, revision) => links.revisions.get(path) === revision);
-        if (advanced === null)
+    function changed(frame) {
+        const change = parseAuthorityChange(frame);
+        if (change === null)
             return null;
-        const relinked = streamedLinks(links, advanced);
-        if (relinked === null)
-            return null;
-        handed.set(entry.locator, relinked);
-        const models = await streamedModels(advanced.schemas, entry, 'credential');
-        return models === undefined ? advanced.page : { ...advanced.page, models };
+        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) {
+            unreused.add(entry.locator);
+            return UNCERTAIN_READ;
+        }
+        return {
+            ...(await stepped(bootstrapping(scope))),
+            ...(part.models === undefined ? {} : { models: part.models }),
+            ...(part.pageToken === undefined ? {} : { pageToken: part.pageToken }),
+            bytes: part.bytes,
+        };
+    }
+    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, heldLinks(room));
-            notifications.reach(entry.authority, at);
-            return [presented(entry.authority, at)];
-        });
-        notifications.send(kept);
-    }
-    function adopted(entry, outcome) {
-        if (outcome.kind !== 'accepted')
-            return outcome;
-        const { originals, ...accepted } = outcome;
-        const links = handed.get(entry.locator);
-        if (links === undefined)
-            return accepted;
-        const follows = followsVersion(links.roomVersion, accepted.roomVersion);
-        const relinked = acceptedLinks(links, accepted, follows ? accepted.roomVersion : links.roomVersion, originals);
-        handed.set(entry.locator, relinked.links);
-        const at = logPosition(accepted.roomVersion);
-        if (follows && at !== null)
-            notifications.reach(entry.authority, at);
-        return relinked.attachments === undefined
-            ? accepted
-            : { ...accepted, attachments: relinked.attachments };
+            return entry === undefined || at === null ? [] : [presented(entry.authority, at)];
+        }));
     }
     function authorityFor(locator) {
         return tracked.get(locator);
@@ -121,114 +146,25 @@ export function createAgentsHouseAdapter(options) {
             return result;
         return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
     }
-    function weight(entry) {
-        return contentPrefixes(entry).length;
-    }
-    async function bootstrapped(entries, answer) {
-        let open = entries.map((entry, ask) => ({ entry, ask }));
-        while (open.length > 0) {
-            const unreached = [];
-            for (const part of selections(open, ({ entry }) => weight(entry), declared().max_prefixes)) {
-                const answered = await transport.door(DOOR_BOOTSTRAP, {
-                    prefixes: part.flatMap(({ entry }) => contentPrefixes(entry)),
-                });
-                const classified = part.map(({ entry }) => classifyDoor(answered.status, answered.body, entry.locator));
-                const envelope = classified[0] === null ? parseEnvelope(answered.body) : null;
-                for (const [index, asked] of part.entries()) {
-                    const failure = classified[index];
-                    if (failure !== null && failure !== undefined) {
-                        answer(asked.ask, failure);
-                        continue;
-                    }
-                    if (envelope === null) {
-                        answer(asked.ask, UNCERTAIN_READ);
-                        continue;
-                    }
-                    const scope = envelope.scopes.find((candidate) => matchesScope(candidate, asked.entry));
-                    if (scope === undefined && envelope.next !== undefined) {
-                        unreached.push(asked);
-                        continue;
-                    }
-                    answer(asked.ask, await bootstrappedRoom(envelope, scope, asked.entry, null));
-                }
-            }
-            open = unreached;
-        }
-    }
-    async function continuedBootstrap(entry, continued) {
-        const after = { room: entry.authority, path: continued.after };
-        const answered = await transport.door(DOOR_BOOTSTRAP, {
-            prefixes: contentPrefixes(entry),
-            after,
-        });
-        const failure = classifyDoor(answered.status, answered.body, entry.locator);
-        if (failure !== null)
-            return failure;
-        const envelope = parseEnvelope(answered.body);
-        if (envelope === null)
-            return UNCERTAIN_READ;
-        const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
-        return bootstrappedRoom(envelope, scope, entry, continued);
-    }
-    function layered(asks) {
-        const depths = new Map();
-        const layers = [];
-        for (const ask of asks) {
-            const depth = depths.get(ask.entry.authority) ?? 0;
-            depths.set(ask.entry.authority, depth + 1);
-            (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)),
-                });
-                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.set(ask, answered);
-                    open = open.filter((ask) => !gone.includes(ask));
-                    continue;
-                }
-                const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
-                for (const [index, ask] of open.entries()) {
-                    const failure = classified[index];
-                    if (failure !== null && failure !== undefined) {
-                        answers.set(ask, failure);
-                        continue;
-                    }
-                    answers.set(ask, enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask));
-                }
-                open = [];
-            }
-        }
-        return asks.map((ask) => answers.get(ask) ?? UNCERTAIN_READ);
-    }
-    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: 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',
@@ -238,92 +174,159 @@ export function createAgentsHouseAdapter(options) {
         if (delivered.status !== 200)
             return { outcome: UNCERTAIN };
         const holding = parseGrant(delivered.body);
-        if (holding === null || holding.method !== 'POST')
+        if (holding === null)
             return { outcome: UNCERTAIN };
         const upload = { url: holding.url, operation: holding.operation, bytes, sha256 };
         await keep(upload);
         return { body: { ...head, paths, upload, runtime: notifications.runtime } };
     }
-    async function submit(head, changes, delta, bytes, entry, handed, keep) {
+    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 discover(_authorization) {
-            const answer = await transport.door(DOOR_DISCOVER, { prefixes: [...DISCOVER_PREFIXES] });
-            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);
-            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);
-            return {
-                ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document)),
-                member: document.member,
-            };
-        },
         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 continuedBootstrap(entry, JSON.parse(request.pageToken));
-            }
-            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 = 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);
             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, entry.authority);
             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 adopted(entry, outcome);
-            return adopted(entry, await submit(head, mapped.changes, delta, bytes, entry, undefined, keep));
+                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 }),
@@ -334,6 +337,47 @@ 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);
         },
@@ -343,7 +387,10 @@ export function createAgentsHouseAdapter(options) {
         async action(_authorization, request) {
             return withAt(await houseAction(transport, request));
         },
-        roomStream: { hold: held, reopen: notifications.reopen, observe: notifications.observe },
+        roomStream: {
+            hold: held,
+            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)}]`;