@agentshouse/mdruntime 0.1.0-cebcd51f70ed1 → 0.1.0-cedb03eaa48b6

package/dist/client.js

@@ -1,5 +1,11 @@
 import { observed } from './observation.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,6 +13,8 @@ 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(message);
     };
@@ -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,6 +59,7 @@ export function connectMdRuntime(port) {
         for (const { handle } of observations.values())
             handle.end();
         observations.clear();
+        drawing?.();
     }
     port.addEventListener('message', (event) => {
         const message = answer(event.data);
@@ -61,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') {
@@ -71,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 });
@@ -104,17 +120,47 @@ 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', []),
@@ -128,15 +174,17 @@ export function connectMdRuntime(port) {
             discard: (room, path, revision) => ask('roomDraft.discard', [room, path, revision]),
         },
         save: (room, roomDrafts) => ask('save', [room, roomDrafts]),
+        saveParts: (room, parts) => ask('saveParts', [room, parts]),
         presentation: {
             read: () => ask('presentation.read', []),
             write: (value) => ask('presentation.write', [value]),
+            edit: (members) => ask('presentation.edit', [members]),
         },
         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]),
+            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]),
@@ -144,15 +192,30 @@ 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]),
+            prepend: (conversation, draft) => ask('chatDraft.prepend', [conversation, draft]),
             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]),
+            link: (room, path, revision) => ask('binaryFile.link', [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', []),
+        retry: () => ask('retry', []),
         observe: ((topic, ...input) => watch(topic, input)),
         reauthorize: () => ask('reauthorize', []),
+        settled,
     };
 }
+const turns = new WeakMap();
+export function inTurn(client, work) {
+    const turn = (turns.get(client) ?? Promise.resolve()).then(work);
+    turns.set(client, turn.then(() => undefined, () => undefined));
+    return turn;
+}
+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;
@@ -15,16 +18,22 @@ export type Composition = {
     } | null;
 };
 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;CACnE,CAAC;AASF,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,CAOZ;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,CAQpD;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"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"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"}

package/dist/collection.js

@@ -1,5 +1,8 @@
-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, sizeOf } from './shared.js';
+import { after, inUnits, ROW_WEIGHT } from './turn.js';
 export const MD_MODEL = { identity: '@agentshouse/mdmodel', version: VERSION };
 const NO_TYPES = { types: {} };
 function selected(composition, path) {
@@ -11,30 +14,81 @@ export function governing(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);
-}
-export function parseCollection(text, composition, previous) {
-    const documents = {};
-    for (const path of Object.keys(text).sort()) {
-        const parsed = parsedAt(text, path, previous);
-        if (parsed.ok)
-            documents[path] = parsed.document;
+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* documentsOf(collection) {
+    for (const path of Object.keys(collection.text).sort()) {
+        const held = cachedIn(collection, 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];
     }
-    return { documents, composition };
-}
-export function readCollection(text, composition, previous) {
-    const documents = {};
-    for (const path of Object.keys(text).sort()) {
-        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;
@@ -70,3 +124,227 @@ export function validateCollection(text, binaryTargets, composition) {
         return verdicts[0];
     return refusals.find((refusal) => refusal.rule !== 'model-unavailable') ?? refusals[0];
 }
+const NO_REFERRERS = shared({});
+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 referrersOfTarget(index, target) {
+    return Object.hasOwn(index.referrers, target) ? index.referrers[target] : NO_REFERRERS;
+}
+function reindexed(index, changed) {
+    const referrers = new Map();
+    const held = (target) => referrers.get(target) ?? referrersOfTarget(index, target);
+    for (const [path, found] of changed) {
+        const before = Object.hasOwn(index.targets, path) ? index.targets[path] : [];
+        for (const target of before) {
+            if (!found.includes(target))
+                referrers.set(target, patched(held(target), [], [path]));
+        }
+        for (const target of found) {
+            if (!before.includes(target))
+                referrers.set(target, patched(held(target), [[path, true]]));
+        }
+    }
+    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(([, files]) => sizeOf(files) > 0), [...referrers].filter(([, files]) => sizeOf(files) === 0).map(([target]) => target)),
+    };
+}
+function storedIn(entries) {
+    let stored = shared({});
+    let unit = [];
+    return after(inUnits(entries, (entry) => {
+        unit.push(entry);
+        return ROW_WEIGHT;
+    }, () => {
+        stored = patched(stored, unit);
+        unit = [];
+    }), () => stored);
+}
+function storedReferrers(referrers) {
+    const sets = new Map();
+    let unit = new Map();
+    const pairs = function* () {
+        for (const [target, files] of referrers)
+            for (const file of files)
+                yield [target, file];
+    };
+    return after(inUnits(pairs(), ([target, file]) => {
+        const files = unit.get(target);
+        if (files === undefined)
+            unit.set(target, [file]);
+        else
+            files.push(file);
+        return ROW_WEIGHT;
+    }, () => {
+        for (const [target, files] of unit) {
+            sets.set(target, patched(sets.get(target) ?? NO_REFERRERS, files.map((file) => [file, true])));
+        }
+        unit = new Map();
+    }), () => storedIn(sets));
+}
+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) {
+            const files = referrers.get(target);
+            if (files === undefined)
+                referrers.set(target, [path]);
+            else
+                files.push(path);
+        }
+        return ROW_WEIGHT + content.length;
+    });
+    const indexed = after(filled, () => after(storedIn(targets), (storedTargets) => after(storedReferrers(referrers), (stored) => {
+        referrersOf.set(held.text, { composition, targets: storedTargets, referrers: stored });
+    })));
+    if (!(indexed instanceof Promise))
+        return;
+    const building = 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) {
+        for (const file of Object.keys(referrersOfTarget(index, 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.keys(referrersOfTarget(index, 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;
+}