@agentshouse/mdruntime-adapter 0.1.0-alpha.9 → 0.1.0-c9f1e531ad7c8

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,OAAO,EACP,aAAa,EAad,MAAM,wBAAwB,CAAC;AAqChC,OAAO,EAQL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAiBxB,MAAM,MAAM,yBAAyB,GACjC;IACE,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CACrC,GACD;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,CAAC;AA2BjC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAuQpF"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,OAAO,EACP,aAAa,EAad,MAAM,wBAAwB,CAAC;AA0ChC,OAAO,EASL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAuBxB,MAAM,MAAM,yBAAyB,GACjC;IACE,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CACrC,GACD;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAiCjC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAkZpF"}

package/dist/adapter.js

@@ -1,61 +1,91 @@
-import { DISCOVER_PREFIXES, PROVIDER_SELECTION_MODEL_ROOT, capabilities, discoveredRoom, locatorOf, mapDiscovery, parseDiscovery, providerSelection, trackedFrom } from './discovery.js';
-import { MODEL_ABSENT, failedModel, heldModel, modelKey, modelShelf } from './model.js';
+import { DISCOVER_PREFIXES, HOUSE_SCHEMA, capabilities, discoveredRoom, locatorOf, mapDiscovery, parseDiscovery, providerSelection, trackedFrom, } from './discovery.js';
+import { MODEL_ABSENT, failedModel, heldModel, modelKey, modelShelf, } from './model.js';
+import { gathered, selections } from './gather.js';
 import { createSiteAdapter } from './site.js';
-import { authorityRoot, bootstrapFrom, contentPrefixes, definitionsFrom, modelPrefix, parseEnumeration, parseEnvelope, parseGrant, refreshFrom } from './read.js';
+import { bootstrapOf, contentPrefixes, matchesScope, parseEnumeration, parseEnvelope, parseGrant, refreshFrom, schemaFrom, schemaPath, viewOf, } from './read.js';
+import { enumeratedLinks, scopeLinks, streamedLinks } from './links.js';
 import { houseAction } from './actions.js';
-import { classifyDoor, discoveryFailure } from './refusal.js';
+import { classifyDoor, discoveryFailure, doorRefusal } from './refusal.js';
 import { houseNotifications } from './stream.js';
-import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_REVISIONS, PRIVATE_AUTHORITY } from './transport.js';
-import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable } from './write.js';
-import { logPosition, presented } from './version.js';
-const UNCERTAIN = {
-    kind: 'transport-uncertainty'
-};
-const RESOLVED_OUTCOMES = new Set([
-    'accepted',
-    'conflicted',
-    'rejected',
-    'expired'
-]);
+import { DOOR_BATCH, DOOR_BATCH_UPLOAD, DOOR_BOOTSTRAP, DOOR_DISCOVER, DOOR_ENUMERATE, DOOR_REVISIONS, DOOR_SELECTION_MAX, PRIVATE_LOCATOR, } from './transport.js';
+import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
+import { logPosition, presented, reachedVersion, roomVersion, } from './version.js';
+const UNCERTAIN = { kind: 'transport-uncertainty' };
+const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
 function lapsedGrant(outcome) {
     return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
 }
 function modelFailure(classified, envelope) {
     if (classified === null) {
-        return envelope === null ? {
-            kind: 'transport-uncertainty'
-        } : MODEL_ABSENT;
+        return envelope === null ? { kind: 'transport-uncertainty' } : MODEL_ABSENT;
     }
     return failedModel(classified);
 }
 export function createAgentsHouseAdapter(options) {
-    if ('site' in options) return createSiteAdapter(options.site);
+    if ('site' in options)
+        return createSiteAdapter(options.site);
     const transport = options.transport;
     const notifications = houseNotifications(transport, 'credential');
     const tracked = new Map();
+    const handed = new Map();
     const models = modelShelf();
-    const submissions = new Map();
-    function held(envelope, entry, modelRoot, identity, failure) {
-        return heldModel(envelope === null ? null : definitionsFrom(envelope, entry, modelRoot), identity, failure);
+    function bootstrappedRoom(envelope, entry) {
+        const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
+        if (scope === undefined)
+            return { kind: 'room-not-readable', locator: entry.locator };
+        handed.set(entry.locator, scopeLinks(scope));
+        notifications.hold(entry.authority, scope);
+        return bootstrapOf(scope, entry);
+    }
+    function enumeratedRoom(enumeration, ask) {
+        const view = viewOf(enumeration, ask.entry);
+        if (view === undefined)
+            return { kind: 'room-not-readable', locator: ask.entry.locator };
+        notifications.hold(ask.entry.authority, view);
+        const answer = refreshFrom(view, ask.entry, ask.fromRoomVersion);
+        if (answer.kind === 'net-advancement') {
+            handed.set(ask.entry.locator, enumeratedLinks(view, handed.get(ask.entry.locator)));
+        }
+        return answer;
+    }
+    function streamed(entry, request, from) {
+        const links = handed.get(entry.locator);
+        if (links?.roomVersion !== request.fromRoomVersion)
+            return null;
+        const advanced = notifications.advance(entry, from, (path, revision) => links.revisions.get(path) === revision);
+        if (advanced === null)
+            return null;
+        if (request.minPosition !== undefined &&
+            !reachedVersion(advanced.page.roomVersion, request.minPosition, entry.logEpoch))
+            return null;
+        const relinked = streamedLinks(links, advanced);
+        if (relinked === null)
+            return null;
+        handed.set(entry.locator, relinked);
+        return advanced.page;
+    }
+    function held(envelope, entry, schema, failure) {
+        return heldModel(envelope === null ? null : schemaFrom(envelope, entry, schema), schemaPath(entry.handle, schema), failure);
+    }
+    function modelPrefixes(entry) {
+        return entry.schemas.map((schema) => schemaPath(entry.handle, schema));
     }
     async function acquireModels(entries) {
         const acquired = new Map();
-        const privateEntry = entries.find((entry)=>entry.authority === PRIVATE_AUTHORITY);
-        const prefixes = entries.map((entry)=>modelPrefix(entry, entry.modelRoot));
-        if (privateEntry !== undefined) {
-            prefixes.push(`${authorityRoot(undefined)}/${PROVIDER_SELECTION_MODEL_ROOT}`);
-        }
-        const answer = await transport.door(DOOR_BOOTSTRAP, {
-            prefixes
-        });
-        const classified = classifyDoor(answer.status, answer.body, PRIVATE_AUTHORITY);
-        const envelope = classified === null ? parseEnvelope(await bundled(answer.body)) : null;
-        const failure = modelFailure(classified, envelope);
-        for (const entry of entries){
-            acquired.set(modelKey(entry.locator, 'collection'), await held(envelope, entry, entry.modelRoot, `${authorityRoot(entry.handle)}/${entry.modelRoot}`, failure));
-        }
-        if (privateEntry !== undefined) {
-            acquired.set(modelKey(privateEntry.locator, 'typed-selection'), await held(envelope, privateEntry, PROVIDER_SELECTION_MODEL_ROOT, `${authorityRoot(undefined)}/${PROVIDER_SELECTION_MODEL_ROOT}`, failure));
+        for (const part of selections(entries, (entry) => modelPrefixes(entry).length, DOOR_SELECTION_MAX)) {
+            const privateEntry = part.find((entry) => entry.locator === PRIVATE_LOCATOR);
+            const answer = await transport.door(DOOR_BOOTSTRAP, {
+                prefixes: part.flatMap((entry) => modelPrefixes(entry)),
+            });
+            const classified = classifyDoor(answer.status, answer.body, PRIVATE_LOCATOR);
+            const envelope = classified === null ? parseEnvelope(await bundled(answer.body)) : null;
+            const failure = modelFailure(classified, envelope);
+            for (const entry of part) {
+                acquired.set(modelKey(entry.locator, 'collection'), await held(envelope, entry, entry.schema, failure));
+            }
+            if (privateEntry !== undefined) {
+                acquired.set(modelKey(privateEntry.locator, 'typed-selection'), await held(envelope, privateEntry, HOUSE_SCHEMA, failure));
+            }
         }
         return acquired;
     }
@@ -63,7 +93,7 @@ export function createAgentsHouseAdapter(options) {
         const locator = locatorOf(authority);
         const key = modelKey(locator, 'collection');
         const collection = models.retain(key, acquired.get(key));
-        if (authority.kind !== 'private') {
+        if (locator !== PRIVATE_LOCATOR) {
             return discoveredRoom(authority, collection?.identity ?? null, undefined);
         }
         const selection = models.retain(modelKey(locator, 'typed-selection'), acquired.get(modelKey(locator, 'typed-selection')));
@@ -72,214 +102,249 @@ export function createAgentsHouseAdapter(options) {
     function authorityFor(locator) {
         return tracked.get(locator);
     }
+    function withAt(result) {
+        if (result.kind !== 'action')
+            return result;
+        const body = result.result;
+        if (typeof body !== 'object' || body === null)
+            return result;
+        const { authority, position, log_epoch: logEpoch } = body;
+        if (typeof position !== 'string' || typeof logEpoch !== 'string')
+            return result;
+        const locator = authority === undefined
+            ? PRIVATE_LOCATOR
+            : [...tracked.values()].find((entry) => entry.authority === authority)?.locator;
+        if (locator === undefined)
+            return result;
+        return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
+    }
     async function bundled(body) {
         const grant = parseGrant(body);
-        if (grant === null) return body;
-        if (grant.method !== 'GET') return null;
+        if (grant === null)
+            return body;
+        if (grant.method !== 'GET')
+            return null;
         const answer = await transport.transfer({
-            act: 'working_copy_bundle',
+            act: 'local_copy_bundle',
             method: 'GET',
-            url: grant.url
+            url: grant.url,
+            answer: 'json',
         });
         return answer.status === 200 ? answer.body : null;
     }
-    async function uploaded(head, changes, delta, bytes, entry) {
+    function weight(entry) {
+        return contentPrefixes(entry).length;
+    }
+    async function bootstrapped(entries) {
+        const answers = [];
+        for (const part of selections(entries, weight, DOOR_SELECTION_MAX)) {
+            const answer = await transport.door(DOOR_BOOTSTRAP, {
+                prefixes: part.flatMap((entry) => contentPrefixes(entry)),
+            });
+            const classified = part.map((entry) => classifyDoor(answer.status, answer.body, entry.locator));
+            const envelope = classified[0] === null ? parseEnvelope(await bundled(answer.body)) : null;
+            part.forEach((entry, index) => {
+                const failure = classified[index];
+                if (failure === null || failure === undefined) {
+                    answers.push(envelope === null ? UNCERTAIN_READ : bootstrappedRoom(envelope, entry));
+                    return;
+                }
+                answers.push(failure.kind === 'beyond-horizon' ? UNCERTAIN_READ : failure);
+            });
+        }
+        return answers;
+    }
+    function layered(asks) {
+        const depths = new Map();
+        const layers = [];
+        for (const ask of asks) {
+            const depth = depths.get(ask.entry.authority) ?? 0;
+            depths.set(ask.entry.authority, depth + 1);
+            (layers[depth] ??= []).push(ask);
+        }
+        return layers;
+    }
+    async function enumerated(asks) {
+        const answers = new Map();
+        const parts = layered(asks).flatMap((layer) => selections(layer, (ask) => weight(ask.entry), DOOR_SELECTION_MAX));
+        for (const part of parts) {
+            let open = [...part];
+            while (open.length > 0) {
+                const answer = await transport.door(DOOR_ENUMERATE, {
+                    prefixes: open.flatMap((ask) => contentPrefixes(ask.entry)),
+                    positions: open.map((ask) => ({
+                        ...presented(ask.entry.authority, ask.from),
+                        ...(ask.minPosition === undefined ? {} : { min_position: ask.minPosition }),
+                    })),
+                });
+                const refusal = doorRefusal(answer.body);
+                if (refusal?.code === 'replica_behind') {
+                    const named = open.filter((ask) => ask.entry.authority === refusal.fields.authority);
+                    const behind = named.length === 0 ? open : named;
+                    for (const ask of behind)
+                        answers.set(ask, { kind: 'retryable-refusal', ...refusal });
+                    open = open.filter((ask) => !behind.includes(ask));
+                    continue;
+                }
+                const classified = open.map((ask) => classifyDoor(answer.status, answer.body, ask.entry.locator));
+                if (classified[0]?.kind === 'beyond-horizon') {
+                    const named = doorRefusal(answer.body)?.fields.authority;
+                    const expired = open.filter((ask) => ask.entry.authority === named);
+                    const answered = expired.length === 0 ? UNCERTAIN_READ : { kind: 'beyond-horizon' };
+                    const gone = expired.length === 0 ? open : expired;
+                    for (const ask of gone)
+                        answers.set(ask, answered);
+                    open = open.filter((ask) => !gone.includes(ask));
+                    continue;
+                }
+                const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
+                open.forEach((ask, index) => {
+                    const failure = classified[index];
+                    if (failure !== null && failure !== undefined) {
+                        answers.set(ask, failure);
+                        return;
+                    }
+                    answers.set(ask, enumeration === null ? UNCERTAIN_READ : enumeratedRoom(enumeration, ask));
+                });
+                open = [];
+            }
+        }
+        return asks.map((ask) => answers.get(ask) ?? UNCERTAIN_READ);
+    }
+    const bootstrapTogether = gathered(bootstrapped);
+    const enumerateTogether = gathered(enumerated);
+    async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
         const paths = batchPaths(changes);
         const sha256 = await deltaDigest(delta);
-        const retained = submissions.get(head.operation_id);
-        if (retained !== undefined && retained.sha256 === sha256 && retained.body.app_ref === head.app_ref && retained.body.release === head.release) return {
-            body: retained.body
-        };
-        const minted = await transport.door(DOOR_BATCH_UPLOAD, {
-            ...head,
-            paths,
-            bytes,
-            sha256
-        });
+        if (handed !== undefined && handed.sha256 === sha256) {
+            return { body: { ...head, paths, upload: handed } };
+        }
+        const minted = await transport.door(DOOR_BATCH_UPLOAD, { ...head, paths, bytes, sha256 });
         if (minted.status !== 200) {
-            return {
-                outcome: mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)
-            };
+            return { outcome: mutationOutcome(minted.status, minted.body, entry.locator, entry.handle) };
         }
         const grant = parseGrant(minted.body);
-        if (grant === null || grant.method !== 'POST') return {
-            outcome: UNCERTAIN
-        };
+        if (grant === null || grant.method !== 'POST')
+            return { outcome: UNCERTAIN };
         const delivered = await transport.transfer({
             act: 'authored_batch_upload',
             method: 'POST',
             url: grant.url,
-            body: `${grant.operation}\n${delta}`
+            answer: 'json',
+            body: `${grant.operation}\n${delta}`,
         });
-        if (delivered.status !== 200) return {
-            outcome: UNCERTAIN
-        };
+        if (delivered.status !== 200)
+            return { outcome: UNCERTAIN };
         const holding = parseGrant(delivered.body);
-        if (holding === null) return {
-            outcome: UNCERTAIN
-        };
-        const body = {
-            ...head,
-            paths,
-            upload: {
-                url: holding.url,
-                operation: holding.operation,
-                bytes,
-                sha256
-            }
-        };
-        submissions.set(head.operation_id, {
-            sha256,
-            body
-        });
-        return {
-            body
-        };
+        if (holding === null || holding.method !== 'POST')
+            return { outcome: UNCERTAIN };
+        const upload = { url: holding.url, operation: holding.operation, bytes, sha256 };
+        await keep(upload);
+        return { body: { ...head, paths, upload } };
     }
-    async function submit(head, changes, delta, bytes, entry) {
-        const prepared = uploadable(bytes) ? await uploaded(head, changes, delta, bytes, entry) : {
-            body: {
-                ...head,
-                changes
-            }
-        };
-        if ('outcome' in prepared) return prepared.outcome;
+    async function submit(head, changes, delta, bytes, entry, handed, keep) {
+        const prepared = uploadable(bytes)
+            ? await uploaded(head, changes, delta, bytes, entry, handed, keep)
+            : { body: { ...head, changes } };
+        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);
     }
     return {
-        async authorize () {
+        async authorize() {
             return options.authorize();
         },
-        async model (_authorization, request) {
+        async model(_authorization, request) {
             return models.answer(request);
         },
-        async discover (_authorization) {
-            const answer = await transport.door(DOOR_DISCOVER, {
-                prefixes: [
-                    ...DISCOVER_PREFIXES
-                ]
-            });
-            const classified = classifyDoor(answer.status, answer.body, PRIVATE_AUTHORITY);
-            if (classified !== null) return discoveryFailure(classified);
+        async discover(_authorization) {
+            const answer = await transport.door(DOOR_DISCOVER, { prefixes: [...DISCOVER_PREFIXES] });
+            const classified = classifyDoor(answer.status, answer.body, PRIVATE_LOCATOR);
+            if (classified !== null)
+                return discoveryFailure(classified);
             const document = parseDiscovery(answer.body);
-            if (document === null) return {
-                kind: 'transport-uncertainty'
-            };
+            if (document === null)
+                return { kind: 'transport-uncertainty' };
             const entries = trackedFrom(document);
             tracked.clear();
-            for (const entry of entries)tracked.set(entry.locator, entry);
+            for (const entry of entries)
+                tracked.set(entry.locator, entry);
+            for (const locator of handed.keys())
+                if (!tracked.has(locator))
+                    handed.delete(locator);
             notifications.track(entries);
             const acquired = await acquireModels(entries);
-            models.keep(entries.map((entry)=>entry.locator));
-            return mapDiscovery(document, document.authorities.map((authority)=>roomOf(authority, acquired)), capabilities());
+            models.keep(entries.map((entry) => entry.locator));
+            return mapDiscovery(document, document.authorities.map((authority) => roomOf(authority, acquired)), capabilities(document.actions));
         },
-        async bootstrap (_authorization, request) {
+        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'
-            };
-            const answer = await transport.door(DOOR_BOOTSTRAP, {
-                prefixes: [
-                    ...contentPrefixes(entry)
-                ]
-            });
-            const classified = classifyDoor(answer.status, answer.body, entry.locator);
-            if (classified !== null) {
-                return classified.kind === 'beyond-horizon' ? {
-                    kind: 'transport-uncertainty'
-                } : classified;
-            }
-            const envelope = parseEnvelope(await bundled(answer.body));
-            if (envelope === null) return {
-                kind: 'transport-uncertainty'
-            };
-            return bootstrapFrom(envelope, entry);
+            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) {
+        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'
-            };
+            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 streamed = notifications.advance(entry, from);
-            if (streamed !== null) return streamed;
-            const answer = await transport.door(DOOR_ENUMERATE, {
-                prefixes: [
-                    ...contentPrefixes(entry)
-                ],
-                positions: [
-                    presented(entry.authority, from)
-                ]
+            if (from === null)
+                return { kind: 'beyond-horizon' };
+            const answered = streamed(entry, request, from);
+            if (answered !== null)
+                return answered;
+            const minPosition = request.minPosition === undefined ? null : logPosition(request.minPosition);
+            return enumerateTogether({
+                entry,
+                from,
+                fromRoomVersion: request.fromRoomVersion,
+                ...(minPosition?.logEpoch === from.logEpoch ? { minPosition: minPosition.position } : {}),
             });
-            const classified = classifyDoor(answer.status, answer.body, entry.locator);
-            if (classified !== null) return classified;
-            const enumeration = parseEnumeration(answer.body, 'credential');
-            if (enumeration === null) return {
-                kind: 'transport-uncertainty'
-            };
-            return refreshFrom(enumeration, entry, request.fromRoomVersion);
         },
-        async mutate (_authorization, request) {
+        async mutate(_authorization, request, keep) {
             const entry = authorityFor(request.locator);
-            if (entry === undefined) return {
-                kind: 'room-not-readable',
-                locator: request.locator
-            };
+            if (entry === undefined)
+                return { kind: 'room-not-readable', locator: request.locator };
             const mapped = houseChanges(request.changeBatch, entry.handle);
-            if (mapped.kind === 'unmapped') return rejectedMapping(mapped);
+            if (mapped.kind === 'unmapped')
+                return rejectedMapping(mapped);
             const head = operationHead(request.changeBatch);
             const delta = deltaBody(mapped.changes);
             const bytes = deltaBytes(delta);
-            const resent = submissions.has(head.operation_id);
-            let outcome = await submit(head, mapped.changes, delta, bytes, entry);
-            if (resent && lapsedGrant(outcome)) {
-                submissions.delete(head.operation_id);
-                outcome = await submit(head, mapped.changes, delta, bytes, entry);
-            }
-            if (RESOLVED_OUTCOMES.has(outcome.kind)) submissions.delete(head.operation_id);
-            return outcome;
+            const handed = request.upload;
+            const outcome = await submit(head, mapped.changes, delta, bytes, entry, handed, keep);
+            if (handed === undefined || !lapsedGrant(outcome))
+                return outcome;
+            return submit(head, mapped.changes, delta, bytes, entry, undefined, keep);
         },
-        async history (_authorization, request) {
+        async history(_authorization, request) {
             const entry = authorityFor(request.locator);
-            if (entry === undefined) return {
-                kind: 'room-not-readable',
-                locator: request.locator
-            };
+            if (entry === undefined)
+                return { kind: 'room-not-readable', locator: request.locator };
             const answer = await transport.door(DOOR_REVISIONS, revisionBody({
                 path: request.path,
                 handle: entry.handle,
-                ...request.revision === undefined ? {} : {
-                    revision: request.revision
-                },
-                ...request.pageToken === undefined ? {} : {
-                    pageToken: request.pageToken
-                }
+                ...(request.revision === undefined ? {} : { revision: request.revision }),
+                ...(request.pageToken === undefined ? {} : { pageToken: request.pageToken }),
             }));
             return historyOutcome(answer.status, answer.body, entry.locator, {
                 path: request.path,
-                ...request.revision === undefined ? {} : {
-                    revision: request.revision
-                }
+                ...(request.revision === undefined ? {} : { revision: request.revision }),
             });
         },
-        async action (_authorization, request) {
-            return houseAction(transport, request);
+        reached(locator, version, target) {
+            return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
+        },
+        async action(_authorization, request) {
+            return withAt(await houseAction(transport, request));
         },
         roomVersions: notifications,
-        conversations: notifications.conversations
+        conversations: notifications.conversations,
+        serviceMode: notifications.serviceMode,
     };
 }
-
-//# sourceMappingURL=adapter.js.map

package/dist/digest.js

@@ -3,9 +3,5 @@ export function textBytes(value) {
 }
 export async function sha256Hex(value) {
     const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
-    return [
-        ...new Uint8Array(digest)
-    ].map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+    return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, '0')).join('');
 }
-
-//# sourceMappingURL=digest.js.map

package/dist/discovery.d.ts

@@ -7,10 +7,14 @@ export declare const PROVIDER_ACTIONS = "provider-actions";
 export declare const MOVE_REFERENCE_REWRITES = "move-reference-rewrites";
 export declare const DISCOVER_PREFIXES: readonly string[];
 export declare const PROVIDER_SELECTION_ROOTS: readonly string[];
-export declare const PROVIDER_SELECTION_MODEL_ROOT = "house/settings/model";
+export declare const UNTYPED_FOLDERS: readonly string[];
+export declare const RESERVED_NAMES: readonly string[];
+export declare const HOUSE_SCHEMA = "house/schema.yaml";
+export declare const PRIVATE_HANDLE = "private";
 export type HouseBounds = {
     max_authored_file_bytes: number;
     max_batch_operations: number;
+    max_batch_documents: number;
     max_path_length: number;
     max_path_depth: number;
     max_mount_files: number;
@@ -25,12 +29,10 @@ export type HouseOperations = {
     delete: readonly string[];
 };
 export type HouseAuthority = LogPosition & {
-    kind: 'room' | 'private';
     roomRef: string;
-    roomHandle: string | null;
+    roomHandle: string;
     name: string;
-    collectionRoot: string;
-    modelRoot: string;
+    schema: string;
     managedReplication: 'admitted' | 'unavailable';
     protectedPaths: readonly string[];
     operations: HouseOperations;
@@ -39,24 +41,27 @@ export type HouseDiscoveryDocument = {
     bounds: HouseBounds;
     mdModelVersion: string;
     authorities: readonly HouseAuthority[];
+    actions: readonly string[];
 };
 export type TrackedAuthority = LogPosition & {
     locator: string;
     authority: string;
-    handle: string | undefined;
-    collectionRoot: string;
-    modelRoot: string;
-    modelRoots: readonly string[];
+    handle: string;
+    schema: string;
+    schemas: readonly string[];
+};
+export type HouseSiteEntry = {
+    roomRef: string;
+    segment: string;
 };
 export type HouseSiteSlot = {
     slot: string;
-    roomRef: string | null;
+    entries: readonly HouseSiteEntry[];
 };
 export type HouseSiteAuthority = LogPosition & {
     roomRef: string;
     roomHandle: string;
-    collectionRoot: string;
-    modelRoot: string;
+    schema: string;
 };
 export type HouseSiteDiscovery = {
     bounds: HouseBounds;
@@ -64,18 +69,15 @@ export type HouseSiteDiscovery = {
     slots: readonly HouseSiteSlot[];
     authorities: readonly HouseSiteAuthority[];
 };
-export type SiteTracked = TrackedAuthority & {
-    slot: string;
-};
 export declare function parseDiscovery(body: unknown): HouseDiscoveryDocument | null;
 export declare function parseSiteDiscovery(body: unknown): HouseSiteDiscovery | null;
-export declare function siteLocator(slot: string, roomRef: string): string;
-export declare function siteTracked(document: HouseSiteDiscovery): SiteTracked[];
+export declare function siteTracked(document: HouseSiteDiscovery): TrackedAuthority[];
+export declare function siteSlots(document: HouseSiteDiscovery): Discovery['slots'];
 export declare function locatorOf(authority: HouseAuthority): string;
 export declare function trackedFrom(document: HouseDiscoveryDocument): TrackedAuthority[];
 export declare function providerLimits(bounds: HouseBounds): readonly ProviderLimit[];
 export declare function declaredRetention(bounds: HouseBounds): Retention;
-export declare function capabilities(): readonly Capability[];
+export declare function capabilities(actions: readonly string[]): readonly Capability[];
 export declare function siteCapabilities(): readonly Capability[];
 export declare function providerSelection(attachedModel: TypedSelection['attachedModel']): TypedSelection;
 export declare function discoveredRoom(authority: HouseAuthority, attachedModel: DiscoveredRoom['attachedModel'], typedSelection: TypedSelection | undefined): DiscoveredRoom;