@agentshouse/mdruntime 0.1.0-cedb03eaa48b6 → 0.1.0-cedd665dffa4c

package/dist/search.js

@@ -1,270 +1,14 @@
-import MiniSearch from 'minisearch';
-import { indexGeneration } from './identity.js';
-import { flag, invalid, known, limitOf, plain, } from './query.js';
-import { beneath } from './paths.js';
-import { inUnits, ROW_WEIGHT } from './turn.js';
-import { decodedCursor } from './windows.js';
-export function undeclaredSearch() {
-    return {
-        kind: 'undeclared',
-        code: 'search-undeclared',
-        fields: { name: 'local_search' },
-        retryable: false,
-    };
-}
-const FIELDS = ['fields', 'sections', 'preamble', 'path', 'text'];
-function documentId(room, path) {
-    return JSON.stringify(['document', room, path]);
-}
-function messageId(conversation, identity) {
-    return JSON.stringify(['message', conversation, identity]);
-}
-function scalars(value) {
-    if (value === null || value === undefined)
-        return [];
-    if (Array.isArray(value))
-        return value.flatMap(scalars);
-    if (typeof value === 'object')
-        return Object.values(value).flatMap(scalars);
-    return [String(value)];
-}
-function hitCursor(input) {
-    if (input === null)
-        return null;
-    if (!Array.isArray(input))
-        return undefined;
-    if (input.length === 0)
-        return [];
-    const [score, first, second] = input;
-    return input.length === 3 &&
-        typeof score === 'number' &&
-        typeof first === 'string' &&
-        typeof second === 'string'
-        ? [score, first, second]
-        : undefined;
-}
-function searchAfter(input) {
-    if (input === undefined)
-        return null;
-    const decoded = typeof input === 'string' ? decodedCursor(input) : null;
-    const documents = decoded?.length === 2 ? hitCursor(decoded[0]) : undefined;
-    const messages = decoded?.length === 2 ? hitCursor(decoded[1]) : undefined;
-    if (documents === undefined || messages === undefined) {
-        invalid('after', 'expects the next an earlier search returned');
-    }
-    return [documents, messages];
-}
+import { invalid, known, plain } from '@agentshouse/mdmodel';
 export function searchPlanOf(input) {
     if (!plain(input))
         invalid('search', 'expects a search object');
-    known(input, ['text', 'documents', 'collection', 'conversations', 'limit', 'after', 'total'], '');
-    if (typeof input.text !== 'string')
-        invalid('text', 'expects text');
-    const conversations = input.conversations;
-    if (conversations !== undefined &&
-        (!Array.isArray(conversations) || conversations.some((named) => typeof named !== 'string'))) {
-        invalid('conversations', 'expects a list of conversations');
-    }
-    return {
-        text: input.text,
-        documents: input.documents,
-        collection: flag(input.collection, 'collection'),
-        conversations: conversations ?? null,
-        limit: limitOf(input.limit),
-        after: searchAfter(input.after),
-        total: flag(input.total, 'total'),
-    };
-}
-function pair(left, right) {
-    if (left[0] !== right[0])
-        return left[0] < right[0] ? -1 : 1;
-    if (left[1] !== right[1])
-        return left[1] < right[1] ? -1 : 1;
-    return 0;
-}
-function hitWindow(found, cursor, limit, tie) {
-    if (cursor === null)
-        return { kept: [], cursor: null };
-    const start = cursor.length === 0
-        ? 0
-        : found.findIndex((hit) => hit.score < cursor[0] ||
-            (hit.score === cursor[0] && pair(tie(hit), [cursor[1], cursor[2]]) > 0));
-    const following = start === -1 ? [] : found.slice(start);
-    if (limit === null || following.length <= limit)
-        return { kept: following, cursor: null };
-    const kept = following.slice(0, limit);
-    const last = kept[kept.length - 1];
-    return { kept, cursor: last === undefined ? cursor : [last.score, ...tie(last)] };
-}
-export function createSearchIndex(source) {
-    const generation = indexGeneration();
-    const index = new MiniSearch({ fields: FIELDS });
-    const documents = new Map();
-    const messages = new Map();
-    const rooms = new Set();
-    const filling = new Set();
-    const conversations = new Set();
-    const acquiring = new Set();
-    const changedDocuments = new Map();
-    let changes = 0;
-    function addDocument(document) {
-        const id = documentId(document.room, document.path);
-        discard(id, documents);
-        index.add({
-            id,
-            fields: scalars(document.fields).join('\n'),
-            sections: Object.entries(document.sections)
-                .map(([heading, text]) => `${heading}\n${text}`)
-                .join('\n'),
-            preamble: document.preamble,
-            path: document.path,
-        });
-        documents.set(id, { room: document.room, path: document.path, type: document.type });
-    }
-    function addMessage(message) {
-        const id = messageId(message.conversation, message.identity);
-        discard(id, messages);
-        index.add({ id, text: message.text });
-        messages.set(id, { conversation: message.conversation, identity: message.identity });
-    }
-    function discard(id, entries) {
-        if (entries.delete(id))
-            index.discard(id);
-    }
-    function* pending() {
-        for (;;) {
-            const next = changedDocuments.entries().next();
-            if (next.done === true)
-                return;
-            changedDocuments.delete(next.value[0]);
-            yield next.value;
-        }
-    }
-    let catching = null;
-    function caughtUp() {
-        if (catching !== null)
-            return catching;
-        const running = inUnits(pending(), ([id, { room, path }]) => {
-            discard(id, documents);
-            const document = source.document(room, path);
-            if (document === null)
-                return ROW_WEIGHT;
-            addDocument(document);
-            return Object.values(document.sections).reduce((total, text) => total + text.length, ROW_WEIGHT + document.preamble.length);
-        });
-        if (!(running instanceof Promise))
-            return Promise.resolve();
-        catching = running.finally(() => {
-            catching = null;
-        });
-        return catching;
-    }
-    function ranked(text, entries, keep, tie) {
-        const found = index.search(text, {
-            filter: ({ id }) => {
-                const entry = entries.get(id);
-                return entry !== undefined && keep(entry, id);
-            },
-        });
-        found.sort((left, right) => right.score - left.score ||
-            pair(tie(entries.get(left.id)), tie(entries.get(right.id))));
-        return found.map(({ id, score, match }) => ({
-            ...entries.get(id),
-            score,
-            match,
-        }));
-    }
-    return {
-        generation: () => generation,
-        rooms: () => rooms,
-        conversations: () => conversations,
-        async indexRoom(room) {
-            if (rooms.has(room) || filling.has(room))
-                return;
-            filling.add(room);
-            try {
-                await inUnits(source.room(room), (path) => {
-                    const document = filling.has(room) ? source.document(room, path) : null;
-                    if (document === null)
-                        return ROW_WEIGHT;
-                    addDocument(document);
-                    return Object.values(document.sections).reduce((total, text) => total + text.length, ROW_WEIGHT + document.preamble.length);
-                });
-                if (filling.has(room))
-                    rooms.add(room);
-            }
-            finally {
-                filling.delete(room);
-            }
-        },
-        indexMessages(conversation, arriving, whole) {
-            for (const message of arriving)
-                addMessage(message);
-            if (!whole) {
-                acquiring.add(conversation);
-                return;
-            }
-            acquiring.delete(conversation);
-            conversations.add(conversation);
-        },
-        forget(leaving) {
-            const gone = new Set(leaving);
-            for (const [id, entry] of documents)
-                if (gone.has(entry.room))
-                    discard(id, documents);
-            for (const room of leaving) {
-                rooms.delete(room);
-                filling.delete(room);
-            }
-        },
-        changed(set) {
-            changes += 1;
-            for (const { locator, path } of set.documents) {
-                if (rooms.has(locator) || filling.has(locator)) {
-                    changedDocuments.set(documentId(locator, path), { room: locator, path });
-                }
-            }
-            for (const { conversation, identity, text } of set.messages) {
-                if (!conversations.has(conversation) && !acquiring.has(conversation))
-                    continue;
-                const id = messageId(conversation, identity);
-                if (text === null)
-                    discard(id, messages);
-                else
-                    addMessage({ conversation, identity, text });
-            }
-        },
-        changes: () => changes,
-        caughtUp,
-        search({ text, limit, after, total }, selected, named, within, selections) {
-            const chosen = selected === null
-                ? null
-                : new Set(selected.map(({ room, path }) => documentId(room, path)));
-            const asked = new Set(named);
-            const documentTie = ({ room, path }) => [room, path];
-            const messageTie = ({ conversation, identity }) => [conversation, identity];
-            const foundDocuments = ranked(text, documents, ({ room, path }, id) => (chosen === null || chosen.has(id)) &&
-                (within === null || within.has(room)) &&
-                !(selections?.get(room) ?? []).some((root) => beneath(root, path)), documentTie);
-            const foundMessages = ranked(text, messages, ({ conversation }) => asked.has(conversation), messageTie);
-            const [documentsAfter, messagesAfter] = after ?? [[], []];
-            const documentWindow = hitWindow(foundDocuments, documentsAfter, limit, documentTie);
-            const messageWindow = hitWindow(foundMessages, messagesAfter, limit, messageTie);
-            const more = documentWindow.cursor !== null || messageWindow.cursor !== null;
-            return {
-                documents: documentWindow.kept.map(({ match, ...hit }) => ({
-                    ...hit,
-                    matches: match,
-                })),
-                messages: messageWindow.kept.map(({ match, ...hit }) => ({
-                    ...hit,
-                    matches: match,
-                })),
-                ...(more ? { next: JSON.stringify([documentWindow.cursor, messageWindow.cursor]) } : {}),
-                ...(total
-                    ? { total: { documents: foundDocuments.length, messages: foundMessages.length } }
-                    : {}),
-            };
-        },
-    };
+    known(input, ['text', 'rooms'], '');
+    if (typeof input.text !== 'string' || input.text.trim() === '')
+        invalid('text', 'expects words');
+    const rooms = input.rooms;
+    if (rooms !== undefined &&
+        (!Array.isArray(rooms) || rooms.some((named) => typeof named !== 'string'))) {
+        invalid('rooms', 'expects a list of Rooms');
+    }
+    return { text: input.text, rooms: rooms ?? null };
 }

package/dist/seed.d.ts

@@ -1,5 +1,9 @@
-import type { KeyedResult } from './observation.js';
-import type { QueryRows } from './query.js';
+import type { Cover } from './live.js';
+import { type KeyedResult } from './observation.js';
+import type { Plan, QueryRows } from './query.js';
+import type { Deliver } from './reach.js';
+import type { Runtime } from './runtime.js';
+import type { HeldCover, Store } from './store.js';
 export type EntrySeed = {
     readonly at: Readonly<Record<string, string>>;
     readonly queries: readonly {
@@ -11,6 +15,11 @@ export type Seeded = {
     readonly rows: QueryRows;
     readonly at: Readonly<Record<string, string>>;
 };
+type SeededWatch = (coverOf: (cover: Cover, held: HeldCover) => Cover, deliver: (message: unknown) => void) => () => void;
 export declare function entrySeedOf(value: unknown): EntrySeed | null;
 export declare function seededResult(seed: Seeded): KeyedResult;
+export declare function seedApplies(runtime: Runtime, plan: Plan, held: HeldCover): Seeded | null;
+export declare function keepEntrySeed(store: Store, entry: EntrySeed): void;
+export declare function watchSeeded(runtime: Runtime, plan: Plan, deliver: Deliver, watch: SeededWatch): () => void;
+export {};
 //# sourceMappingURL=seed.d.ts.map

package/dist/seed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAA4C,SAAS,EAAE,MAAM,YAAY,CAAC;AAGtF,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;KAAE,EAAE,CAAC;CACpF,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC;AAwCjG,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAe5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAoBtD"}
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAwB,KAAK,WAAW,EAAqB,MAAM,kBAAkB,CAAC;AAC7F,OAAO,KAAK,EAAE,IAAI,EAA4C,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;KAAE,EAAE,CAAC;CACpF,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC;AAEjG,KAAK,WAAW,GAAG,CACjB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,KAAK,EACjD,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KAChC,MAAM,IAAI,CAAC;AA0ChB,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAe5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAmBtD;AA+BD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAOxF;AAYD,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAMlE;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,WAAW,GACjB,MAAM,IAAI,CA4BZ"}

package/dist/seed.js

@@ -1,4 +1,7 @@
+import { queryKey } from '@agentshouse/mdmodel';
+import { pendingChange, whole } from './observation.js';
 import { documentKey } from './rows.js';
+const seedTopic = (key) => `seed\u0000${key}`;
 function plain(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -59,7 +62,6 @@ export function seededResult(seed) {
             generation,
             current: false,
         })),
-        indexes: [],
         overlay: [],
     };
     if ('groups' in seed.rows) {
@@ -73,3 +75,71 @@ export function seededResult(seed) {
         keys: seed.rows.documents.map((document) => documentKey(document.room, document.path)),
     };
 }
+function seedRoomHeld({ socket }, room, version, held) {
+    const stored = held.rooms.get(room);
+    return (stored !== undefined &&
+        stored.indexed &&
+        socket.reads.reached(room, stored.roomVersion, version));
+}
+function seedHeld(runtime, at, held) {
+    const { socket, presence } = runtime;
+    return Object.entries(at).every(([room, version]) => (socket.session.now().roomsListed &&
+        presence.room(room) === undefined &&
+        !held.rooms.has(room)) ||
+        seedRoomHeld(runtime, room, version, held));
+}
+export function seedApplies(runtime, plan, held) {
+    const { seeds } = runtime.store;
+    const seed = seeds.of(plan.key);
+    if (seed === undefined)
+        return null;
+    if (!seedHeld(runtime, seed.at, held))
+        return seed;
+    seeds.drop(plan.key);
+    return null;
+}
+function seedBehind(runtime, plan, cover, held) {
+    const seed = seedApplies(runtime, plan, held);
+    if (seed === null || 'pending' in cover)
+        return cover;
+    return {
+        pending: Object.entries(seed.at)
+            .filter(([room, version]) => !seedRoomHeld(runtime, room, version, held))
+            .map(([room]) => ({ room, awaits: 'acquisition' })),
+    };
+}
+export function keepEntrySeed(store, entry) {
+    for (const { query, rows } of entry.queries) {
+        const key = queryKey(query);
+        store.seeds.keep(key, { rows, at: entry.at });
+        for (const watcher of store.watching(seedTopic(key)))
+            watcher.answer(null);
+    }
+}
+export function watchSeeded(runtime, plan, deliver, watch) {
+    const { store } = runtime;
+    let seeded = false;
+    let pending = true;
+    const shown = () => {
+        const seed = store.seeds.of(plan.key);
+        if (seed === undefined || seeded || !pending)
+            return;
+        seeded = true;
+        deliver(seededResult(seed));
+    };
+    const watcher = store.watch(seedTopic(plan.key), shown);
+    const stop = watch((cover, held) => seedBehind(runtime, plan, cover, held), (message) => {
+        const answered = message;
+        pending = whole(answered) ? 'pending' in answered.result : pendingChange(answered);
+        if (pending && store.seeds.of(plan.key) !== undefined) {
+            shown();
+            return;
+        }
+        seeded = false;
+        deliver(message);
+    });
+    return () => {
+        watcher.stop();
+        stop();
+    };
+}

package/dist/shared.d.ts

@@ -1,11 +1,10 @@
 export type Paths<V> = Readonly<Record<string, V>>;
-type Weigh<V> = (key: string, value: V) => number;
-export declare function shared<V>(map: Paths<V>): Paths<V>;
-export declare function patched<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Paths<V>;
-export declare function tally<V>(map: Paths<V>, weigh: Weigh<V>): number;
-export declare function sizeOf<V>(map: Paths<V>): number;
-export declare function differing<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): ReadonlySet<string>;
+export declare function guarding<V>(values: Paths<V>, handler: ProxyHandler<Paths<V>>): Paths<V>;
+export declare function entriesIn<V>(map: Paths<V>): Generator<readonly [string, V]>;
+export declare function sortedKeys(map: Paths<unknown>): Generator<number, readonly string[], void>;
+export declare function sorting(keys: Iterable<string>): Generator<number, readonly string[], void>;
+export declare function patching<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Generator<number, Paths<V>, void>;
 export declare function drafted<V>(base: Paths<V>): Record<string, V>;
 export declare function settled<V>(draft: Record<string, V>): Paths<V>;
-export {};
+export declare function settling<V>(draft: Record<string, V>): Generator<number, Paths<V>, void>;
 //# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAkBnD,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;AA6LlD,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAEjD;AAED,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EACnC,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAM,GAC7B,KAAK,CAAC,CAAC,CAAC,CA8BV;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAY/D;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAE/C;AAuCD,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,GAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAmB,GAC/C,WAAW,CAAC,MAAM,CAAC,CAcrB;AAMD,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAiD5D;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAS7D"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AA8LnD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAIvF;AAED,wBAAiB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAQ5E;AAqCD,wBAAiB,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,CAE3F;AAED,wBAAiB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,CAoB3F;AAED,wBAAiB,QAAQ,CAAC,CAAC,EACzB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EACnC,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAM,GAC7B,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAgBnC;AAMD,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAiD5D;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE7D;AAED,wBAAiB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAUxF"}

package/dist/shared.js

@@ -1,7 +1,7 @@
+import { finished, ROW_WEIGHT } from './turn.js';
 const BITS = 5;
 const MASK = (1 << BITS) - 1;
 const roots = new WeakMap();
-const tallies = new WeakMap();
 function hashOf(key) {
     let hash = 0x811c9dc5;
     for (let index = 0; index < key.length; index += 1) {
@@ -100,21 +100,15 @@ function lone(node) {
 }
 function taken(node, hash, key, shift) {
     if (isLeaf(node))
-        return node.key === key ? undefined : node;
+        return undefined;
     if (isCollision(node)) {
         const leaves = node.leaves.filter((leaf) => leaf.key !== key);
-        if (leaves.length === node.leaves.length)
-            return node;
         return leaves.length === 1 ? leaves[0] : { hash: node.hash, leaves };
     }
     const bit = 1 << fragment(hash, shift);
-    if ((node.bitmap & bit) === 0)
-        return node;
     const at = slot(node.bitmap, bit);
     const child = node.children[at];
     const next = taken(child, hash, key, shift + BITS);
-    if (next === child)
-        return node;
     if (next === undefined) {
         if (node.children.length === 1)
             return undefined;
@@ -179,122 +173,95 @@ function facade(root) {
     roots.set(map, root);
     return map;
 }
-function rootOf(map) {
+const guarded = new WeakMap();
+export function guarding(values, handler) {
+    const map = new Proxy(values, handler);
+    guarded.set(map, values);
+    return map;
+}
+export function* entriesIn(map) {
+    const root = roots.get(map);
+    if (root === undefined) {
+        const values = guarded.get(map) ?? map;
+        for (const key of Object.keys(values))
+            yield [key, values[key]];
+        return;
+    }
+    for (const leaf of leavesOf(root.node))
+        yield [leaf.key, leaf.value];
+}
+function* rooted(map) {
     const held = roots.get(map);
     if (held !== undefined)
         return held;
     let node;
-    let size = 0;
-    for (const [key, value] of Object.entries(map)) {
+    for (const [key, value] of entriesIn(map)) {
         node = put(node, { key, hash: hashOf(key), value }, 0);
-        size += 1;
+        yield ROW_WEIGHT;
     }
-    return { node, size };
+    return { node };
 }
-export function shared(map) {
-    return roots.has(map) ? map : facade(rootOf(map));
+const RUN = 1 << 10;
+function* merged(left, right) {
+    const into = [];
+    let at = 0;
+    let from = 0;
+    while (at < left.length || from < right.length) {
+        into.push(from === right.length || (at < left.length && left[at] < right[from])
+            ? left[at++]
+            : right[from++]);
+        yield ROW_WEIGHT;
+    }
+    return into;
 }
-export function patched(base, set, removed = []) {
-    const root = rootOf(base);
-    const weighed = [...(tallies.get(base) ?? [])];
-    let node = root.node;
-    let size = root.size;
-    const shift = (key, before, after) => {
-        for (const entry of weighed) {
-            entry[1] +=
-                (after === undefined ? 0 : entry[0](key, after)) -
-                    (before === undefined ? 0 : entry[0](key, before.value));
+function* pathsOf(map) {
+    for (const [key] of entriesIn(map))
+        yield key;
+}
+export function* sortedKeys(map) {
+    return yield* sorting(pathsOf(map));
+}
+export function* sorting(keys) {
+    let runs = [];
+    let run = [];
+    for (const key of keys) {
+        run.push(key);
+        yield ROW_WEIGHT;
+        if (run.length === RUN) {
+            runs.push(run.sort());
+            run = [];
         }
-    };
+    }
+    if (run.length > 0)
+        runs.push(run.sort());
+    while (runs.length > 1) {
+        const next = [];
+        for (let at = 0; at < runs.length; at += 2) {
+            next.push(at + 1 === runs.length ? runs[at] : yield* merged(runs[at], runs[at + 1]));
+        }
+        runs = next;
+    }
+    return runs[0] ?? [];
+}
+export function* patching(base, set, removed = []) {
+    const root = yield* rooted(base);
+    let node = root.node;
     for (const key of removed) {
         if (node === undefined)
             break;
-        const before = lookup({ node, size }, key);
+        const before = lookup({ node }, key);
         if (before === undefined)
             continue;
         node = taken(node, before.hash, key, 0);
-        size -= 1;
-        shift(key, before, undefined);
+        yield ROW_WEIGHT;
     }
     for (const [key, value] of set) {
-        const before = lookup({ node, size }, key);
         node = put(node, { key, hash: hashOf(key), value }, 0);
-        if (before === undefined)
-            size += 1;
-        shift(key, before, value);
+        yield ROW_WEIGHT;
     }
     if (node === root.node && roots.has(base))
         return base;
-    const map = facade({ node, size });
-    if (weighed.length > 0)
-        tallies.set(map, new Map(weighed));
-    return map;
-}
-export function tally(map, weigh) {
-    const held = tallies.get(map);
-    const known = held?.get(weigh);
-    if (known !== undefined)
-        return known;
-    let total = 0;
-    for (const [key, value] of Object.entries(map))
-        total += weigh(key, value);
-    if (roots.has(map)) {
-        const kept = held ?? new Map();
-        kept.set(weigh, total);
-        tallies.set(map, kept);
-    }
-    return total;
-}
-export function sizeOf(map) {
-    return roots.get(map)?.size ?? Object.keys(map).length;
-}
-function collect(node, into) {
-    for (const leaf of leavesOf(node))
-        into.add(leaf.key);
-}
-function compared(left, right, shift, same, into) {
-    if (left === right)
-        return;
-    if (left === undefined)
-        return collect(right, into);
-    if (right === undefined)
-        return collect(left, into);
-    if (!isLeaf(left) && !isCollision(left) && !isLeaf(right) && !isCollision(right)) {
-        const bits = left.bitmap | right.bitmap;
-        for (let remaining = bits; remaining !== 0; remaining &= remaining - 1) {
-            const bit = remaining & -remaining;
-            compared((left.bitmap & bit) === 0 ? undefined : left.children[slot(left.bitmap, bit)], (right.bitmap & bit) === 0 ? undefined : right.children[slot(right.bitmap, bit)], shift + BITS, same, into);
-        }
-        return;
-    }
-    const before = new Map([...leavesOf(left)].map((leaf) => [leaf.key, leaf.value]));
-    for (const leaf of leavesOf(right)) {
-        const held = before.get(leaf.key);
-        before.delete(leaf.key);
-        if (held === undefined || !same(held, leaf.value))
-            into.add(leaf.key);
-    }
-    for (const key of before.keys())
-        into.add(key);
-}
-export function differing(left, right, same = Object.is) {
-    const into = new Set();
-    if (left === right)
-        return into;
-    const leftRoot = roots.get(left);
-    const rightRoot = roots.get(right);
-    if (leftRoot !== undefined && rightRoot !== undefined) {
-        compared(leftRoot.node, rightRoot.node, 0, same, into);
-        return into;
-    }
-    for (const key of Object.keys(left)) {
-        if (!Object.hasOwn(right, key) || !same(left[key], right[key]))
-            into.add(key);
-    }
-    for (const key of Object.keys(right))
-        if (!Object.hasOwn(left, key))
-            into.add(key);
-    return into;
+    return facade({ node });
 }
 const drafts = new WeakMap();
 const GONE = Symbol('gone');
@@ -355,6 +322,9 @@ export function drafted(base) {
     return draft;
 }
 export function settled(draft) {
+    return finished(settling(draft));
+}
+export function* settling(draft) {
     const held = drafts.get(draft);
     const set = [];
     const removed = [];
@@ -363,6 +333,7 @@ export function settled(draft) {
             removed.push(key);
         else
             set.push([key, value]);
+        yield ROW_WEIGHT;
     }
-    return patched(held.base, set, removed);
+    return yield* patching(held.base, set, removed);
 }