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

package/dist/house-model.js

@@ -0,0 +1,361 @@
+export const HOUSE_MODEL_DECLARATION = {
+    $defs: {
+        room: {
+            description: 'A Room, by its Room reference, under the key `room`.',
+            type: 'string',
+            pattern: '^r_([0123456789abcdefghjkmnpqrstvwxyz]+)\\.([0123456789abcdefghjkmnpqrstvwxyz])$',
+        },
+        app: {
+            description: 'An App, by its App reference, under the key `app`.',
+            type: 'string',
+            pattern: '^a_([0123456789abcdefghjkmnpqrstvwxyz]+)\\.([0123456789abcdefghjkmnpqrstvwxyz])$',
+        },
+        document: {
+            description: 'A document of a Room, by its file reference, under the key `document`.',
+            type: 'string',
+            pattern: '^af_([123456789abcdefghjkmnpqrstvwxyz][0123456789abcdefghjkmnpqrstvwxyz]*)\\.([0123456789abcdefghjkmnpqrstvwxyz])$',
+        },
+        id: {
+            description: 'Any other entity, by its identifier, under the key of its kind. An entity a type says more about is an object holding it under that key beside its facts.',
+            type: 'string',
+            format: 'uuid',
+        },
+        namespace: {
+            description: 'The Namespace a grant entry covers, an App or a Room by its reference with the area of it.',
+            type: 'string',
+            maxLength: 512,
+            pattern: '^(?:a_[A-Za-z0-9._-]+(?:\\/source)?|r_[A-Za-z0-9._-]+(?:\\/(?:settings|settings\\/schema|settings\\/model|settings\\/indexing|content))?)$',
+        },
+    },
+    'house-app-preferences': {
+        description: "An App's preferences. Its own vocabulary is in the body.",
+        properties: { app: { $ref: '#/$defs/app' } },
+        required: ['app'],
+    },
+    'house-notification': {
+        description: "One kept Notification for this User: its kind, when it was sent as `created`, its way in, its email's subject and each fact of its value that is not sealed, named in snake_case. An entity a fact names is an object holding its identifier under the key of its kind, when the notification carries it, and its `name`, `email` and other facts beside it; a fact holding null is absent. `way_in` is either the House `path` it opens or the entity it is about, by its identifier under the key of its kind, a Trigger with its `room`. Its body is its email's words in Markdown. Both were worded once, in the User's language when it was delivered; an App may show them or word it itself from its kind and value. `read` is when the User opened it or marked it read, on any device: the one field House adds after delivery.",
+        properties: {
+            notification: { $ref: '#/$defs/id' },
+            kind: {
+                type: 'string',
+                enum: [
+                    'share-offer',
+                    'join-request',
+                    'join-request-approved',
+                    'room-ownership-offer',
+                    'managed-environment-retention-opened',
+                    'storage-full',
+                    'sandbox-budget-spent',
+                    'trigger-failed',
+                    'break-glass-owner-disclosure',
+                    'export-ready',
+                    'export-failed',
+                    'custom',
+                ],
+            },
+            created: { type: 'string', format: 'date-time' },
+            read: { type: 'string', format: 'date-time' },
+            way_in: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    path: { type: 'string', pattern: '^\\/' },
+                    room: { $ref: '#/$defs/room' },
+                    environment: { $ref: '#/$defs/id' },
+                    trigger: { $ref: '#/$defs/id' },
+                },
+                minProperties: 1,
+            },
+            subject: { type: 'string' },
+            share: { $ref: '#/$defs/id' },
+            issuer: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { name: { type: 'string' }, email: { type: 'string', format: 'email' } },
+                required: ['name', 'email'],
+            },
+            rooms: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: { name: { type: 'string' } },
+                    required: ['name'],
+                },
+            },
+            apps: {
+                maxItems: 20,
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        name: { type: 'string', minLength: 1, maxLength: 200 },
+                        reaches: { type: 'array', items: { type: 'string', minLength: 1, maxLength: 512 } },
+                    },
+                    required: ['name', 'reaches'],
+                },
+            },
+            expires_at: { type: 'string', format: 'date-time' },
+            join_request: { $ref: '#/$defs/id' },
+            user: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { name: { type: 'string' }, email: { type: 'string', format: 'email' } },
+                required: ['name', 'email'],
+            },
+            room: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { room: { $ref: '#/$defs/room' }, name: { type: 'string' } },
+                minProperties: 1,
+            },
+            app: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { app: { $ref: '#/$defs/app' } },
+                required: ['app'],
+            },
+            ownership_offer: { $ref: '#/$defs/id' },
+            offerer: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { name: { type: 'string' }, email: { type: 'string', format: 'email' } },
+                required: ['name', 'email'],
+            },
+            environment: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    environment: { $ref: '#/$defs/id' },
+                    name: { type: 'string' },
+                    kind: { enum: ['vps', 'sandbox'] },
+                },
+                required: ['environment', 'name'],
+            },
+            reason: { type: 'string' },
+            deadline: { type: 'string', format: 'date-time' },
+            free: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    held: { type: 'string', pattern: '^\\d+$' },
+                    limit: { type: 'string', pattern: '^[1-9]\\d*$' },
+                    measure: { type: 'string', enum: ['content', 'retained'] },
+                },
+                required: ['held', 'limit', 'measure'],
+            },
+            budget: { type: 'string', pattern: '^\\d+(?:\\.\\d+)?$' },
+            resets_at: { type: 'string', format: 'date-time' },
+            grant: { $ref: '#/$defs/id' },
+            category: { type: 'string' },
+            access_started_at: { type: 'string', format: 'date-time' },
+            access_ended_at: { type: 'string', format: 'date-time' },
+            systems: { type: 'array', items: { type: 'string' } },
+            case_reference: { type: 'string' },
+            export: { $ref: '#/$defs/id' },
+            size_bytes: { type: 'integer', minimum: 0 },
+            title: { type: 'string' },
+            body: { type: 'string' },
+            authorship: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    kind: { type: 'string', const: 'trigger-action' },
+                    trigger: { $ref: '#/$defs/id' },
+                    position: { type: 'integer', minimum: 0 },
+                },
+                required: ['kind', 'trigger', 'position'],
+            },
+            path: { type: 'string', maxLength: 4096, pattern: '^\\/.*' },
+            trigger: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { trigger: { $ref: '#/$defs/id' }, description: { type: 'string' } },
+                required: ['trigger', 'description'],
+            },
+            code: {
+                type: 'string',
+                enum: [
+                    'failed',
+                    'function_failed',
+                    'function_not_started',
+                    'agent_function_request_not_started',
+                ],
+            },
+            action: { type: 'integer', minimum: 0 },
+            moment: { type: 'string', format: 'date-time' },
+            error: { type: 'string' },
+        },
+        required: ['notification', 'kind', 'created', 'way_in', 'subject'],
+    },
+    'house-panel-preferences': {
+        description: "The panel's preferences at /rooms/private/settings/panel.md. Its own vocabulary is in the body.",
+        properties: {},
+    },
+    'house-agent-function': {
+        description: "One Agent function that serves this Room, which House alone writes from its owner's document in their Private Room: the `agent_function` by identifier, its `description`, the `input` a caller sends, empty when it takes nothing, and the `agent` it starts, by `agent` and the `name` that Agent had when this card was last written. The Agent function's instruction is never written here.",
+        properties: {
+            reflected: { type: 'string', format: 'date-time' },
+            agent_function: { $ref: '#/$defs/id' },
+            description: { type: 'string' },
+            input: { type: 'string' },
+            agent: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { agent: { $ref: '#/$defs/id' }, name: { type: 'string' } },
+                required: ['agent', 'name'],
+            },
+        },
+        required: ['reflected', 'agent_function', 'description', 'input', 'agent'],
+    },
+    'house-agent-function-document': {
+        description: 'One Agent function as its owner writes it in their Private Room at rooms/<room-handle>/agent-functions/<name>.md, a path that binds this type and a document that names no type: what it does as `description`, what a caller sends as `input`, empty when it takes nothing, and the `agent` it starts, by identifier. Its body is the instruction that Agent follows.',
+        properties: {
+            description: { type: 'string', maxLength: 2000, pattern: '\\S' },
+            input: { type: 'string' },
+            agent: { $ref: '#/$defs/id' },
+        },
+        required: ['description', 'input', 'agent'],
+    },
+    'house-trigger': {
+        description: "One Trigger of this Room as its acts wrote it, which House alone writes: its `description`, the `condition` it fires on, its `actions` in order, whether each action and the Trigger are `enabled`, `paused_by` `types` while a change of the Room's types paused it, its `creator` by `user` and the `name` they had then, and when it was `created`. A `notify` action reaches the `users` its `to` names, the members its `fields` name in the matched document and the holders of its `roles`; an `agent_function` action sends its `payload` to the Agent function whose card under this Room's `house/agent-functions/` its `card` names, absent while this Room holds no card of that Agent function; a `message` action puts its `text` into the active conversation that Agent function started for what the Event is about, or starts that Agent function when none is active; a `done` action marks Done every active conversation an Agent function request of this Room started for the Event's document; a `function` action runs the `function` its `app`'s latest release declares, on House's servers, or, naming no `app`, the Room owner's Environment function of that name on its Environment, which only a Trigger of their Private Room holds. Whether an action's target holds is not written: it follows from the Room's members, the Agent function's card, the App's latest release and the owner's functions.",
+        properties: {
+            reflected: { type: 'string', format: 'date-time' },
+            trigger: { $ref: '#/$defs/id' },
+            description: { type: 'string' },
+            condition: {
+                description: 'When it fires, as the Trigger reference page writes it, a document it names at its current path.',
+                type: 'object',
+                additionalProperties: true,
+            },
+            actions: {
+                type: 'array',
+                items: {
+                    anyOf: [
+                        {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                kind: { const: 'notify' },
+                                enabled: { type: 'boolean' },
+                                title: { type: 'string' },
+                                text: { type: 'string' },
+                                to: {
+                                    type: 'object',
+                                    additionalProperties: false,
+                                    properties: {
+                                        users: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'object',
+                                                additionalProperties: false,
+                                                properties: { user: { $ref: '#/$defs/id' } },
+                                                required: ['user'],
+                                            },
+                                        },
+                                        fields: { type: 'array', items: { type: 'string' } },
+                                        roles: { type: 'array', items: { type: 'string' } },
+                                    },
+                                    required: ['users', 'fields', 'roles'],
+                                },
+                            },
+                            required: ['kind', 'enabled', 'title', 'text', 'to'],
+                        },
+                        {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                kind: { const: 'agent_function' },
+                                enabled: { type: 'boolean' },
+                                card: { type: 'string', minLength: 1 },
+                                payload: { type: 'string' },
+                            },
+                            required: ['kind', 'enabled', 'payload'],
+                        },
+                        {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                kind: { const: 'message' },
+                                enabled: { type: 'boolean' },
+                                card: { type: 'string', minLength: 1 },
+                                text: { type: 'string' },
+                            },
+                            required: ['kind', 'enabled', 'text'],
+                        },
+                        {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: { kind: { const: 'done' }, enabled: { type: 'boolean' } },
+                            required: ['kind', 'enabled'],
+                        },
+                        {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                kind: { const: 'function' },
+                                enabled: { type: 'boolean' },
+                                app: { $ref: '#/$defs/app' },
+                                function: { type: 'string' },
+                            },
+                            required: ['kind', 'enabled', 'function'],
+                        },
+                    ],
+                },
+            },
+            enabled: { type: 'boolean' },
+            paused_by: { enum: ['types'] },
+            creator: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { user: { $ref: '#/$defs/id' }, name: { type: 'string' } },
+                required: ['user', 'name'],
+            },
+            created: { type: 'string', format: 'date-time' },
+        },
+        required: [
+            'reflected',
+            'trigger',
+            'description',
+            'condition',
+            'actions',
+            'enabled',
+            'creator',
+            'created',
+        ],
+    },
+    'house-web-wizard': {
+        description: "One Web Wizard an agent made for this User: the `environment` it runs on, with the `name` that Environment had when the Web Wizard was made, and its `state`, `waiting` until its owner presses Run or Keep, `running`, `finished` with the script's `exit_code`, `failed`, `cancelled` when its page closed before the script ended, `lapsed` when nobody ran it in its time, or `kept` when its owner kept the script, without running it, as their Environment function named `function`. Its body is the script, whole, in one fenced code block. The terminal's output is never kept.",
+        properties: {
+            reflected: { type: 'string', format: 'date-time' },
+            web_wizard: { $ref: '#/$defs/id' },
+            environment: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { environment: { $ref: '#/$defs/id' }, name: { type: 'string' } },
+                required: ['environment', 'name'],
+            },
+            state: { enum: ['waiting', 'running', 'finished', 'failed', 'cancelled', 'lapsed', 'kept'] },
+            exit_code: { type: 'integer' },
+            function: { type: 'string' },
+        },
+        required: ['reflected', 'web_wizard', 'environment', 'state'],
+    },
+};
+function modelText(model) {
+    return `${Object.entries(model)
+        .map(([name, declared]) => `${name}: ${JSON.stringify(declared)}`)
+        .join('\n')}\n`;
+}
+export const HOUSE_MODEL_TYPES = modelText(HOUSE_MODEL_DECLARATION);
+export const HOUSE_TYPED_PATHS = [
+    { path: 'settings/panel.md', type: 'house-panel-preferences', named: true, body: false },
+    { path: 'settings/apps/*.md', type: 'house-app-preferences', named: true, body: false },
+    {
+        path: 'rooms/*/agent-functions/*.md',
+        type: 'house-agent-function-document',
+        named: false,
+        body: true,
+    },
+];

package/dist/index.d.ts

@@ -1,4 +1,13 @@
 export { createAgentsHouseAdapter, type AgentsHouseAdapterOptions } from './adapter.js';
-export { HOUSE_APP_ACTS, HOUSE_APP_BATCHES, HOUSE_SITE_ACTS } from './actions.js';
-export type { HouseByteAct, HouseByteTransfer, HouseBytesAnswer, HouseDoorAnswer, HouseHeldRoom, HouseOpening, HouseStream, HouseStreamEntry, HouseStreamFrame, HouseSiteTransport, HouseTransport, } from './transport.js';
+export { foldedAuthorities } from './discovery.js';
+export { finishedUpload, houseUpload, type HouseUpload } from './upload.js';
+export { houseAction, type HouseActDoor } from './actions.js';
+export { HISTORY_PAGE } from './history.js';
+export { houseParts, type ChangeMapping } from './write.js';
+export { APP_REFERENCE_PATTERN } from './app-reference.js';
+export { HOUSE_MODEL_DECLARATION, HOUSE_MODEL_TYPES, HOUSE_TYPED_PATHS, type HouseDocumentFields, type HouseModelType, } from './house-model.js';
+export { CROCKFORD_ALPHABET, CROCKFORD_CHARACTER, CROCKFORD_LEADING_CHARACTER, } from './crockford.js';
+export { CHAT_MESSAGE_TYPE, CHAT_TYPE, HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES, INBOX_CHANNEL_KINDS, type InboxChannelKind, } from './room-types.js';
+export { HOUSE_RUNTIME_READS, houseDoorRoute, houseSiteRoute, type HouseRuntimeAct, type HouseRuntimeFrame, } from './transport.js';
+export type { HouseByteAct, HouseByteTransfer, HouseBytesAnswer, HouseClosing, HouseDoorAnswer, HouseHeldRoom, HouseOpening, HouseStream, HouseStreamed, HouseStreamEntry, HouseStreamFrame, HouseSiteTransport, HouseTransport, } from './transport.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAClF,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,GACf,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,yBAAyB,EACzB,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,GACf,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,2 +1,11 @@
 export { createAgentsHouseAdapter } from './adapter.js';
-export { HOUSE_APP_ACTS, HOUSE_APP_BATCHES, HOUSE_SITE_ACTS } from './actions.js';
+export { foldedAuthorities } from './discovery.js';
+export { finishedUpload, houseUpload } from './upload.js';
+export { houseAction } from './actions.js';
+export { HISTORY_PAGE } from './history.js';
+export { houseParts } from './write.js';
+export { APP_REFERENCE_PATTERN } from './app-reference.js';
+export { HOUSE_MODEL_DECLARATION, HOUSE_MODEL_TYPES, HOUSE_TYPED_PATHS, } from './house-model.js';
+export { CROCKFORD_ALPHABET, CROCKFORD_CHARACTER, CROCKFORD_LEADING_CHARACTER, } from './crockford.js';
+export { CHAT_MESSAGE_TYPE, CHAT_TYPE, HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES, INBOX_CHANNEL_KINDS, } from './room-types.js';
+export { HOUSE_RUNTIME_READS, houseDoorRoute, houseSiteRoute, } from './transport.js';

package/dist/model.d.ts

@@ -1,9 +1,13 @@
 import type { RoomModels } from '@agentshouse/mdruntime';
 import type { TrackedAuthority } from './discovery.js';
-import { type HouseScope, type HouseView } from './read.js';
+import { type HouseRoomHead, type HouseScope } from './read.js';
+import { type SpaceSchemas } from './space-schema.js';
 import type { HouseMode, HouseStreamEntry } from './transport.js';
 export declare function partModels(scope: HouseScope, tracked: TrackedAuthority, seen: ReadonlySet<string>, final: boolean): Promise<RoomModels | undefined>;
-export declare function scopeModels(scope: HouseScope, tracked: TrackedAuthority): Promise<RoomModels | undefined>;
-export declare function viewModels(view: HouseView, tracked: TrackedAuthority): Promise<RoomModels | undefined>;
-export declare function streamedModels(schemas: ReadonlyMap<string, HouseStreamEntry>, tracked: TrackedAuthority, mode: HouseMode): Promise<RoomModels | undefined>;
+export declare function manifestedModels(room: HouseRoomHead, tracked: TrackedAuthority, spaces: SpaceSchemas): Promise<{
+    readonly models: RoomModels | undefined;
+    readonly seen: string[];
+}>;
+export declare function keptSpaceSchemas(entries: readonly HouseStreamEntry[], spaces: SpaceSchemas): void;
+export declare function streamedModels(schemas: ReadonlyMap<string, HouseStreamEntry>, tracked: TrackedAuthority, mode: HouseMode, spaces: SpaceSchemas): Promise<RoomModels | undefined>;
 //# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAA0C,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACpG,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAoClE,wBAAgB,UAAU,CACxB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAKjC;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEjC;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAcjC;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC9C,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAWjC"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAIL,KAAK,aAAa,EAElB,KAAK,UAAU,EAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA+BlE,wBAAgB,UAAU,CACxB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAKjC;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAS/E;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAKjG;AAQD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC9C,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAajC"}

package/dist/model.js

@@ -1,5 +1,6 @@
 import { sha256Hex } from './digest.js';
-import { schemaOf, schemaPath } from './read.js';
+import { modelScope, schemaOf, schemaPath, } from './read.js';
+import { spaceIdentity } from './space-schema.js';
 const MODEL_ABSENT = { kind: 'model-unavailable', reason: 'not-readable' };
 const ABSENT_SCHEMA = { schema: null, version: null, revision: null };
 async function heldModel(read, identity) {
@@ -8,23 +9,19 @@ async function heldModel(read, identity) {
     const version = await sha256Hex(JSON.stringify(read.version));
     return {
         kind: 'model',
-        snapshot: { identity, version, schema: read.schema, revision: read.revision },
+        snapshot: {
+            identity: read.space === undefined ? identity : spaceIdentity(read.space),
+            version,
+            schema: read.schema,
+            revision: read.revision,
+        },
     };
 }
 async function modelsOf(tracked, read) {
-    const models = {};
     const collection = read(tracked.schema);
-    if (collection !== undefined) {
-        models.collection = await heldModel(collection, schemaPath(tracked.handle, tracked.schema));
-    }
-    if (tracked.houseModel !== null) {
-        const root = tracked.houseModel.root;
-        const selection = read(root);
-        if (selection !== undefined) {
-            models.selection = await heldModel(selection, schemaPath(tracked.handle, root));
-        }
-    }
-    return models.collection === undefined && models.selection === undefined ? undefined : models;
+    if (collection === undefined)
+        return undefined;
+    return { collection: await heldModel(collection, schemaPath(tracked.handle, tracked.schema)) };
 }
 export function partModels(scope, tracked, seen, final) {
     return modelsOf(tracked, (schema) => {
@@ -33,38 +30,41 @@ export function partModels(scope, tracked, seen, final) {
         return final && !seen.has(schema) ? ABSENT_SCHEMA : undefined;
     });
 }
-export function scopeModels(scope, tracked) {
-    return partModels(scope, tracked, new Set(), true);
+export async function manifestedModels(room, tracked, spaces) {
+    const scope = modelScope(room);
+    const held = schemaOf(scope, tracked.schema);
+    if (held?.space !== undefined && held.schema !== null && held.revision !== null)
+        spaces.keep(held.space, held.revision, held.schema);
+    return {
+        models: await partModels(scope, tracked, new Set(), true),
+        seen: scope.files.some((file) => file.path === tracked.schema) ? [tracked.schema] : [],
+    };
 }
-export function viewModels(view, tracked) {
-    return modelsOf(tracked, (schema) => {
-        const change = view.changes.find((candidate) => candidate.path === schema);
-        if (change === undefined)
-            return undefined;
-        if ('removed' in change)
-            return ABSENT_SCHEMA;
-        if ('content' in change) {
-            return {
-                schema: change.content,
-                version: change.version,
-                revision: change.revision ?? null,
-            };
-        }
-        return null;
-    });
+export function keptSpaceSchemas(entries, spaces) {
+    for (const entry of entries) {
+        if (entry.space !== undefined && entry.text !== undefined && entry.revision !== undefined)
+            spaces.keep(entry.space, entry.revision, entry.text);
+    }
+}
+function streamedText(entry, spaces) {
+    if (entry.text !== undefined || entry.space === undefined || entry.revision === undefined)
+        return entry.text;
+    return spaces.held(entry.space, entry.revision);
 }
-export function streamedModels(schemas, tracked, mode) {
+export function streamedModels(schemas, tracked, mode, spaces) {
     return modelsOf(tracked, (schema) => {
         const entry = schemas.get(schema);
         if (entry === undefined)
             return undefined;
+        const space = entry.space === undefined ? {} : { space: entry.space };
         if (entry.kind === 'removed')
-            return ABSENT_SCHEMA;
-        if (entry.text === undefined)
+            return { ...ABSENT_SCHEMA, ...space };
+        const text = streamedText(entry, spaces);
+        if (text === undefined)
             return null;
         const version = mode === 'site' ? entry.sha256 : entry.revision;
         return version === undefined
             ? null
-            : { schema: entry.text, version, revision: mode === 'site' ? null : version };
+            : { schema: text, version, revision: mode === 'site' ? null : version, ...space };
     });
 }

package/dist/part.d.ts

@@ -0,0 +1,14 @@
+export type RoomFrame = {
+    readonly kind: 'frame';
+    readonly payload: Uint8Array<ArrayBuffer>;
+    readonly bytes: number;
+} | {
+    readonly kind: 'ended';
+} | {
+    readonly kind: 'broken';
+};
+export type RoomFrames = () => Promise<RoomFrame>;
+export declare function checkedPayload(frame: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer> | null>;
+export declare function roomFrames(room: ReadableStream<Uint8Array>, arrived?: (bytes: number) => void, signal?: AbortSignal): RoomFrames;
+export declare function gunzipped(payload: Uint8Array<ArrayBuffer>): ReadableStream<string>;
+//# sourceMappingURL=part.d.ts.map

package/dist/part.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"part.d.ts","sourceRoot":"","sources":["../src/part.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC7F;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEhC,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC;AAQlD,wBAAsB,cAAc,CAClC,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,GAC7B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,CASzC;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,EAChC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACjC,MAAM,CAAC,EAAE,WAAW,GACnB,UAAU,CAwDZ;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAKlF"}

package/dist/part.js

@@ -0,0 +1,90 @@
+const PART_MAGIC = 0x48505431;
+const PART_HEAD_BYTES = 8;
+const PART_DIGEST_BYTES = 32;
+function hex(bytes) {
+    let text = '';
+    for (const byte of bytes)
+        text += byte.toString(16).padStart(2, '0');
+    return text;
+}
+export async function checkedPayload(frame) {
+    if (frame.length < PART_HEAD_BYTES + PART_DIGEST_BYTES)
+        return null;
+    const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+    if (view.getUint32(0) !== PART_MAGIC)
+        return null;
+    const length = view.getUint32(4);
+    if (PART_HEAD_BYTES + length + PART_DIGEST_BYTES !== frame.length)
+        return null;
+    const payload = frame.subarray(PART_HEAD_BYTES, PART_HEAD_BYTES + length);
+    const digest = hex(new Uint8Array(await crypto.subtle.digest('SHA-256', payload)));
+    return hex(frame.subarray(PART_HEAD_BYTES + length)) === digest ? payload : null;
+}
+export function roomFrames(room, arrived, signal) {
+    const reader = room.getReader();
+    signal?.addEventListener('abort', () => void reader.cancel().catch(() => { }), { once: true });
+    const chunks = [];
+    let held = 0;
+    let received = 0;
+    let ended = false;
+    async function filled(bytes) {
+        while (held < bytes && !ended) {
+            const read = await reader.read();
+            if (read.done) {
+                ended = true;
+                break;
+            }
+            chunks.push(read.value);
+            held += read.value.byteLength;
+            received += read.value.byteLength;
+            arrived?.(received);
+        }
+        return held >= bytes;
+    }
+    function taken(bytes) {
+        const out = new Uint8Array(bytes);
+        let at = 0;
+        while (at < bytes) {
+            const chunk = chunks[0];
+            const used = Math.min(chunk.byteLength, bytes - at);
+            out.set(chunk.subarray(0, used), at);
+            at += used;
+            if (used === chunk.byteLength)
+                chunks.shift();
+            else
+                chunks[0] = chunk.subarray(used);
+        }
+        held -= bytes;
+        return out;
+    }
+    return async () => {
+        try {
+            if (!(await filled(PART_HEAD_BYTES)))
+                return held === 0 ? { kind: 'ended' } : { kind: 'broken' };
+            const head = taken(PART_HEAD_BYTES);
+            const view = new DataView(head.buffer);
+            if (view.getUint32(0) !== PART_MAGIC)
+                return { kind: 'broken' };
+            const length = view.getUint32(4);
+            const rest = length + PART_DIGEST_BYTES;
+            if (!(await filled(rest)))
+                return { kind: 'broken' };
+            const frame = new Uint8Array(PART_HEAD_BYTES + rest);
+            frame.set(head, 0);
+            frame.set(taken(rest), PART_HEAD_BYTES);
+            const payload = await checkedPayload(frame);
+            return payload === null
+                ? { kind: 'broken' }
+                : { kind: 'frame', payload, bytes: frame.byteLength };
+        }
+        catch {
+            return { kind: 'broken' };
+        }
+    };
+}
+export function gunzipped(payload) {
+    return new Blob([payload])
+        .stream()
+        .pipeThrough(new DecompressionStream('gzip'))
+        .pipeThrough(new TextDecoderStream());
+}