@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c0105dbd22806

package/dist/client.js

@@ -1,227 +1,208 @@
-import { answer, AUTHORIZATION_ENDED, carried, envelope, PROTOCOL_MISMATCH } from './wire.js';
+import { observed } from './observation.js';
+import { runtimeError } from './failure.js';
+import { answer, AUTHORIZATION_ENDED, PORT_CLOSED, } from './wire.js';
+function refused(refusal) {
+    return runtimeError(refusal.code, refusal.code, refusal.retryable);
+}
 export function connectMdRuntime(port) {
     let sequence = 0;
     let refusal = null;
-    let ended = false;
+    let ended = null;
     const calls = new Map();
-    const acks = new Map();
-    const listeners = new Map();
-    const send = (message)=>{
-        port.postMessage(envelope(message));
+    const opening = new Map();
+    const observations = new Map();
+    let drawing = null;
+    let settling = null;
+    const send = (message) => {
+        port.postMessage(message);
     };
+    function begin(id, topic, first) {
+        const handle = observed(first, () => {
+            observations.delete(id);
+            if (refusal === null)
+                send({ kind: 'stop', id });
+        }, topic === 'query');
+        observations.set(id, { topic, handle });
+        return handle.observation;
+    }
     function refuse(reported) {
         refusal = reported;
-        for (const waiting of acks.values())waiting.settle();
-        acks.clear();
-        const failure = new Error(reported.reason);
-        for (const waiting of calls.values())waiting.fail(failure);
-        calls.clear();
-        for (const listener of listeners.values()){
-            if (listener.topic === 'connection-refusal') listener.notify(reported);
+        for (const { topic, handle } of observations.values()) {
+            if (topic === 'connection-refusal')
+                handle.receive(reported);
         }
+        const failure = refused(reported);
+        for (const [id, waiting] of opening) {
+            if (waiting.topic === 'connection-refusal')
+                waiting.settle(begin(id, waiting.topic, reported));
+            else
+                waiting.fail(failure);
+        }
+        opening.clear();
+        for (const waiting of calls.values())
+            waiting.fail(failure);
+        calls.clear();
+        drawing?.();
     }
-    function end() {
-        ended = true;
-        const failure = new Error(AUTHORIZATION_ENDED);
-        for (const waiting of acks.values())waiting.fail(failure);
-        acks.clear();
-        for (const waiting of calls.values())waiting.fail(failure);
+    function end(failure) {
+        if (ended !== null)
+            return;
+        ended = failure;
+        for (const waiting of opening.values())
+            waiting.fail(failure);
+        opening.clear();
+        for (const waiting of calls.values())
+            waiting.fail(failure);
         calls.clear();
-        listeners.clear();
+        for (const { handle } of observations.values())
+            handle.end();
+        observations.clear();
+        drawing?.();
     }
-    port.addEventListener('message', (event)=>{
-        const wire = carried(event.data);
-        if (wire === null) return;
-        if (!wire.matching) {
-            refuse(PROTOCOL_MISMATCH);
+    port.addEventListener('message', (event) => {
+        const message = answer(event.data);
+        if (message === null)
             return;
-        }
-        const message = answer(wire.message);
-        if (message === null) return;
         if (message.kind === 'refusal') {
             refuse(message.refusal);
             return;
         }
         if (message.kind === 'ended') {
-            end();
+            for (const { topic, handle } of observations.values()) {
+                if (topic === 'member')
+                    handle.receive(null);
+            }
+            end(runtimeError('authorization-ended', AUTHORIZATION_ENDED));
             return;
         }
         if (message.kind === 'event') {
-            listeners.get(message.id)?.notify(message.value);
+            observations.get(message.id)?.handle.receive(message.value);
             return;
         }
-        const subscribing = acks.get(message.id);
-        if (subscribing !== undefined) {
-            acks.delete(message.id);
+        const waiting = opening.get(message.id);
+        if (waiting !== undefined) {
+            opening.delete(message.id);
             if (message.kind === 'failure') {
-                listeners.delete(message.id);
-                subscribing.fail(new Error(message.message));
-            } else subscribing.settle();
+                waiting.fail(runtimeError(message.code, message.message, message.retryable));
+            }
+            else
+                waiting.settle(begin(message.id, waiting.topic, message.value));
+            drawing?.();
             return;
         }
-        const waiting = calls.get(message.id);
-        if (waiting === undefined) return;
+        const called = calls.get(message.id);
+        if (called === undefined)
+            return;
         calls.delete(message.id);
-        if (message.kind === 'failure') waiting.fail(new Error(message.message));
-        else waiting.settle(message.value);
+        if (message.kind === 'failure') {
+            called.fail(runtimeError(message.code, message.message, message.retryable));
+        }
+        else
+            called.settle(message.value);
     });
-    port.start();
-    send({
-        kind: 'hello'
+    port.addEventListener('close', () => {
+        end(runtimeError('port-closed', PORT_CLOSED));
     });
+    port.start();
+    send({ kind: 'hello' });
     function ask(member, input) {
-        if (ended) return Promise.reject(new Error(AUTHORIZATION_ENDED));
-        if (refusal !== null) return Promise.reject(new Error(refusal.reason));
-        const id = sequence += 1;
-        return new Promise((settle, fail)=>{
-            calls.set(id, {
-                settle: settle,
-                fail
-            });
-            send({
-                kind: 'call',
-                id,
-                member,
-                input
-            });
+        if (ended !== null)
+            return Promise.reject(ended);
+        if (refusal !== null)
+            return Promise.reject(refused(refusal));
+        const id = (sequence += 1);
+        return new Promise((settle, fail) => {
+            calls.set(id, { settle: settle, fail });
+            send({ kind: 'call', id, member, input });
         });
     }
-    function watch(topic, input, notify) {
-        if (ended) return Promise.reject(new Error(AUTHORIZATION_ENDED));
-        const id = sequence += 1;
-        listeners.set(id, {
-            topic,
-            notify
-        });
-        const end = ()=>{
-            if (!listeners.delete(id)) return;
-            if (refusal === null) send({
-                kind: 'stop',
-                id
-            });
-        };
+    function watch(topic, input) {
+        if (ended !== null)
+            return Promise.reject(ended);
+        const id = (sequence += 1);
         if (refusal !== null) {
-            if (topic === 'connection-refusal') notify(refusal);
-            return Promise.resolve(end);
+            return topic === 'connection-refusal'
+                ? Promise.resolve(begin(id, topic, refusal))
+                : Promise.reject(refused(refusal));
         }
-        return new Promise((settle, fail)=>{
-            acks.set(id, {
-                settle: ()=>settle(end),
-                fail
-            });
-            send({
-                kind: 'observe',
-                id,
-                topic,
-                input
-            });
+        return new Promise((settle, fail) => {
+            opening.set(id, { topic, settle, fail });
+            send({ kind: 'observe', id, topic, input });
+            drawing?.();
+        });
+    }
+    function settled() {
+        if (settling !== null)
+            return settling;
+        settling = new Promise((resolve) => {
+            let moved = 0;
+            const check = () => {
+                moved += 1;
+                if (opening.size > 0)
+                    return;
+                const at = moved;
+                requestAnimationFrame(() => {
+                    requestAnimationFrame(() => {
+                        if (moved !== at || opening.size > 0)
+                            return;
+                        drawing = null;
+                        resolve();
+                    });
+                });
+            };
+            drawing = check;
+            check();
         });
+        return settling;
     }
     return {
-        rooms: ()=>ask('rooms', []),
-        query: (options)=>ask('query', [
-                options
-            ]),
-        types: (locator)=>ask('types', [
-                locator
-            ]),
-        syncStatus: ()=>ask('syncStatus', []),
-        draft: {
-            list: ()=>ask('draft.list', []),
-            read: (locator, path)=>ask('draft.read', [
-                    locator,
-                    path
-                ]),
-            replace: (locator, path, content)=>ask('draft.replace', [
-                    locator,
-                    path,
-                    content
-                ]),
-            discard: (locator, path)=>ask('draft.discard', [
-                    locator,
-                    path
-                ])
-        },
-        save: (locator, changes, replacing)=>ask('save', [
-                locator,
-                changes,
-                replacing
-            ]),
-        outcome: (identifier)=>ask('outcome', [
-                identifier
-            ]),
-        queue: {
-            discard: (locator, identifier)=>ask('queue.discard', [
-                    locator,
-                    identifier
-                ])
+        rooms: () => ask('rooms', []),
+        query: ((query) => ask('query', [query])),
+        search: (request) => ask('search', [request]),
+        types: (locator) => ask('types', [locator]),
+        roomDraft: {
+            list: () => ask('roomDraft.list', []),
+            read: (room, path) => ask('roomDraft.read', [room, path]),
+            write: (room, path, revision, parts) => ask('roomDraft.write', [room, path, revision, parts]),
+            discard: (room, path, revision) => ask('roomDraft.discard', [room, path, revision]),
         },
+        save: (room, roomDrafts) => ask('save', [room, roomDrafts]),
         presentation: {
-            read: ()=>ask('presentation.read', []),
-            write: (value)=>ask('presentation.write', [
-                    value
-                ])
+            read: () => ask('presentation.read', []),
+            write: (value) => ask('presentation.write', [value]),
         },
         conversation: {
-            list: ()=>ask('conversation.list', []),
-            read: (conversation)=>ask('conversation.read', [
-                    conversation
-                ]),
-            older: (conversation)=>ask('conversation.older', [
-                    conversation
-                ]),
-            compose: (conversation, instruction)=>ask('conversation.compose', [
-                    conversation,
-                    instruction
-                ]),
-            discard: (conversation)=>ask('conversation.discard', [
-                    conversation
-                ]),
-            create: (input)=>ask('conversation.create', [
-                    input
-                ]),
-            send: (conversation)=>ask('conversation.send', [
-                    conversation
-                ]),
-            answer: (conversation, answer)=>ask('conversation.answer', [
-                    conversation,
-                    answer
-                ]),
-            interrupt: (conversation)=>ask('conversation.interrupt', [
-                    conversation
-                ]),
-            kill: (conversation)=>ask('conversation.kill', [
-                    conversation
-                ]),
-            cancel: (conversation, turn)=>ask('conversation.cancel', [
-                    conversation,
-                    turn
-                ]),
-            delete: (conversation)=>ask('conversation.delete', [
-                    conversation
-                ])
+            list: () => ask('conversation.list', []),
+            read: (conversation, options) => ask('conversation.read', [conversation, options]),
+            create: (input) => ask('conversation.create', [input]),
+            send: (conversation) => ask('conversation.send', [conversation]),
+            answer: (conversation, answer) => ask('conversation.answer', [conversation, answer]),
+            interrupt: (conversation) => ask('conversation.interrupt', [conversation]),
+            kill: (conversation) => ask('conversation.kill', [conversation]),
+            cancel: (conversation, turn) => ask('conversation.cancel', [conversation, turn]),
+            delete: (conversation) => ask('conversation.delete', [conversation]),
         },
-        history: (locator, path, query)=>ask('history', [
-                locator,
-                path,
-                query
-            ]),
-        call: (name, input)=>ask('call', [
-                name,
-                input
-            ]),
-        log: ()=>ask('log', []),
-        storageLoss: ()=>ask('storageLoss', []),
-        persistence: ()=>ask('persistence', []),
-        observe (topic, second, third) {
-            const positional = topic === 'query' || topic === 'queue' || topic === 'conversation';
-            const notify = positional ? third : second;
-            return watch(topic, positional ? [
-                second
-            ] : [], notify);
+        chatDraft: {
+            write: (conversation, draft, revision) => ask('chatDraft.write', [conversation, draft, revision]),
+            discard: (conversation) => ask('chatDraft.discard', [conversation]),
         },
-        reauthorize: ()=>ask('reauthorize', [])
+        history: (locator, path, query) => ask('history', [locator, path, query]),
+        binaryFile: {
+            read: (room, path, revision) => ask('binaryFile.read', [room, path, revision]),
+            readReference: (reference) => ask('binaryFile.readReference', [reference]),
+        },
+        call: (name, input) => ask('call', [name, input]),
+        reached: (locator, roomVersion, path) => ask('reached', [locator, roomVersion, path]),
+        log: () => ask('log', []),
+        persistence: () => ask('persistence', []),
+        observe: ((topic, ...input) => watch(topic, input)),
+        reauthorize: () => ask('reauthorize', []),
+        settled,
     };
 }
-
-//# sourceMappingURL=client.js.map
+const turns = new WeakMap();
+export function inTurn(client, work) {
+    const next = (turns.get(client) ?? Promise.resolve()).then(work).catch(() => undefined);
+    turns.set(client, next);
+    return next;
+}

package/dist/collection.d.ts

@@ -1,21 +1,14 @@
 import { type Document, type Validation } from '@agentshouse/mdmodel';
-import type { Selector } from '@agentshouse/query';
-import type { AttachedModelBinding, ModelState } from './model.js';
+import type { ModelState } from './model.js';
 import type { MdModelIdentity } from './adapter.js';
+import type { Refused } from './transfer.js';
 export declare const MD_MODEL: MdModelIdentity;
-export declare const PRESENTED: Selector;
-export type MdType = {
-    name: string;
-    path: string;
-    fields: Readonly<Record<string, unknown>>;
-    sections: Readonly<Record<string, unknown>>;
-};
 export type Collection = {
-    documents: Readonly<Record<string, Document>>;
+    text: Readonly<Record<string, string>>;
     composition: Composition;
+    document(path: string): Document | undefined;
 };
 export type Composition = {
-    collectionRoot: string;
     model: ModelState;
     selection: {
         roots: readonly string[];
@@ -23,11 +16,10 @@ export type Composition = {
     } | null;
 };
 export declare function governing(composition: Composition, path: string): ModelState;
-export declare function typesAt(composition: Composition, path: string): readonly MdType[];
-export declare function parseCollection(text: Readonly<Record<string, string>>, composition: Composition): Collection;
-export declare function readCollection(text: Readonly<Record<string, string>>, composition: Composition): Collection | null;
+export declare function collectionOf(text: Readonly<Record<string, string>>, composition: Composition, previous?: Collection): Collection;
+export declare function passingDocument(collection: Collection, path: string): Document | undefined;
+export declare function documentsOf(collection: Collection): Generator<readonly [string, Document]>;
+export declare function unreadable(text: Readonly<Record<string, string>>, previous?: Readonly<Record<string, string>>): Refused | null;
 export declare function validRoot(root: unknown): root is string;
-export declare function validateCollection(text: Readonly<Record<string, string>>, binaryTargets: readonly string[], composition: Composition, binding: AttachedModelBinding | null): Validation & {
-    source?: 'content' | 'model';
-};
+export declare function validateCollection(text: Readonly<Record<string, string>>, binaryTargets: readonly string[], composition: Composition): Validation;
 //# sourceMappingURL=collection.d.ts.map

package/dist/collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAChG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,QAAQ,EAAE,eAAwE,CAAC;AAEhG,eAAO,MAAM,SAAS,EAAE,QAAyC,CAAC;AAElE,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1C,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC9C,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE;QAAE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAC;CACnE,CAAC;AASF,wBAAgB,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAI5E;AAED,wBAAgB,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAGjF;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,GACvB,UAAU,CAOZ;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,GACvB,UAAU,GAAG,IAAI,CAenB;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAEvD;AAyCD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,oBAAoB,GAAG,IAAI,GACnC,UAAU,GAAG;IAAE,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAA;CAAE,CA4C/C"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,eAAO,MAAM,QAAQ,EAAE,eAAwE,CAAC;AAIhG,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACvC,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE;QAAE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAC;CACnE,CAAC;AASF,wBAAgB,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAI5E;AAID,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,UAAU,GACpB,UAAU,CAsBZ;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAO1F;AAED,wBAAiB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAY3F;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC1C,OAAO,GAAG,IAAI,CAOhB;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAEvD;AAwBD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,WAAW,EAAE,WAAW,GACvB,UAAU,CA0BZ"}

package/dist/collection.js

@@ -1,115 +1,109 @@
-import { parse, validate, VERSION } from '@agentshouse/mdmodel';
+import { parse, validate, VERSION, } from '@agentshouse/mdmodel';
 import { beneath, normalize } from './paths.js';
-export const MD_MODEL = {
-    identity: '@agentshouse/mdmodel',
-    version: VERSION
-};
-export const PRESENTED = {
-    path: {
-        $regex: '\\.md$'
-    }
-};
+export const MD_MODEL = { identity: '@agentshouse/mdmodel', version: VERSION };
+const NO_TYPES = { types: {} };
 function selected(composition, path) {
-    return composition.selection !== null && composition.selection.roots.some((root)=>beneath(root, path));
+    return (composition.selection !== null &&
+        composition.selection.roots.some((root) => beneath(root, path)));
 }
 export function governing(composition, path) {
-    return composition.selection !== null && selected(composition, path) ? composition.selection.model : composition.model;
-}
-export function typesAt(composition, path) {
-    const model = governing(composition, path);
-    return model.status === 'unavailable' ? [] : model.types;
+    return composition.selection !== null && selected(composition, path)
+        ? composition.selection.model
+        : composition.model;
 }
-export function parseCollection(text, composition) {
-    const documents = {};
-    for (const path of Object.keys(text).sort()){
-        const parsed = parse(text[path], path);
-        if (parsed.ok) documents[path] = parsed.document;
+const parsedIn = new WeakMap();
+export function collectionOf(text, composition, previous) {
+    const parsed = new Map();
+    if (previous !== undefined) {
+        for (const [path, held] of parsedIn.get(previous) ?? []) {
+            if (previous.text[path] === text[path])
+                parsed.set(path, held);
+        }
     }
-    return {
-        documents,
-        composition
+    const collection = {
+        text,
+        composition,
+        document(path) {
+            const held = parsed.get(path);
+            if (held !== undefined)
+                return held ?? undefined;
+            const content = text[path];
+            if (content === undefined)
+                return undefined;
+            const read = parse(content, path);
+            parsed.set(path, read.ok ? read.document : null);
+            return read.ok ? read.document : undefined;
+        },
     };
-}
-export function readCollection(text, composition) {
-    if (!validRoot(composition.collectionRoot)) return null;
-    const collection = parseCollection(text, composition);
-    if (Object.keys(collection.documents).length !== Object.keys(text).length) return null;
-    if (Object.entries(collection.documents).some(([path, document])=>!member(path, composition.collectionRoot) && !selected(composition, path) && document.type !== undefined && document.type !== 'any')) return null;
+    parsedIn.set(collection, parsed);
     return collection;
 }
+export function passingDocument(collection, path) {
+    const held = parsedIn.get(collection)?.get(path);
+    if (held !== undefined)
+        return held ?? undefined;
+    const content = collection.text[path];
+    if (content === undefined)
+        return undefined;
+    const read = parse(content, path);
+    return read.ok ? read.document : undefined;
+}
+export function* documentsOf(collection) {
+    const parsed = parsedIn.get(collection);
+    for (const path of Object.keys(collection.text).sort()) {
+        const held = parsed?.get(path);
+        if (held === null)
+            continue;
+        if (held !== undefined) {
+            yield [path, held];
+            continue;
+        }
+        const read = parse(collection.text[path], path);
+        if (read.ok)
+            yield [path, read.document];
+    }
+}
+export function unreadable(text, previous) {
+    for (const path of Object.keys(text).sort()) {
+        if (previous?.[path] === text[path])
+            continue;
+        const read = parse(text[path], path);
+        if (!read.ok)
+            return { kind: 'refused', refusal: read.refusal };
+    }
+    return null;
+}
 export function validRoot(root) {
     return typeof root === 'string' && normalize(root) === root;
 }
-function member(path, root) {
-    return root === '' || path.startsWith(`${root}/`);
-}
-function validateAgainst(documents, binaryTargets, prefix, model, binding) {
-    if (model.status === 'unavailable' || binding === null) {
-        const typed = Object.entries(documents).find(([, content])=>{
+function validateAgainst(documents, binaryTargets, model) {
+    if (model.status === 'unavailable') {
+        const typed = Object.entries(documents).find(([, content]) => {
             const parsed = parse(content);
             return parsed.ok && parsed.document.type !== undefined && parsed.document.type !== 'any';
         });
-        if (typed !== undefined) return {
-            verdict: 'refuse',
-            rule: 'model-unavailable',
-            file: `${prefix}${typed[0]}`,
-            version: VERSION
-        };
-        return validate(documents, {
-            binaryTargets
-        });
+        if (typed !== undefined)
+            return { verdict: 'refuse', rule: 'model-unavailable', file: typed[0] };
     }
-    const verdict = binding.validate({
-        model: model.snapshot,
-        documents,
-        binaryTargets
-    });
-    if (verdict.verdict === 'refuse' && verdict.source === 'model') return verdict;
-    if (verdict.verdict === 'accept') return verdict;
-    return {
-        ...verdict,
-        file: `${prefix}${verdict.file}`,
-        ...verdict.referrers === undefined ? {} : {
-            referrers: verdict.referrers.map((path)=>`${prefix}${path}`)
-        }
-    };
+    return validate(documents, { binaryTargets }, model.status === 'unavailable' ? NO_TYPES : { types: model.types });
 }
-export function validateCollection(text, binaryTargets, composition, binding) {
-    const prefix = composition.collectionRoot === '' ? '' : `${composition.collectionRoot}/`;
+export function validateCollection(text, binaryTargets, composition) {
     const collection = {};
     const selection = {};
-    for (const [path, content] of Object.entries(text)){
-        if (member(path, composition.collectionRoot)) {
-            collection[path.slice(prefix.length)] = content;
-            continue;
-        }
-        if (selected(composition, path)) {
+    for (const [path, content] of Object.entries(text)) {
+        if (selected(composition, path))
             selection[path] = content;
-            continue;
-        }
-        const parsed = parse(content, path);
-        if (!parsed.ok) return {
-            verdict: 'refuse',
-            ...parsed.refusal
-        };
-        if (Object.hasOwn(parsed.document.fields, 'type') && parsed.document.fields.type !== 'any') {
-            return {
-                verdict: 'refuse',
-                rule: 'outside-collection-type',
-                file: path,
-                version: VERSION
-            };
-        }
+        else
+            collection[path] = content;
     }
     const verdicts = [
-        validateAgainst(collection, binaryTargets.filter((path)=>member(path, composition.collectionRoot)).map((path)=>path.slice(prefix.length)), prefix, composition.model, binding)
+        validateAgainst(collection, binaryTargets.filter((path) => !selected(composition, path)), composition.model),
     ];
     if (composition.selection !== null) {
-        verdicts.push(validateAgainst(selection, binaryTargets.filter((path)=>selected(composition, path)), '', composition.selection.model, binding));
+        verdicts.push(validateAgainst(selection, binaryTargets.filter((path) => selected(composition, path)), composition.selection.model));
     }
-    const refusals = verdicts.filter((verdict)=>verdict.verdict === 'refuse');
-    if (refusals.length === 0) return verdicts[0];
-    return refusals.find((refusal)=>refusal.rule !== 'model-unavailable') ?? refusals[0];
+    const refusals = verdicts.filter((verdict) => verdict.verdict === 'refuse');
+    if (refusals.length === 0)
+        return verdicts[0];
+    return refusals.find((refusal) => refusal.rule !== 'model-unavailable') ?? refusals[0];
 }
-
-//# sourceMappingURL=collection.js.map