@agentshouse/mdruntime 0.1.0-c3903a68dcbbf → 0.1.0-c3fa75348e547

package/dist/client.js

@@ -1,5 +1,11 @@
 import { observed } from './observation.js';
-import { answer, AUTHORIZATION_ENDED, carried, envelope, PORT_CLOSED, PROTOCOL_MISMATCH, } from './wire.js';
+import { runtimeError } from './failure.js';
+import { answer, AUTHORIZATION_ENDED, PORT_CLOSED, } from './wire.js';
+// React renders an arrived value in a later task and opens what that render observes as it commits, so this many frames opening nothing mean the page drew what it observes.
+const SETTLED_FRAMES = 2;
+function refused(refusal) {
+    return runtimeError(refusal.code, refusal.code, refusal.retryable);
+}
 export function connectMdRuntime(port) {
     let sequence = 0;
     let refusal = null;
@@ -7,8 +13,10 @@ export function connectMdRuntime(port) {
     const calls = new Map();
     const opening = new Map();
     const observations = new Map();
+    let drawing = null;
+    let settling = null;
     const send = (message) => {
-        port.postMessage(envelope(message));
+        port.postMessage(message);
     };
     function begin(id, topic, first) {
         const handle = observed(first, () => {
@@ -25,7 +33,7 @@ export function connectMdRuntime(port) {
             if (topic === 'connection-refusal')
                 handle.receive(reported);
         }
-        const failure = new Error(reported.reason);
+        const failure = refused(reported);
         for (const [id, waiting] of opening) {
             if (waiting.topic === 'connection-refusal')
                 waiting.settle(begin(id, waiting.topic, reported));
@@ -36,12 +44,12 @@ export function connectMdRuntime(port) {
         for (const waiting of calls.values())
             waiting.fail(failure);
         calls.clear();
+        drawing?.();
     }
-    function end(reason) {
+    function end(failure) {
         if (ended !== null)
             return;
-        ended = reason;
-        const failure = new Error(reason);
+        ended = failure;
         for (const waiting of opening.values())
             waiting.fail(failure);
         opening.clear();
@@ -51,16 +59,10 @@ export function connectMdRuntime(port) {
         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);
-            return;
-        }
-        const message = answer(wire.message);
+        const message = answer(event.data);
         if (message === null)
             return;
         if (message.kind === 'refusal') {
@@ -68,7 +70,11 @@ export function connectMdRuntime(port) {
             return;
         }
         if (message.kind === 'ended') {
-            end(AUTHORIZATION_ENDED);
+            for (const { topic, handle } of observations.values()) {
+                if (topic === 'member')
+                    handle.receive(null);
+            }
+            end(runtimeError('authorization-ended', AUTHORIZATION_ENDED));
             return;
         }
         if (message.kind === 'event') {
@@ -78,31 +84,34 @@ export function connectMdRuntime(port) {
         const waiting = opening.get(message.id);
         if (waiting !== undefined) {
             opening.delete(message.id);
-            if (message.kind === 'failure')
-                waiting.fail(new Error(message.message));
+            if (message.kind === 'failure') {
+                waiting.fail(runtimeError(message.code, message.message, message.retryable));
+            }
             else
                 waiting.settle(begin(message.id, waiting.topic, message.value));
+            drawing?.();
             return;
         }
         const called = calls.get(message.id);
         if (called === undefined)
             return;
         calls.delete(message.id);
-        if (message.kind === 'failure')
-            called.fail(new Error(message.message));
+        if (message.kind === 'failure') {
+            called.fail(runtimeError(message.code, message.message, message.retryable));
+        }
         else
             called.settle(message.value);
     });
     port.addEventListener('close', () => {
-        end(PORT_CLOSED);
+        end(runtimeError('port-closed', PORT_CLOSED));
     });
     port.start();
     send({ kind: 'hello' });
     function ask(member, input) {
         if (ended !== null)
-            return Promise.reject(new Error(ended));
+            return Promise.reject(ended);
         if (refusal !== null)
-            return Promise.reject(new Error(refusal.reason));
+            return Promise.reject(refused(refusal));
         const id = (sequence += 1);
         return new Promise((settle, fail) => {
             calls.set(id, { settle: settle, fail });
@@ -111,26 +120,53 @@ export function connectMdRuntime(port) {
     }
     function watch(topic, input) {
         if (ended !== null)
-            return Promise.reject(new Error(ended));
+            return Promise.reject(ended);
         const id = (sequence += 1);
         if (refusal !== null) {
             return topic === 'connection-refusal'
                 ? Promise.resolve(begin(id, topic, refusal))
-                : Promise.reject(new Error(refusal.reason));
+                : Promise.reject(refused(refusal));
         }
         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;
+                const waited = (frames) => {
+                    requestAnimationFrame(() => {
+                        if (frames < SETTLED_FRAMES) {
+                            waited(frames + 1);
+                            return;
+                        }
+                        if (moved !== at || opening.size > 0)
+                            return;
+                        drawing = null;
+                        resolve();
+                    });
+                };
+                waited(1);
+            };
+            drawing = check;
+            check();
+        });
+        return settling;
+    }
     return {
         rooms: () => ask('rooms', []),
-        slots: () => ask('slots', []),
         query: ((query) => ask('query', [query])),
         search: (request) => ask('search', [request]),
         types: (locator) => ask('types', [locator]),
-        syncStatus: () => ask('syncStatus', []),
-        serviceMode: () => ask('serviceMode', []),
         roomDraft: {
             list: () => ask('roomDraft.list', []),
             read: (room, path) => ask('roomDraft.read', [room, path]),
@@ -138,7 +174,6 @@ export function connectMdRuntime(port) {
             discard: (room, path, revision) => ask('roomDraft.discard', [room, path, revision]),
         },
         save: (room, roomDrafts) => ask('save', [room, roomDrafts]),
-        outcome: (identifier) => ask('outcome', [identifier]),
         presentation: {
             read: () => ask('presentation.read', []),
             write: (value) => ask('presentation.write', [value]),
@@ -147,7 +182,7 @@ export function connectMdRuntime(port) {
             list: () => ask('conversation.list', []),
             read: (conversation, options) => ask('conversation.read', [conversation, options]),
             create: (input) => ask('conversation.create', [input]),
-            send: (conversation) => ask('conversation.send', [conversation]),
+            send: (conversation, operation, draft) => ask('conversation.send', [conversation, operation, draft]),
             answer: (conversation, answer) => ask('conversation.answer', [conversation, answer]),
             interrupt: (conversation) => ask('conversation.interrupt', [conversation]),
             kill: (conversation) => ask('conversation.kill', [conversation]),
@@ -155,17 +190,28 @@ export function connectMdRuntime(port) {
             delete: (conversation) => ask('conversation.delete', [conversation]),
         },
         chatDraft: {
-            write: (conversation, draft) => ask('chatDraft.write', [conversation, draft]),
+            write: (conversation, draft, revision) => ask('chatDraft.write', [conversation, draft, revision]),
             discard: (conversation) => ask('chatDraft.discard', [conversation]),
         },
         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', []),
-        storageLoss: () => ask('storageLoss', []),
         persistence: () => ask('persistence', []),
-        deploymentFacts: () => ask('deploymentFacts', []),
+        retry: () => ask('retry', []),
         observe: ((topic, ...input) => watch(topic, input)),
         reauthorize: () => ask('reauthorize', []),
+        settled,
     };
 }
+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;
+}
+export { unanswered } from './wire.js';

package/dist/collection.d.ts

@@ -1,11 +1,14 @@
-import { type Document, type Validation } from '@agentshouse/mdmodel';
-import type { ModelState } from './model.js';
+import { type Document, type Frontmatter, type Validation } from '@agentshouse/mdmodel';
+import { type ModelState } from './model.js';
 import type { MdModelIdentity } from './adapter.js';
+import { type Paths } from './shared.js';
 import type { Refused } from './transfer.js';
+import { type Later } from './turn.js';
 export declare const MD_MODEL: MdModelIdentity;
 export type Collection = {
-    documents: Readonly<Record<string, Document>>;
+    text: Readonly<Record<string, string>>;
     composition: Composition;
+    document(path: string): Document | undefined;
 };
 export type Composition = {
     model: ModelState;
@@ -13,20 +16,24 @@ export type Composition = {
         roots: readonly string[];
         model: ModelState;
     } | null;
-    untypedFolders: readonly string[];
 };
-export declare function untyped(roots: readonly string[], path: string): boolean;
 export declare function governing(composition: Composition, path: string): ModelState;
-type Previous = {
-    text: Readonly<Record<string, string>>;
-    collection: Collection;
-};
-export declare function parseCollection(text: Readonly<Record<string, string>>, composition: Composition, previous?: Previous): Collection;
-export declare function readCollection(text: Readonly<Record<string, string>>, composition: Composition, previous?: Previous): {
-    kind: 'read';
-    collection: Collection;
-} | Refused;
+export declare function collectionOf(text: Readonly<Record<string, string>>, composition: Composition, previous?: Collection): Collection;
+export declare function passingFrontmatter(collection: Collection, path: string): Frontmatter | 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): Validation;
+type Held = {
+    text: Paths<string>;
+    binaries: Paths<unknown>;
+};
+export declare function indexReferrers(held: Held, composition: Composition): Later<void>;
+export declare function referencesIndexed(held: Held, composition: Composition): boolean;
+export declare function referring(held: Held, composition: Composition, targets: Iterable<string>): ReadonlySet<string> | null;
+export declare function available(composition: Composition): boolean;
+export declare function changedCleanly(next: Held, previous: Held & {
+    composition: Composition;
+}, composition: Composition): boolean;
 export {};
 //# 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,EAIL,KAAK,QAAQ,EAEb,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,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,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE;QAAE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAC;IAClE,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC,CAAC;AASF,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvE;AAED,wBAAgB,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAI5E;AAED,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAanF,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,QAAQ,GAClB,UAAU,CAQZ;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,QAAQ,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,GAAG,OAAO,CASpD;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,CA4BZ"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"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"}

package/dist/collection.js

@@ -1,47 +1,94 @@
-import { parse, validate, VERSION, } from '@agentshouse/mdmodel';
+import { checkDocument, parseFrontmatter, references, sectionReferences, target, parse, resolves, validate, VERSION, } from '@agentshouse/mdmodel';
 import { beneath, normalize } from './paths.js';
+import { sameTyping } from './model.js';
+import { differing, patched, shared } from './shared.js';
+import { inUnits, ROW_WEIGHT } from './turn.js';
 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)));
 }
-export function untyped(roots, path) {
-    return roots.some((root) => beneath(root, path));
-}
 export function governing(composition, path) {
     return composition.selection !== null && selected(composition, path)
         ? composition.selection.model
         : composition.model;
 }
-function parsedAt(text, path, previous) {
-    const retained = previous?.collection.documents[path];
-    return retained !== undefined && previous?.text[path] === text[path]
-        ? { ok: true, document: retained }
-        : parse(text[path], path);
+const parsedIn = new WeakMap();
+function carried(previous, text) {
+    const held = parsedIn.get(previous);
+    if (held === undefined)
+        return shared({});
+    const kept = patched(held.base, held.added);
+    held.base = kept;
+    held.added = new Map();
+    return patched(kept, [], differing(previous.text, text));
+}
+function cachedIn(collection, path) {
+    const held = parsedIn.get(collection);
+    if (held === undefined)
+        return undefined;
+    if (held.added.has(path))
+        return held.added.get(path);
+    return Object.hasOwn(held.base, path) ? held.base[path] : undefined;
+}
+export function collectionOf(text, composition, previous) {
+    const parsed = {
+        base: previous === undefined ? shared({}) : carried(previous, text),
+        added: new Map(),
+    };
+    const collection = {
+        text,
+        composition,
+        document(path) {
+            const held = cachedIn(collection, path);
+            if (held !== undefined)
+                return held ?? undefined;
+            const content = text[path];
+            if (content === undefined)
+                return undefined;
+            const read = parse(content, path);
+            parsed.added.set(path, read.ok ? read.document : null);
+            return read.ok ? read.document : undefined;
+        },
+    };
+    parsedIn.set(collection, parsed);
+    return collection;
+}
+export function passingFrontmatter(collection, path) {
+    const held = cachedIn(collection, path);
+    if (held !== undefined)
+        return held ?? undefined;
+    const content = collection.text[path];
+    if (content === undefined)
+        return undefined;
+    const read = parseFrontmatter(content, path);
+    return read.ok ? read.frontmatter : undefined;
 }
-export function parseCollection(text, composition, previous) {
-    const documents = {};
-    for (const path of Object.keys(text).sort()) {
-        if (untyped(composition.untypedFolders, path))
+export function* documentsOf(collection) {
+    for (const path of Object.keys(collection.text).sort()) {
+        const held = cachedIn(collection, path);
+        if (held === null)
             continue;
-        const parsed = parsedAt(text, path, previous);
-        if (parsed.ok)
-            documents[path] = parsed.document;
+        if (held !== undefined) {
+            yield [path, held];
+            continue;
+        }
+        const read = parse(collection.text[path], path);
+        if (read.ok)
+            yield [path, read.document];
     }
-    return { documents, composition };
 }
-export function readCollection(text, composition, previous) {
-    const documents = {};
-    for (const path of Object.keys(text).sort()) {
-        if (untyped(composition.untypedFolders, path))
-            continue;
-        const parsed = parsedAt(text, path, previous);
-        if (!parsed.ok)
-            return { kind: 'refused', refusal: parsed.refusal };
-        documents[path] = parsed.document;
+export function unreadable(text, previous) {
+    const paths = previous === undefined
+        ? Object.keys(text)
+        : [...differing(previous, text)].filter((path) => text[path] !== undefined);
+    for (const path of paths.sort()) {
+        const read = parse(text[path], path);
+        if (!read.ok)
+            return { kind: 'refused', refusal: read.refusal };
     }
-    return { kind: 'read', collection: { documents, composition } };
+    return null;
 }
 export function validRoot(root) {
     return typeof root === 'string' && normalize(root) === root;
@@ -61,22 +108,213 @@ export function validateCollection(text, binaryTargets, composition) {
     const collection = {};
     const selection = {};
     for (const [path, content] of Object.entries(text)) {
-        if (untyped(composition.untypedFolders, path))
-            continue;
         if (selected(composition, path))
             selection[path] = content;
         else
             collection[path] = content;
     }
-    const linked = binaryTargets.filter((path) => !untyped(composition.untypedFolders, path));
     const verdicts = [
-        validateAgainst(collection, linked.filter((path) => !selected(composition, path)), composition.model),
+        validateAgainst(collection, binaryTargets.filter((path) => !selected(composition, path)), composition.model),
     ];
     if (composition.selection !== null) {
-        verdicts.push(validateAgainst(selection, linked.filter((path) => selected(composition, path)), composition.selection.model));
+        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 referrersOf = new WeakMap();
+function typing(left, right) {
+    return (sameTyping(left.model, right.model) &&
+        (left.selection === null || right.selection === null
+            ? left.selection === right.selection
+            : sameTyping(left.selection.model, right.selection.model)) &&
+        JSON.stringify(left.selection?.roots ?? null) === JSON.stringify(right.selection?.roots ?? null));
+}
+function declared(content) {
+    if (content === undefined)
+        return undefined;
+    const read = parseFrontmatter(content);
+    return read.ok ? (read.frontmatter.type ?? 'any') : undefined;
+}
+function typedIn(content) {
+    const type = declared(content);
+    return type !== undefined && type !== 'any';
+}
+function modelOf(composition, path) {
+    const model = governing(composition, path);
+    return model.status === 'unavailable' ? null : { types: model.types };
+}
+function checked(path, content, composition) {
+    return checkDocument(path, content, modelOf(composition, path) ?? NO_TYPES);
+}
+function targetsOf(check) {
+    if (!check.ok)
+        return [];
+    return [...new Set(check.references.flatMap(({ target }) => (target === null ? [] : [target])))];
+}
+function referencedBy(path, content, composition) {
+    const model = modelOf(composition, path);
+    if (model === null)
+        return [];
+    const read = parseFrontmatter(content, path);
+    const type = read.ok ? read.frontmatter.type : undefined;
+    if (!read.ok || type === undefined || !Object.hasOwn(model.types, type))
+        return [];
+    const definition = model.types[type];
+    return [
+        ...new Set([
+            ...references(read.frontmatter, definition).flatMap(({ value }) => {
+                const found = target(path, value);
+                return found === null ? [] : [found];
+            }),
+            ...sectionReferences(path, content, definition).flatMap(({ target }) => target === null ? [] : [target]),
+        ]),
+    ];
+}
+function reindexed(index, changed) {
+    const referrers = new Map();
+    const touch = (target) => {
+        let held = referrers.get(target);
+        if (held === undefined) {
+            held = new Set(Object.hasOwn(index.referrers, target) ? index.referrers[target] : []);
+            referrers.set(target, held);
+        }
+        return held;
+    };
+    for (const [path, found] of changed) {
+        const before = Object.hasOwn(index.targets, path) ? index.targets[path] : [];
+        for (const target of before)
+            touch(target).delete(path);
+        for (const target of found)
+            touch(target).add(path);
+    }
+    const emptied = [...referrers].filter(([, held]) => held.size === 0).map(([target]) => target);
+    return {
+        composition: index.composition,
+        targets: patched(index.targets, [...changed].filter(([, found]) => found.length > 0), [...changed].filter(([, found]) => found.length === 0).map(([path]) => path)),
+        referrers: patched(index.referrers, [...referrers]
+            .filter(([, held]) => held.size > 0)
+            .map(([target, held]) => [target, [...held]]), emptied),
+    };
+}
+function heldIndex(held, composition) {
+    const index = referrersOf.get(held.text);
+    return index !== undefined && typing(index.composition, composition) ? index : null;
+}
+const indexing = new WeakMap();
+export function indexReferrers(held, composition) {
+    if (heldIndex(held, composition) !== null)
+        return;
+    const running = indexing.get(held.text);
+    if (running !== undefined)
+        return running;
+    const targets = new Map();
+    const referrers = new Map();
+    const filled = inUnits(Object.keys(held.text), (path) => {
+        const content = held.text[path];
+        const found = referencedBy(path, content, composition);
+        if (found.length > 0)
+            targets.set(path, found);
+        for (const target of found)
+            referrers.set(target, [...(referrers.get(target) ?? []), path]);
+        return ROW_WEIGHT + content.length;
+    });
+    const indexed = () => {
+        referrersOf.set(held.text, {
+            composition,
+            targets: patched(shared({}), targets),
+            referrers: patched(shared({}), referrers),
+        });
+    };
+    if (!(filled instanceof Promise))
+        return indexed();
+    const building = filled.then(indexed).finally(() => indexing.delete(held.text));
+    indexing.set(held.text, building);
+    return building;
+}
+export function referencesIndexed(held, composition) {
+    return heldIndex(held, composition) !== null;
+}
+export function referring(held, composition, targets) {
+    const index = heldIndex(held, composition);
+    if (index === null)
+        return null;
+    const found = new Set();
+    for (const target of targets) {
+        if (!Object.hasOwn(index.referrers, target))
+            continue;
+        for (const file of index.referrers[target])
+            found.add(file);
+    }
+    return found;
+}
+export function available(composition) {
+    return (composition.model.status !== 'unavailable' &&
+        (composition.selection === null || composition.selection.model.status !== 'unavailable'));
+}
+export function changedCleanly(next, previous, composition) {
+    if (!typing(previous.composition, composition))
+        return false;
+    const paths = new Set([
+        ...differing(previous.text, next.text),
+        ...differing(previous.binaries, next.binaries, () => true),
+    ]);
+    const binary = (path) => Object.hasOwn(next.binaries, path);
+    const within = (file) => (path) => selected(composition, path) === selected(composition, file);
+    const reaching = (file, check) => {
+        if (!check.ok)
+            return false;
+        const part = within(file);
+        return check.references.every((reference) => resolves(reference, (path) => (part(path) ? declared(next.text[path]) : undefined), (path) => part(path) && binary(path)));
+    };
+    const changedTargets = new Map();
+    const shifted = [];
+    for (const path of paths) {
+        const now = next.text[path];
+        const was = previous.text[path];
+        const modeled = modelOf(composition, path) !== null;
+        if ((now === undefined) !== (was === undefined) ||
+            declared(now) !== declared(was) ||
+            binary(path) !== Object.hasOwn(previous.binaries, path)) {
+            shifted.push(path);
+        }
+        if (!modeled && typedIn(was) && !typedIn(now))
+            return false;
+        if (now === undefined) {
+            if (modeled)
+                changedTargets.set(path, []);
+            continue;
+        }
+        if (binary(path))
+            return false;
+        if (!modeled) {
+            if (declared(now) === undefined)
+                return false;
+            if (!typedIn(now) && !checked(path, now, composition).ok)
+                return false;
+            continue;
+        }
+        const check = checked(path, now, composition);
+        if (!reaching(path, check))
+            return false;
+        changedTargets.set(path, targetsOf(check));
+    }
+    const index = heldIndex(previous, composition);
+    if (index === null && shifted.length > 0)
+        return false;
+    for (const target of shifted) {
+        const files = index !== null && Object.hasOwn(index.referrers, target) ? index.referrers[target] : [];
+        for (const file of files) {
+            if (paths.has(file))
+                continue;
+            if (!reaching(file, checked(file, next.text[file], composition)))
+                return false;
+        }
+    }
+    if (index !== null) {
+        referrersOf.set(next.text, changedTargets.size === 0 ? index : reindexed(index, changedTargets));
+    }
+    return true;
+}