@agentshouse/mdruntime-adapter 0.1.0-cacce09fc82c6 → 0.1.0-cad35e1fe3a03

package/dist/adapter.js

@@ -1,96 +1,123 @@
-import { DISCOVER_PREFIXES, capabilities, discoveredRoom, mapDiscovery, parseDiscovery, trackedFrom, } from './discovery.js';
-import { scopeModels, streamedModels, viewModels } from './model.js';
-import { gathered, selections } from './gather.js';
+import { 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 { 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_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 { 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_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';
 }
 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 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();
+    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 bootstrappedRoom(envelope, entry) {
-        const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
-        if (scope === undefined)
-            return { kind: 'room-not-readable', locator: entry.locator };
-        handed.set(entry.locator, scopeLinks(scope));
-        notifications.reach(entry.authority, scope);
-        const models = await scopeModels(scope, entry);
-        return { ...bootstrapOf(scope), ...(models === undefined ? {} : { models }) };
-    }
-    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 };
+    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 {
+            ...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
+            member: document.member,
+        };
     }
-    async function streamed(entry, request, from) {
-        const links = handed.get(entry.locator);
-        if (links?.roomVersion !== request.fromRoomVersion)
+    function changed(frame) {
+        const change = parseAuthorityChange(frame);
+        if (change === null)
             return null;
-        const advanced = notifications.advance(entry, from, (path, revision) => links.revisions.get(path) === revision);
-        if (advanced === 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 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 chunkRead(entry, id) {
+        const room = chunked.get(entry.locator);
+        const address = room?.chunks.get(id);
+        if (room === undefined || address === undefined)
             return null;
-        const relinked = streamedLinks(links, advanced);
-        if (relinked === 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, relinked);
-        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, heldLinks(room));
-            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;
+    }
+    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);
+        }
+        notifications.send(rooms);
     }
-    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 };
+    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);
@@ -109,197 +136,190 @@ export function createAgentsHouseAdapter(options) {
             return result;
         return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
     }
-    async function bundled(body) {
-        const grant = parseGrant(body);
-        if (grant === null)
-            return body;
-        if (grant.method !== 'GET')
-            return null;
-        const answer = await transport.transfer({
-            act: 'local_copy_bundle',
-            method: 'GET',
-            url: grant.url,
-            answer: 'json',
-        });
-        return answer.status === 200 ? answer.body : null;
-    }
-    function weight(entry) {
-        return contentPrefixes(entry).length;
-    }
-    async function bootstrapped(entries) {
-        const answers = [];
-        for (const part of selections(entries, weight, declared().max_prefixes)) {
-            const answer = await transport.door(DOOR_BOOTSTRAP, {
-                prefixes: part.flatMap((entry) => contentPrefixes(entry)),
-            });
-            const classified = part.map((entry) => classifyDoor(answer.status, answer.body, entry.locator));
-            const envelope = classified[0] === null ? parseEnvelope(await bundled(answer.body)) : null;
-            for (const [index, entry] of part.entries()) {
-                const failure = classified[index];
-                if (failure === null || failure === undefined) {
-                    answers.push(envelope === null ? UNCERTAIN_READ : await bootstrappedRoom(envelope, entry));
-                    continue;
-                }
-                answers.push(failure);
-            }
-        }
-        return answers;
-    }
-    function layered(asks) {
-        const depths = new Map();
-        const layers = [];
-        for (const ask of asks) {
-            const depth = depths.get(ask.entry.authority) ?? 0;
-            depths.set(ask.entry.authority, depth + 1);
-            (layers[depth] ??= []).push(ask);
-        }
-        return layers;
-    }
-    async function enumerated(asks) {
-        const answers = new Map();
-        const parts = layered(asks).flatMap((layer) => selections(layer, (ask) => weight(ask.entry), declared().max_prefixes));
-        for (const part of parts) {
-            let open = [...part];
-            while (open.length > 0) {
-                const answer = await transport.door(DOOR_ENUMERATE, {
-                    prefixes: open.flatMap((ask) => contentPrefixes(ask.entry)),
-                    positions: open.map((ask) => presented(ask.entry.authority, ask.from)),
-                });
-                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 = gathered(bootstrapped);
-    const enumerateTogether = gathered(enumerated);
     async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
         const paths = batchPaths(changes);
         const sha256 = await deltaDigest(delta);
         if (handed !== undefined && handed.sha256 === sha256) {
             return { body: { ...head, paths, upload: handed, 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: mutationOutcome(minted.status, minted.body, entry.locator, entry.handle) };
+            return {
+                outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
+            };
         }
         const grant = parseGrant(minted.body);
-        if (grant === null || grant.method !== 'POST')
+        if (grant === null)
             return { outcome: UNCERTAIN };
         const delivered = await transport.transfer({
             act: 'authored_batch_upload',
-            method: 'POST',
             url: grant.url,
-            answer: 'json',
             body: `${grant.operation}\n${delta}`,
         });
         if (delivered.status !== 200)
             return { outcome: UNCERTAIN };
         const holding = parseGrant(delivered.body);
-        if (holding === null || holding.method !== 'POST')
+        if (holding === null)
             return { outcome: UNCERTAIN };
         const upload = { url: holding.url, operation: holding.operation, bytes, sha256 };
         await keep(upload);
         return { body: { ...head, paths, upload, 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('files/batch'), prepared.body);
+        const stagedFiles = await staged(answer, request);
+        if (stagedFiles === false)
+            return UNCERTAIN;
+        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
+            ? 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/read'), {
+            room_ref: entry.authority,
+            path: request.path,
+            revision: request.revision,
+        });
     }
     return {
+        roomTypes: HOUSE_ROOM_TYPES,
+        nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
+        typedPaths: HOUSE_TYPED_PATHS,
         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 { kind: 'transport-uncertainty' };
-            return bootstrapTogether(entry);
-        },
-        async refresh(_authorization, request) {
-            const entry = authorityFor(request.locator);
-            if (entry === undefined)
-                return { kind: 'room-not-readable', locator: request.locator };
-            if (request.pageToken !== undefined)
-                return { kind: 'transport-uncertainty' };
-            const from = logPosition(request.fromRoomVersion);
-            if (from === null)
-                return { kind: 'beyond-horizon' };
-            const answered = 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);
             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('files/revisions/list'), revisionBody({
                 path: request.path,
                 handle: entry.handle,
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
@@ -310,6 +330,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);
         },
@@ -319,7 +380,13 @@ export function createAgentsHouseAdapter(options) {
         async action(_authorization, request) {
             return withAt(await houseAction(transport, request));
         },
-        roomStream: { hold: held, reopen: notifications.reopen, observe: notifications.observe },
+        search(_authorization, request) {
+            return houseSearch(transport, [...tracked.values()], request);
+        },
+        roomStream: {
+            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})$`);

package/dist/chunks.d.ts

@@ -0,0 +1,38 @@
+import { type AdapterFailure, type BootstrapPart, type BootstrapResult } from '@agentshouse/mdruntime';
+import type { TrackedAuthority } from './discovery.js';
+import { type HouseModels, type HouseScope } from './read.js';
+import type { SpaceSchemas } from './space-schema.js';
+import { type HouseDoor, type HouseMode } from './transport.js';
+import { type LogPosition } from './version.js';
+export type ChunkAddress = {
+    readonly url: string;
+    readonly bytes: number;
+};
+export type ChunkedRoom = LogPosition & {
+    readonly anchor: string;
+    readonly mode: HouseMode;
+    readonly chunks: ReadonlyMap<string, ChunkAddress>;
+    readonly parts: readonly BootstrapPart[];
+    readonly names: ReadonlyMap<string, string>;
+    readonly models: HouseModels;
+};
+export type Listed = ChunkedRoom | {
+    readonly kind: 'not-ready';
+} | AdapterFailure;
+type Answered = {
+    readonly status: number;
+    readonly body: unknown;
+};
+export declare function partId(logEpoch: string, hash: string): string;
+export declare function siteChunkList(answer: Answered, locator: string): Listed;
+export declare function chunkedHead(listed: ChunkedRoom, entry: TrackedAuthority, spaces: SpaceSchemas): Promise<BootstrapResult>;
+export declare function chunkPart(body: ReadableStream<Uint8Array> | null, room: ChunkedRoom, id: string, arriving: ((bytes: number) => void) | undefined): Promise<BootstrapResult>;
+export declare function chunkLister(transport: HouseDoor, most: () => number): {
+    askAll: (entries: readonly TrackedAuthority[]) => void;
+    list: (entry: TrackedAuthority) => Promise<Listed>;
+    renew(entry: TrackedAuthority, installing: readonly TrackedAuthority[]): Promise<Listed>;
+    forget(): void;
+};
+export declare function chunkScope(body: ReadableStream<Uint8Array>, room: ChunkedRoom, arriving: ((bytes: number) => void) | undefined): Promise<HouseScope | null>;
+export {};
+//# sourceMappingURL=chunks.d.ts.map

package/dist/chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunks.d.ts","sourceRoot":"","sources":["../src/chunks.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAML,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAkB,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChF,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3E,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG,cAAc,CAAC;AAEnF,KAAK,QAAQ,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAoCpE,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D;AA4BD,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIvE;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,eAAe,CAAC,CAuB1B;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,EACvC,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,GAC9C,OAAO,CAAC,eAAe,CAAC,CAM1B;AAgBD,wBAAgB,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,MAAM;sBAwCzC,SAAS,gBAAgB,EAAE;kBAU/B,gBAAgB,KAAG,OAAO,CAAC,MAAM,CAAC;iBASxC,gBAAgB,cAAc,SAAS,gBAAgB,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;;EAc3F;AAuCD,wBAAsB,UAAU,CAC9B,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,EAChC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,GAC9C,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAgC5B"}