@agentshouse/mdruntime 0.1.0-cf28918c2bf91 → 0.1.0-cf53a3b60b194

package/dist/read-side.d.ts

@@ -1,14 +0,0 @@
-import type { ChangeSet } from './change-set.js';
-import { type KeyedResult, type QueryChange } from './observation.js';
-import type { Plan, QueryResult } from './query.js';
-import type { SearchedDocument } from './search.js';
-export type ReadSide = {
-    apply(set: ChangeSet): void;
-    query(plan: Plan): Promise<QueryResult>;
-    watch(plan: Plan, identity: string, deliver: (message: KeyedResult | QueryChange) => void): () => void;
-    documents(): readonly SearchedDocument[];
-    document(room: string, path: string): SearchedDocument | null;
-    close(): void;
-};
-export declare function createReadSide(): ReadSide;
-//# sourceMappingURL=read-side.d.ts.map

package/dist/read-side.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-side.d.ts","sourceRoot":"","sources":["../src/read-side.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAU,KAAK,WAAW,EAAE,KAAK,WAAW,EAAe,MAAM,kBAAkB,CAAC;AAC3F,OAAO,KAAK,EAOV,IAAI,EAGJ,WAAW,EAIZ,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAqDpD,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACxC,KAAK,CACH,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,KAAK,IAAI,GACpD,MAAM,IAAI,CAAC;IACd,SAAS,IAAI,SAAS,gBAAgB,EAAE,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAC9D,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAySF,wBAAgB,cAAc,IAAI,QAAQ,CA4HzC"}

package/dist/read-side.js

@@ -1,371 +0,0 @@
-import { and, BasicIndex, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, gt, gte, inArray, isNull, isUndefined, lt, lte, not, or, toArray, } from '@tanstack/db';
-import { rowsOf } from './observation.js';
-import { documentKey } from './rows.js';
-function every(expressions) {
-    const [first, second, ...rest] = expressions;
-    return second === undefined ? first : and(first, second, ...rest);
-}
-function some(expressions) {
-    const [first, second, ...rest] = expressions;
-    return second === undefined ? first : or(first, second, ...rest);
-}
-function equal(field, value) {
-    return or(eq(field, value), inArray(value, field));
-}
-function tested(test, field, size, written) {
-    if (test.op === 'eq')
-        return test.value === null ? isNull(field) : equal(field, test.value);
-    if (test.op === 'ne') {
-        return test.value === null
-            ? not(isNull(field))
-            : or(isUndefined(field), isNull(field), not(equal(field, test.value)));
-    }
-    if (test.op === 'in' || test.op === 'nin') {
-        const matches = test.values.length === 0
-            ? inArray(field, [])
-            : some(test.values.map((value) => (value === null ? isNull(field) : equal(field, value))));
-        if (test.op === 'in')
-            return matches;
-        return some([
-            isUndefined(field),
-            ...(test.values.includes(null) ? [] : [isNull(field)]),
-            not(matches),
-        ]);
-    }
-    if (test.op === 'range') {
-        const compare = { gt, gte, lt, lte };
-        return every(test.bounds.map(([operator, bound]) => compare[operator](field, bound)));
-    }
-    if (test.op === 'all') {
-        return every([not(isUndefined(size)), ...test.values.map((value) => inArray(value, field))]);
-    }
-    if (test.op === 'size')
-        return eq(size, test.size);
-    return test.exists ? not(isUndefined(written)) : isUndefined(written);
-}
-function conditioned(condition, row) {
-    if ('every' in condition)
-        return every(condition.every.map((item) => conditioned(item, row)));
-    if ('some' in condition)
-        return some(condition.some.map((item) => conditioned(item, row)));
-    return tested(condition.test, row.values[condition.field], row.sizes[condition.field], row.fields[condition.field]);
-}
-function scoped(scope, row, rooms) {
-    return every([
-        eq(row.kind, 'document'),
-        ...(rooms === null ? [] : [inArray(row.room, [...rooms])]),
-        ...(scope.types === null ? [] : [inArray(row.type, [...scope.types])]),
-        ...(scope.pathPrefix === null ? [] : [inArray(scope.pathPrefix, row.directories)]),
-        ...(scope.where === null ? [] : [conditioned(scope.where, row)]),
-    ]);
-}
-function keyed(key, row) {
-    return key.of === 'field' ? row.values[key.field] : row[key.of];
-}
-function live(query) {
-    return createLiveQueryCollection({
-        query: query,
-        startSync: true,
-    });
-}
-function related(q, rows, scope, field, kept) {
-    const matched = kept === 'source' ? 'target' : 'source';
-    const from = q.from({ r: rows });
-    return from
-        .where(({ r }) => every([eq(r.kind, 'reference'), ...(field === null ? [] : [eq(r.field, field)])]))
-        .innerJoin({ m: rows }, ({ r, m }) => eq(r[matched], m.key))
-        .where(({ m }) => scoped(scope, m, null))
-        .groupBy(({ r }) => r[kept])
-        .select(({ r }) => ({ key: r[kept] }));
-}
-function filtered(q, rows, plan) {
-    const from = q.from({ d: rows });
-    let query = from.where(({ d }) => scoped(plan.root, d, plan.rooms));
-    if (plan.hop !== null) {
-        const hop = related(q, rows, plan.hop, plan.hop.field, 'source');
-        query = query.innerJoin({ h: hop }, ({ d, h }) => eq(d.key, h.key));
-    }
-    if (plan.backlinks !== null) {
-        const backlinks = related(q, rows, plan.backlinks, plan.backlinks.field, 'target');
-        query = query.innerJoin({ k: backlinks }, ({ d, k }) => eq(d.key, k.key));
-    }
-    return query;
-}
-function named(prefix, names, source) {
-    return Object.fromEntries(names.map((name, index) => [`${prefix}${index}`, source[name]]));
-}
-function documents(q, rows, plan, shape) {
-    let query = filtered(q, rows, plan);
-    if (shape.sections !== null || shape.preamble || shape.markdown) {
-        query = query.leftJoin({ b: rows }, ({ d, b }) => eq(d.body, b.key));
-    }
-    for (const { key, options } of shape.orderBy) {
-        query = query.orderBy(({ d }) => keyed(key, d), options);
-    }
-    if (shape.orderBy.length === 0 && plan.limit !== null) {
-        query = query.orderBy(({ d }) => d.key, { stringSort: 'lexical' });
-    }
-    if (plan.limit !== null)
-        query = query.limit(plan.limit);
-    return query.select(({ d, b }) => ({
-        room: d.room,
-        path: d.path,
-        type: d.type,
-        ...(shape.fields === 'all' ? { fields: d.fields } : {}),
-        ...(Array.isArray(shape.fields) ? named('field', shape.fields, d.fields) : {}),
-        ...(shape.sections === 'all' ? { sections: b.sections } : {}),
-        ...(Array.isArray(shape.sections) ? named('section', shape.sections, b.sections) : {}),
-        ...(shape.preamble ? { preamble: b.preamble } : {}),
-        ...(shape.markdown ? { markdown: b.markdown } : {}),
-        ...(shape.backlinks ? { backlinks: toArray(backlinked(q, rows, d)) } : {}),
-        ...(shape.change ? { change: d.change } : {}),
-    }));
-}
-function backlinked(q, rows, document) {
-    const from = q.from({ r: rows });
-    return from
-        .where(({ r }) => eq(r.target, document.key))
-        .orderBy(({ r }) => r.path, { stringSort: 'lexical' })
-        .orderBy(({ r }) => r.field, { stringSort: 'lexical' })
-        .select(({ r }) => ({ path: r.path, type: r.type, field: r.field }));
-}
-function groups(q, stage, shape, limit) {
-    const keys = shape.groupBy.map((_, index) => `key${index}`);
-    const from = q.from({ m: stage });
-    let query = from.groupBy(({ m }) => keys.map((key) => m[key]));
-    for (const { by, direction } of shape.orderBy) {
-        query = query.orderBy(({ m }) => (by === 'count' ? count(m.key) : m[keys[by]]), direction);
-    }
-    if (limit !== null && shape.orderBy.length > 0)
-        query = query.limit(limit);
-    return query.select(({ m }) => ({
-        ...Object.fromEntries(keys.map((key) => [key, m[key]])),
-        count: count(m.key),
-    }));
-}
-function built(rows, plan) {
-    const shape = plan.shape;
-    if (shape.kind === 'documents') {
-        const collection = live((q) => documents(q, rows, plan, shape));
-        return { live: collection, dispose: () => void collection.cleanup() };
-    }
-    const stage = live((q) => filtered(q, rows, plan).select(({ d }) => ({
-        key: d.key,
-        ...Object.fromEntries(shape.groupBy.map((key, index) => [`key${index}`, keyed(key, d)])),
-    })));
-    const collection = live((q) => groups(q, stage, shape, plan.limit));
-    return {
-        live: collection,
-        dispose: () => {
-            void collection.cleanup();
-            void stage.cleanup();
-        },
-    };
-}
-function present(entries) {
-    return Object.fromEntries(entries.filter(([, value]) => value !== undefined));
-}
-function part(row, prefix, names, whole) {
-    if (names === 'all')
-        return whole;
-    return present(names.map((name, index) => [name, row[`${prefix}${index}`]]));
-}
-function documentOf(row, shape) {
-    if (row.type === null)
-        return { room: row.room, path: row.path };
-    return {
-        room: row.room,
-        path: row.path,
-        type: row.type,
-        ...(shape.fields === null
-            ? {}
-            : { fields: part(row, 'field', shape.fields, row.fields) }),
-        ...(shape.sections === null
-            ? {}
-            : {
-                sections: part(row, 'section', shape.sections, row.sections),
-            }),
-        ...(shape.preamble ? { preamble: row.preamble } : {}),
-        ...(shape.markdown ? { markdown: row.markdown } : {}),
-        ...(shape.backlinks
-            ? {
-                backlinks: row.backlinks.map(({ path, type, field }) => ({ path, type, field })),
-            }
-            : {}),
-        ...(shape.change ? { change: row.change } : {}),
-    };
-}
-function keyedOf(plan, entries) {
-    const shape = plan.shape;
-    if (shape.kind === 'documents') {
-        return {
-            result: structuredClone({ documents: entries.map(([, row]) => documentOf(row, shape)) }),
-            keys: entries.map(([key]) => key),
-        };
-    }
-    const bounded = shape.orderBy.length === 0 && plan.limit !== null ? entries.slice(0, plan.limit) : entries;
-    return {
-        result: structuredClone({
-            groups: bounded.map(([, row]) => ({
-                key: shape.groupBy.map((_, index) => row[`key${index}`]),
-                count: row.count,
-            })),
-        }),
-        keys: bounded.map(([key]) => key),
-    };
-}
-function reconciled(previous, next) {
-    const before = rowsOf(previous.result);
-    const held = new Map(previous.keys.map((key, index) => [key, before[index]]));
-    const changed = [];
-    const rows = rowsOf(next.result).map((row, index) => {
-        const key = next.keys[index];
-        const kept = held.get(key);
-        if (kept !== undefined && deepEquals(kept, row))
-            return kept;
-        changed.push([key, row]);
-        return row;
-    });
-    const present = new Set(next.keys);
-    const survivors = previous.keys.filter((key) => present.has(key));
-    const removed = previous.keys.filter((key) => !present.has(key));
-    const moved = survivors.length !== next.keys.length ||
-        survivors.some((key, index) => key !== next.keys[index]);
-    if (changed.length === 0 && removed.length === 0 && !moved)
-        return null;
-    return {
-        keyed: {
-            result: 'groups' in next.result
-                ? { groups: rows }
-                : { documents: rows },
-            keys: next.keys,
-        },
-        change: { changed, removed, order: moved ? next.keys : null },
-    };
-}
-export function createReadSide() {
-    configureIndexDevMode({ enabled: false });
-    let sync;
-    const rows = createCollection({
-        getKey: (row) => row.key,
-        gcTime: 0,
-        startSync: true,
-        autoIndex: 'eager',
-        defaultIndexType: BasicIndex,
-        sync: {
-            rowUpdateMode: 'full',
-            sync: (params) => {
-                sync = params;
-                params.markReady();
-            },
-        },
-    });
-    const shared = new Map();
-    function searched(row) {
-        const body = rows.get(row.body);
-        return {
-            room: row.room,
-            path: row.path,
-            type: row.type,
-            fields: row.fields,
-            preamble: body.preamble,
-            sections: body.sections,
-        };
-    }
-    function publish(entry) {
-        const next = reconciled(entry.result, keyedOf(entry.plan, [...entry.built.live.entries()]));
-        if (next === null)
-            return;
-        entry.result = next.keyed;
-        for (const listener of entry.listeners)
-            listener(next.change);
-    }
-    return {
-        apply(set) {
-            const next = new Map();
-            for (const change of set.documents) {
-                for (const row of change.before)
-                    next.set(row.key, null);
-                for (const row of change.after)
-                    next.set(row.key, row);
-            }
-            if (next.size === 0)
-                return;
-            sync.begin();
-            for (const [key, row] of next) {
-                if (row === null) {
-                    if (rows.has(key))
-                        sync.write({ type: 'delete', key });
-                    continue;
-                }
-                sync.write({ type: rows.has(key) ? 'update' : 'insert', value: row });
-            }
-            sync.commit();
-        },
-        async query(plan) {
-            const { live: collection, dispose } = built(rows, plan);
-            try {
-                await collection.toArrayWhenReady();
-                return keyedOf(plan, [...collection.entries()]).result;
-            }
-            finally {
-                dispose();
-            }
-        },
-        watch(plan, identity, deliver) {
-            let entry = shared.get(identity);
-            if (entry === undefined) {
-                const created = {
-                    plan,
-                    built: built(rows, plan),
-                    result: undefined,
-                    listeners: new Set(),
-                    subscription: null,
-                };
-                created.built.live.on('status:change', ({ status }) => {
-                    if (status === 'cleaned-up' && created.listeners.size === 0)
-                        shared.delete(identity);
-                });
-                shared.set(identity, created);
-                entry = created;
-            }
-            const observed = entry;
-            observed.listeners.add(deliver);
-            observed.built.live.onFirstReady(() => {
-                if (!observed.listeners.has(deliver))
-                    return;
-                if (observed.subscription === null) {
-                    observed.result = keyedOf(observed.plan, [...observed.built.live.entries()]);
-                    observed.subscription = observed.built.live.subscribeChanges(() => {
-                        publish(observed);
-                    }, { includeInitialState: false });
-                }
-                deliver(observed.result);
-            });
-            return () => {
-                if (!observed.listeners.delete(deliver) || observed.listeners.size > 0)
-                    return;
-                observed.subscription?.unsubscribe();
-                observed.subscription = null;
-            };
-        },
-        documents() {
-            return rows.toArray
-                .filter((row) => row.kind === 'document' && row.type !== null)
-                .map(searched);
-        },
-        document(room, path) {
-            const row = rows.get(documentKey(room, path));
-            return row === undefined || row.type === null ? null : searched(row);
-        },
-        close() {
-            for (const entry of shared.values()) {
-                entry.listeners.clear();
-                entry.subscription?.unsubscribe();
-                entry.built.dispose();
-            }
-            shared.clear();
-            void rows.cleanup();
-        },
-    };
-}