@agentshouse/mdruntime-adapter 0.1.0-cdcec0737ac0e → 0.1.0-cdd3671d36a47

package/README.md

@@ -25,7 +25,7 @@ host.attach(port, 'my-app');
 
 App code never imports this package; it reaches the Runtime only through the
 client its host hands it. The rules an App's agent follows are the `apps/` pages
-of House's Guide, which House's `open_guide` opens.
+of House's Guide, which House's `guide/open` opens.
 
 ## License
 

package/dist/actions.d.ts

@@ -1,6 +1,8 @@
 import type { ActionDeclaration, ActionRequest, ActionResult } from '@agentshouse/mdruntime';
 import type { HouseDoorAnswer, HouseTransport } from './transport.js';
 export type HouseActDoor = Pick<HouseTransport, 'door'>;
+export declare const HOUSE_UNKEPT_READS: readonly string[];
+export declare const HOUSE_LEADING_READS: readonly string[];
 export declare function declaredActions(routes: readonly string[]): readonly ActionDeclaration[];
 export declare function houseAction(transport: HouseActDoor, request: ActionRequest): Promise<ActionResult>;
 export declare function actionOutcome(answer: HouseDoorAnswer, name: string, input: unknown): ActionResult;

package/dist/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE7F,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AAExD,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,iBAAiB,EAAE,CAEvF;AAED,wBAAgB,WAAW,CACzB,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,YAAY,CAAC,CAIvB;AAwBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,YAAY,CAUjG"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE7F,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AAExD,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAG/C,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAKhD,CAAC;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,iBAAiB,EAAE,CAEvF;AAED,wBAAgB,WAAW,CACzB,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,YAAY,CAAC,CAIvB;AAwBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,YAAY,CAajG"}

package/dist/actions.js

@@ -1,4 +1,14 @@
-import { doorRefusal } from './refusal.js';
+import { doorRefusal, resetOf } from './refusal.js';
+export const HOUSE_UNKEPT_READS = [
+    'account/security/read',
+    'clients/last-use/list',
+];
+export const HOUSE_LEADING_READS = [
+    'rooms/list',
+    'apps/list',
+    'sites/list',
+    'rooms/members/list',
+];
 export function declaredActions(routes) {
     return routes.map((name) => ({ name, inputShape: {}, resultKind: 'house', room: 'room_ref' }));
 }
@@ -35,8 +45,10 @@ export function actionOutcome(answer, name, input) {
     if (refusal?.code === 'operation_contended' && numbered(input)) {
         return { kind: 'transport-uncertainty' };
     }
-    if (refusal !== null)
-        return { kind: 'rejected', ...refusal };
+    if (refusal !== null) {
+        const reset = resetOf(refusal);
+        return { kind: 'rejected', ...refusal, ...(reset === undefined ? {} : { reset }) };
+    }
     if (answer.status === 404)
         return unimplemented(name);
     if (answer.status === 0 || answer.status >= 400)

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,OAAO,EAIP,aAAa,EAgBd,MAAM,wBAAwB,CAAC;AAiChC,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAoBxB,MAAM,MAAM,yBAAyB,GACjC;IACE,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CACrC,GACD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AA6DrD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAqapF"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,OAAO,EAIP,aAAa,EAed,MAAM,wBAAwB,CAAC;AAyBhC,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAqBxB,MAAM,MAAM,yBAAyB,GACjC;IACE,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CACrC,GACD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAoBrD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAmbpF"}

package/dist/adapter.js

@@ -1,20 +1,20 @@
 import { stepped } from '@agentshouse/mdruntime';
 import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
 import { createSiteAdapter } from './site.js';
-import { authorityRoot, bootstrapping, parseFileAddress, parseGrant, } from './read.js';
-import { roomStreams } from './room-stream.js';
+import { parseFileAddress, parseGrant } from './read.js';
+import { chunkedHead, chunkLister, chunkPart } from './chunks.js';
 import { spaceSchemas } from './space-schema.js';
-import { sha256Hex } from './digest.js';
 import { finishedUpload, houseUpload } from './upload.js';
-import { houseAction } from './actions.js';
+import { houseAction, HOUSE_LEADING_READS, HOUSE_UNKEPT_READS } from './actions.js';
 import { houseSearch } from './search.js';
 import { classifyDoor, doorRefusal } from './refusal.js';
 import { houseNotifications, } from './stream.js';
 import { houseDoorRoute, } from './transport.js';
 import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, houseMove, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
+import { admittedPath } from './authored-path.js';
 import { HOUSE_TYPED_PATHS } from './house-model.js';
 import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.js';
-import { followsVersion, logPosition, presented, reachedVersion, roomVersion } from './version.js';
+import { followsVersion, reachedVersion, roomVersion } from './version.js';
 const UNCERTAIN = { kind: 'transport-uncertainty' };
 const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
 const OCTET_STREAM = 'application/octet-stream';
@@ -22,32 +22,6 @@ const EXPIRED_ADDRESS = 403;
 function lapsedGrant(outcome) {
     return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
 }
-async function heldFiles(authority, held, bound) {
-    const listed = await held.files(null, bound + 1);
-    const files = listed.slice(0, bound);
-    const through = listed.length > bound ? (files.at(-1)?.path ?? null) : null;
-    return files.length === 0 ? null : { room: authority, through, files };
-}
-async function reused(scope, held) {
-    const sent = new Set(scope.contents.map((entry) => entry.path));
-    const contents = [...scope.contents];
-    const asked = scope.files.filter((file) => file.binary === undefined && !sent.has(file.path));
-    if (asked.length === 0)
-        return scope;
-    if (held === undefined)
-        return null;
-    const kept = await held.contents(asked.map(({ path }) => path));
-    for (const file of asked) {
-        const found = kept.get(file.path);
-        if (found === undefined ||
-            found.revision !== file.revision ||
-            (await sha256Hex(found.content)) !== file.sha256) {
-            return null;
-        }
-        contents.push({ path: file.path, content: found.content });
-    }
-    return { ...scope, contents };
-}
 export function createAgentsHouseAdapter(options) {
     if ('site' in options)
         return createSiteAdapter(options.site, options.snapshot === true);
@@ -56,10 +30,12 @@ export function createAgentsHouseAdapter(options) {
     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 rooms = roomStreams('credential', spaces);
-    const unreused = new Set();
+    const lister = chunkLister(transport, () => declared().max_prefixes);
+    const chunked = new Map();
+    const renewals = new WeakMap();
     let bounds;
     function declared() {
         if (bounds === undefined)
@@ -72,6 +48,7 @@ export function createAgentsHouseAdapter(options) {
             return null;
         bounds = document.bounds;
         tracked.clear();
+        lister.forget();
         for (const entry of trackedFrom(document))
             tracked.set(entry.locator, entry);
         notifications.track([...tracked.values()]);
@@ -96,42 +73,52 @@ export function createAgentsHouseAdapter(options) {
             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 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 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);
+    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 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;
+        chunked.set(entry.locator, renewed);
+        return { room: renewed, read: await transport.download(renewed.chunks.get(id).url) };
     }
-    function held(rooms) {
-        notifications.send(rooms.flatMap((room) => {
-            const entry = tracked.get(room.locator);
-            const at = logPosition(room.roomVersion);
-            return entry === undefined || at === null ? [] : [presented(entry.authority, at)];
-        }));
+    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);
+    }
+    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);
@@ -156,7 +143,7 @@ export function createAgentsHouseAdapter(options) {
         if (handed !== undefined && handed.sha256 === sha256) {
             return { body: { ...head, paths, upload: handed, runtime: notifications.runtime } };
         }
-        const minted = await transport.door(houseDoorRoute('batch-upload'), {
+        const minted = await transport.door(houseDoorRoute('files/batch-upload'), {
             ...head,
             paths,
             bytes,
@@ -209,11 +196,13 @@ export function createAgentsHouseAdapter(options) {
             : { body: inline };
         if ('outcome' in prepared)
             return prepared.outcome;
-        const answer = await transport.door(houseDoorRoute('batch'), prepared.body);
+        const answer = await transport.door(houseDoorRoute('files/batch'), prepared.body);
         const stagedFiles = await staged(answer, request);
         if (stagedFiles === false)
             return UNCERTAIN;
-        const settled = stagedFiles === null ? answer : await transport.door(houseDoorRoute('batch'), prepared.body);
+        const settled = stagedFiles === null
+            ? answer
+            : await transport.door(houseDoorRoute('files/batch'), prepared.body);
         if (stagedFiles === true && (await staged(settled, request)) !== null)
             return UNCERTAIN;
         return stepped(mutationOutcome(settled.status, settled.body, entry.locator, entry.handle, into === undefined
@@ -281,7 +270,7 @@ export function createAgentsHouseAdapter(options) {
         const entry = authorityFor(request.locator);
         if (entry === undefined)
             return null;
-        return () => transport.door(houseDoorRoute('files/get'), {
+        return () => transport.door(houseDoorRoute('files/read'), {
             room_ref: entry.authority,
             path: request.path,
             revision: request.revision,
@@ -291,6 +280,9 @@ export function createAgentsHouseAdapter(options) {
         roomTypes: HOUSE_ROOM_TYPES,
         nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
         typedPaths: HOUSE_TYPED_PATHS,
+        pathRule: admittedPath,
+        unkeptReads: HOUSE_UNKEPT_READS,
+        leadingReads: HOUSE_LEADING_READS,
         async authorize() {
             return options.authorize();
         },
@@ -299,8 +291,8 @@ export function createAgentsHouseAdapter(options) {
             if (entry === undefined)
                 return { kind: 'room-not-readable', locator: request.locator };
             return request.pageToken === undefined
-                ? openedRoom(entry, request)
-                : streamedPage(entry, request.pageToken, request.held);
+                ? listedRoom(entry)
+                : chunkPage(entry, request.pageToken, request.arriving);
         },
         async mutate(_authorization, request, keep) {
             const entry = authorityFor(request.locator);
@@ -331,7 +323,7 @@ export function createAgentsHouseAdapter(options) {
             const entry = authorityFor(request.locator);
             if (entry === undefined)
                 return { kind: 'room-not-readable', locator: request.locator };
-            const answer = await transport.door(houseDoorRoute('revisions'), revisionBody({
+            const answer = await transport.door(houseDoorRoute('files/revisions/list'), revisionBody({
                 path: request.path,
                 handle: entry.handle,
                 ...(request.revision === undefined ? {} : { revision: request.revision }),
@@ -396,7 +388,7 @@ export function createAgentsHouseAdapter(options) {
             return houseSearch(transport, [...tracked.values()], request);
         },
         roomStream: {
-            hold: held,
+            hold,
             observe: notifications.observe,
         },
         conversations: notifications.conversations,

package/dist/authored-path.d.ts

@@ -0,0 +1,11 @@
+export declare const GENERATED_PROVENANCE = "_provenance";
+export declare const GENERATED_REVISIONS = "_revisions";
+export declare const RESERVED_DERIVED = "_derived";
+export declare const WHOLE_ESCAPED_NAMES: readonly string[];
+export declare const AUTHORED_SEGMENT_MAX_CHARS = 255;
+export declare const AUTHORED_SEGMENT: RegExp;
+export declare const LOCAL_COPY_MANIFEST = ".house";
+export declare const LOCAL_COPY_ROOT_NAMES: readonly string[];
+export declare const APP_PREFERENCES_HOME = "settings/apps";
+export declare function admittedPath(path: string): boolean;
+//# sourceMappingURL=authored-path.d.ts.map

package/dist/authored-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-path.d.ts","sourceRoot":"","sources":["../src/authored-path.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAElD,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAE3C,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAMhD,CAAC;AAEF,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAO9C,eAAO,MAAM,gBAAgB,QAE5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,WAAW,CAAC;AAE5C,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAIlD,CAAC;AAEF,eAAO,MAAM,oBAAoB,kBAAkB,CAAC;AASpD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQlD"}

package/dist/authored-path.js

@@ -0,0 +1,35 @@
+import { APP_REFERENCE_PATTERN } from './app-reference.js';
+export const GENERATED_PROVENANCE = '_provenance';
+export const GENERATED_REVISIONS = '_revisions';
+export const RESERVED_DERIVED = '_derived';
+export const WHOLE_ESCAPED_NAMES = [
+    '.',
+    '..',
+    GENERATED_PROVENANCE,
+    GENERATED_REVISIONS,
+    RESERVED_DERIVED,
+];
+export const AUTHORED_SEGMENT_MAX_CHARS = 255;
+const REFUSED_SEGMENTS = [
+    ...WHOLE_ESCAPED_NAMES.map((name) => name.replaceAll('.', '[.]')),
+    '[.][Gg][Ii][Tt][.]*',
+].join('|');
+export const AUTHORED_SEGMENT = new RegExp(`^(?!(?:${REFUSED_SEGMENTS})(?:/|$))[A-Za-z0-9._][A-Za-z0-9._-]{0,${AUTHORED_SEGMENT_MAX_CHARS - 1}}$`);
+export const LOCAL_COPY_MANIFEST = '.house';
+export const LOCAL_COPY_ROOT_NAMES = [
+    '.gitignore',
+    '.ignore',
+    LOCAL_COPY_MANIFEST,
+];
+export const APP_PREFERENCES_HOME = 'settings/apps';
+function appPreferences(path) {
+    return (path.endsWith('.md') &&
+        APP_REFERENCE_PATTERN.test(path.slice(APP_PREFERENCES_HOME.length + 1, -3)));
+}
+export function admittedPath(path) {
+    const names = path.split('/');
+    const [root = ''] = names;
+    return (!LOCAL_COPY_ROOT_NAMES.includes(root.toLowerCase()) &&
+        names.every((name) => AUTHORED_SEGMENT.test(name)) &&
+        (!path.startsWith(`${APP_PREFERENCES_HOME}/`) || appPreferences(path)));
+}

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"}

package/dist/chunks.js

@@ -0,0 +1,247 @@
+import { paced, ROW_WEIGHT, stepped, } from '@agentshouse/mdruntime';
+import { manifestedModels } from './model.js';
+import { authorityRoot, bootstrapping, parseFile, } from './read.js';
+import { classifyDoor } from './refusal.js';
+import { houseDoorRoute } from './transport.js';
+import { readPosition, roomVersion } from './version.js';
+function authorKey(author) {
+    for (const kind of ['user', 'site', 'inbox']) {
+        if (typeof author[kind] === 'string')
+            return `${kind}:${author[kind]}`;
+    }
+    const { app, release, function: named } = author;
+    return typeof app === 'string' && typeof release === 'string' && typeof named === 'string'
+        ? `app:${app}:${release}:${named}`
+        : null;
+}
+function namesOf(authors) {
+    if (!Array.isArray(authors))
+        return null;
+    const names = new Map();
+    for (const author of authors) {
+        const key = typeof author === 'object' && author !== null ? authorKey(author) : null;
+        if (key === null || typeof author.name !== 'string')
+            return null;
+        names.set(key, author.name);
+    }
+    return names;
+}
+function modelsOf(models, mode) {
+    if (!Array.isArray(models))
+        return null;
+    const files = [];
+    const contents = [];
+    for (const entry of models) {
+        const file = parseFile(entry, mode);
+        if (file === null || typeof entry.content !== 'string')
+            return null;
+        files.push(file);
+        contents.push({ path: file.path, content: entry.content });
+    }
+    return { files, contents };
+}
+export function partId(logEpoch, hash) {
+    return `${logEpoch}:${hash}`;
+}
+function chunkedRoom(room, mode) {
+    const at = readPosition(room);
+    const names = mode === 'site' ? new Map() : namesOf(room.authors);
+    const models = modelsOf(room.models, mode);
+    if (at === null || names === null || models === null || !Array.isArray(room.chunks))
+        return null;
+    const chunks = new Map();
+    const parts = [];
+    for (const chunk of room.chunks) {
+        const { hash, bytes, download } = chunk;
+        if (typeof hash !== 'string' || typeof bytes !== 'number' || typeof download !== 'string')
+            return null;
+        const id = partId(at.logEpoch, hash);
+        chunks.set(id, { url: download, bytes });
+        parts.push({ id, bytes });
+    }
+    return { anchor: room.room_ref, ...at, mode, chunks, parts, names, models };
+}
+function listedRoom(room, mode) {
+    if (typeof room !== 'object' || room === null)
+        return null;
+    const held = room;
+    if (typeof held.room_ref !== 'string')
+        return null;
+    if (held.ready === false)
+        return { kind: 'not-ready' };
+    return held.ready === true ? chunkedRoom(held, mode) : null;
+}
+export function siteChunkList(answer, locator) {
+    const failure = classifyDoor(answer.status, answer.body, locator);
+    if (failure !== null)
+        return failure;
+    return listedRoom(answer.body, 'site') ?? { kind: 'transport-uncertainty' };
+}
+export async function chunkedHead(listed, entry, spaces) {
+    if (listed.anchor !== entry.authority)
+        return { kind: 'transport-uncertainty' };
+    const models = await manifestedModels({
+        anchor: listed.anchor,
+        position: listed.position,
+        logEpoch: listed.logEpoch,
+        models: listed.models,
+    }, entry, spaces);
+    return {
+        kind: 'bootstrap',
+        roomVersion: roomVersion(listed),
+        documents: {},
+        facts: {},
+        revisions: {},
+        changes: {},
+        binaryFiles: {},
+        parts: listed.parts,
+        ...(models === undefined ? {} : { models }),
+    };
+}
+export async function chunkPart(body, room, id, arriving) {
+    const address = room.chunks.get(id);
+    if (body === null || address === undefined)
+        return { kind: 'transport-uncertainty' };
+    const scope = await chunkScope(body, room, arriving).catch(() => null);
+    if (scope === null)
+        return { kind: 'transport-uncertainty' };
+    return { ...(await stepped(bootstrapping(scope))), bytes: address.bytes };
+}
+function listedRooms(answer) {
+    const rooms = answer.body?.rooms;
+    if (!Array.isArray(rooms))
+        return null;
+    const listed = new Map();
+    for (const room of rooms) {
+        const held = listedRoom(room, 'credential');
+        if (held === null)
+            return null;
+        listed.set(room.room_ref, held);
+    }
+    return listed;
+}
+export function chunkLister(transport, most) {
+    const asked = new Map();
+    function answered(entries, whole) {
+        const prefixes = whole ? ['/'] : entries.map((entry) => authorityRoot(entry.handle));
+        return transport.door(houseDoorRoute('room-chunks/list'), { prefixes }).then((answer) => {
+            const failure = classifyDoor(answer.status, answer.body, '');
+            if (failure !== null)
+                return failed(entries, failure);
+            const listed = listedRooms(answer);
+            return listed ?? failed(entries, { kind: 'transport-uncertainty' });
+        }, () => failed(entries, { kind: 'transport-uncertainty' }));
+    }
+    function failed(entries, failure) {
+        return new Map(entries.map((entry) => [
+            entry.authority,
+            failure.kind === 'room-not-readable' || failure.kind === 'scoped-refusal'
+                ? { ...failure, locator: entry.locator }
+                : failure,
+        ]));
+    }
+    function settled(entry, lists) {
+        return lists.then((listed) => listed.get(entry.authority) ?? { kind: 'room-not-readable', locator: entry.locator });
+    }
+    function askAll(entries) {
+        if (entries.length === 0)
+            return;
+        const lists = answered(entries, entries.length > most());
+        for (const entry of entries) {
+            const listed = settled(entry, lists);
+            listed.catch(() => { });
+            asked.set(entry.authority, { entry, listed });
+        }
+    }
+    function list(entry) {
+        const held = asked.get(entry.authority);
+        asked.delete(entry.authority);
+        return held?.listed ?? settled(entry, answered([entry], false));
+    }
+    return {
+        askAll,
+        list,
+        renew(entry, installing) {
+            if (!asked.has(entry.authority)) {
+                const waiting = [...asked.values()].map((held) => held.entry);
+                const due = new Map([entry, ...installing, ...waiting].map((held) => [held.authority, held]));
+                askAll([...due.values()]);
+            }
+            return list(entry);
+        },
+        forget() {
+            asked.clear();
+        },
+    };
+}
+function folderLine(entry) {
+    return typeof entry.folder === 'string' && Object.keys(entry).length === 1 ? entry.folder : null;
+}
+function chunkEntry(line, room, read) {
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    if (typeof entry !== 'object' || entry === null)
+        return false;
+    const folder = folderLine(entry);
+    if (folder !== null) {
+        read.folders.push(folder);
+        return true;
+    }
+    const author = entry.author;
+    let named = entry;
+    if (author !== undefined) {
+        const key = typeof author === 'object' && author !== null ? authorKey(author) : null;
+        const name = key === null ? undefined : room.names.get(key);
+        if (name === undefined)
+            return false;
+        named = { ...entry, author: { ...author, name } };
+    }
+    const file = parseFile(named, room.mode);
+    if (file === null)
+        return false;
+    read.files.push(file);
+    if (typeof entry.content === 'string')
+        read.contents.push({ path: file.path, content: entry.content });
+    return true;
+}
+export async function chunkScope(body, room, arriving) {
+    const read = {
+        files: [],
+        contents: [],
+        folders: [],
+    };
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const pace = paced();
+    const unfinished = [];
+    let bytes = 0;
+    for (let chunk = await reader.read(); chunk.done !== true; chunk = await reader.read()) {
+        bytes += chunk.value.length;
+        arriving?.(bytes);
+        const text = decoder.decode(chunk.value, { stream: true });
+        let start = 0;
+        for (let end = text.indexOf('\n'); end !== -1; end = text.indexOf('\n', start)) {
+            const piece = text.slice(start, end);
+            const line = unfinished.length === 0 ? piece : unfinished.splice(0).join('') + piece;
+            start = end + 1;
+            if (line.length > 0 && !chunkEntry(line, room, read)) {
+                await reader.cancel();
+                return null;
+            }
+            const due = pace(line.length + ROW_WEIGHT);
+            if (due instanceof Promise)
+                await due;
+        }
+        if (start < text.length)
+            unfinished.push(text.slice(start));
+    }
+    const rest = unfinished.join('') + decoder.decode();
+    if (rest.length > 0 && !chunkEntry(rest, room, read))
+        return null;
+    return { anchor: room.anchor, position: room.position, logEpoch: room.logEpoch, ...read };
+}