@agentshouse/mdruntime 0.1.0-cdf82f77fae68 → 0.1.0-ce131cb435f8b

package/dist/seed.js

@@ -0,0 +1,75 @@
+import { documentKey } from './rows.js';
+function plain(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function windowOf(value) {
+    const { next, total } = value;
+    if (next !== undefined && typeof next !== 'string')
+        return null;
+    if (total !== undefined && !Number.isSafeInteger(total))
+        return null;
+    return {
+        ...(next === undefined ? {} : { next }),
+        ...(total === undefined ? {} : { total: total }),
+    };
+}
+function rowsOf(value) {
+    if (!plain(value))
+        return null;
+    const window = windowOf(value);
+    if (window === null)
+        return null;
+    if (Array.isArray(value.groups)) {
+        const groups = value.groups;
+        return groups.every((group) => plain(group) && Array.isArray(group.key) && typeof group.count === 'number')
+            ? { groups: groups, ...window }
+            : null;
+    }
+    if (!Array.isArray(value.documents))
+        return null;
+    const documents = value.documents;
+    return documents.every((document) => plain(document) && typeof document.room === 'string' && typeof document.path === 'string')
+        ? { documents: documents, ...window }
+        : null;
+}
+export function entrySeedOf(value) {
+    if (!plain(value) || !plain(value.at) || !Array.isArray(value.queries))
+        return null;
+    const at = {};
+    for (const [room, version] of Object.entries(value.at)) {
+        if (typeof version !== 'string')
+            return null;
+        at[room] = version;
+    }
+    const queries = [];
+    for (const entry of value.queries) {
+        if (!plain(entry) || !plain(entry.query))
+            return null;
+        const rows = rowsOf(entry.rows);
+        if (rows === null)
+            return null;
+        queries.push({ query: entry.query, rows });
+    }
+    return { at, queries };
+}
+export function seededResult(seed) {
+    const coverage = {
+        rooms: Object.entries(seed.at).map(([room, generation]) => ({
+            room,
+            generation,
+            current: false,
+        })),
+        indexes: [],
+        overlay: [],
+    };
+    if ('groups' in seed.rows) {
+        return {
+            result: { ...seed.rows, coverage },
+            keys: seed.rows.groups.map((_group, index) => index),
+        };
+    }
+    return {
+        result: { ...seed.rows, coverage },
+        keys: seed.rows.documents.map((document) => documentKey(document.room, document.path)),
+    };
+}

package/dist/shared.d.ts

@@ -0,0 +1,14 @@
+export type Paths<V> = Readonly<Record<string, V>>;
+type Weigh<V> = (key: string, value: V) => number;
+export declare function sharing<V>(map: Paths<V>): Generator<number, Paths<V>, void>;
+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 patching<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Generator<number, Paths<V>, void>;
+export declare function tally<V>(map: Paths<V>, weigh: Weigh<V>): number;
+export declare function sizeOf<V>(map: Paths<V>): number;
+export declare function differences<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): Generator<number, ReadonlySet<string>, void>;
+export declare function differing<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): ReadonlySet<string>;
+export declare function drafted<V>(base: Paths<V>): Record<string, V>;
+export declare function settled<V>(draft: Record<string, V>): Paths<V>;
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"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;AAkBnD,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;AA8LlD,wBAAiB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAE5E;AAED,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,CAEV;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,CAgCnC;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;AA8CD,wBAAiB,WAAW,CAAC,CAAC,EAC5B,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,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAkB9C;AAED,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,CAErB;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"}

package/dist/shared.js

@@ -0,0 +1,394 @@
+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) {
+        hash ^= key.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function isLeaf(node) {
+    return 'key' in node;
+}
+function isCollision(node) {
+    return 'leaves' in node;
+}
+function fragment(hash, shift) {
+    return (hash >>> shift) & MASK;
+}
+function count(bits) {
+    let left = bits - ((bits >>> 1) & 0x55555555);
+    left = (left & 0x33333333) + ((left >>> 2) & 0x33333333);
+    return (((left + (left >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
+function slot(bitmap, bit) {
+    return count(bitmap & (bit - 1));
+}
+function lookup(root, key) {
+    const hash = hashOf(key);
+    let node = root.node;
+    let shift = 0;
+    while (node !== undefined) {
+        if (isLeaf(node))
+            return node.key === key ? node : undefined;
+        if (isCollision(node))
+            return node.leaves.find((leaf) => leaf.key === key);
+        const bit = 1 << fragment(hash, shift);
+        if ((node.bitmap & bit) === 0)
+            return undefined;
+        node = node.children[slot(node.bitmap, bit)];
+        shift += BITS;
+    }
+    return undefined;
+}
+function branchOf(node, shift) {
+    return { bitmap: 1 << fragment(node.hash, shift), children: [node] };
+}
+function joined(left, right, shift) {
+    if (left.hash === right.hash) {
+        const leaves = isCollision(left) ? left.leaves : [left];
+        return { hash: right.hash, leaves: [...leaves, right] };
+    }
+    return put(branchOf(left, shift), right, shift);
+}
+function put(node, leaf, shift) {
+    if (node === undefined)
+        return leaf;
+    if (isLeaf(node)) {
+        if (node.key !== leaf.key)
+            return joined(node, leaf, shift);
+        return node.value === leaf.value ? node : leaf;
+    }
+    if (isCollision(node)) {
+        if (node.hash !== leaf.hash)
+            return joined(node, leaf, shift);
+        const at = node.leaves.findIndex((held) => held.key === leaf.key);
+        if (at === -1)
+            return { hash: node.hash, leaves: [...node.leaves, leaf] };
+        if (node.leaves[at].value === leaf.value)
+            return node;
+        return {
+            hash: node.hash,
+            leaves: node.leaves.map((held, index) => (index === at ? leaf : held)),
+        };
+    }
+    const bit = 1 << fragment(leaf.hash, shift);
+    const at = slot(node.bitmap, bit);
+    if ((node.bitmap & bit) === 0) {
+        return {
+            bitmap: node.bitmap | bit,
+            children: [...node.children.slice(0, at), leaf, ...node.children.slice(at)],
+        };
+    }
+    const child = node.children[at];
+    const next = put(child, leaf, shift + BITS);
+    if (next === child)
+        return node;
+    return {
+        bitmap: node.bitmap,
+        children: node.children.map((held, index) => (index === at ? next : held)),
+    };
+}
+function lone(node) {
+    if (node.children.length !== 1)
+        return null;
+    const [only] = node.children;
+    return isLeaf(only) || isCollision(only) ? only : null;
+}
+function taken(node, hash, key, shift) {
+    if (isLeaf(node))
+        return node.key === key ? undefined : node;
+    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;
+        const rest = {
+            bitmap: node.bitmap & ~bit,
+            children: node.children.filter((_, index) => index !== at),
+        };
+        return lone(rest) ?? rest;
+    }
+    const replaced = {
+        bitmap: node.bitmap,
+        children: node.children.map((held, index) => (index === at ? next : held)),
+    };
+    return lone(replaced) ?? replaced;
+}
+function* leavesOf(node) {
+    if (node === undefined)
+        return;
+    if (isLeaf(node)) {
+        yield node;
+        return;
+    }
+    if (isCollision(node)) {
+        yield* node.leaves;
+        return;
+    }
+    for (const child of node.children)
+        yield* leavesOf(child);
+}
+function facade(root) {
+    let keys;
+    const target = {};
+    const map = new Proxy(target, {
+        get(held, property, receiver) {
+            if (typeof property === 'string') {
+                const leaf = lookup(root, property);
+                if (leaf !== undefined)
+                    return leaf.value;
+            }
+            return Reflect.get(held, property, receiver);
+        },
+        has(held, property) {
+            return ((typeof property === 'string' && lookup(root, property) !== undefined) ||
+                Reflect.has(held, property));
+        },
+        ownKeys() {
+            keys ??= [...leavesOf(root.node)].map((leaf) => leaf.key);
+            return keys;
+        },
+        getOwnPropertyDescriptor(_held, property) {
+            if (typeof property !== 'string')
+                return undefined;
+            const leaf = lookup(root, property);
+            if (leaf === undefined)
+                return undefined;
+            return { value: leaf.value, writable: false, enumerable: true, configurable: true };
+        },
+        set: () => false,
+        defineProperty: () => false,
+        deleteProperty: () => false,
+    });
+    roots.set(map, root);
+    return map;
+}
+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)) {
+        node = put(node, { key, hash: hashOf(key), value }, 0);
+        size += 1;
+        yield ROW_WEIGHT;
+    }
+    return { node, size };
+}
+export function* sharing(map) {
+    return roots.has(map) ? map : facade(yield* rooted(map));
+}
+export function shared(map) {
+    return finished(sharing(map));
+}
+export function patched(base, set, removed = []) {
+    return finished(patching(base, set, removed));
+}
+export function* patching(base, set, removed = []) {
+    const root = yield* rooted(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));
+        }
+    };
+    for (const key of removed) {
+        if (node === undefined)
+            break;
+        const before = lookup({ node, size }, 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* compared(left, right, same, into) {
+    const pending = [[left, right]];
+    for (let pair = pending.pop(); pair !== undefined; pair = pending.pop()) {
+        const [one, other] = pair;
+        if (one === other)
+            continue;
+        if (one !== undefined &&
+            other !== undefined &&
+            !isLeaf(one) &&
+            !isCollision(one) &&
+            !isLeaf(other) &&
+            !isCollision(other)) {
+            const children = [];
+            for (let remaining = one.bitmap | other.bitmap; remaining !== 0; remaining &= remaining - 1) {
+                const bit = remaining & -remaining;
+                children.push([
+                    (one.bitmap & bit) === 0 ? undefined : one.children[slot(one.bitmap, bit)],
+                    (other.bitmap & bit) === 0 ? undefined : other.children[slot(other.bitmap, bit)],
+                ]);
+            }
+            pending.push(...children.reverse());
+            continue;
+        }
+        const before = new Map();
+        for (const leaf of leavesOf(one)) {
+            before.set(leaf.key, leaf.value);
+            yield ROW_WEIGHT;
+        }
+        for (const leaf of leavesOf(other)) {
+            const held = before.get(leaf.key);
+            before.delete(leaf.key);
+            if (held === undefined || !same(held, leaf.value))
+                into.add(leaf.key);
+            yield ROW_WEIGHT;
+        }
+        for (const key of before.keys())
+            into.add(key);
+    }
+}
+export function* differences(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) {
+        yield* compared(leftRoot.node, rightRoot.node, same, into);
+        return into;
+    }
+    for (const key of Object.keys(left)) {
+        if (!Object.hasOwn(right, key) || !same(left[key], right[key]))
+            into.add(key);
+        yield ROW_WEIGHT;
+    }
+    for (const key of Object.keys(right)) {
+        if (!Object.hasOwn(left, key))
+            into.add(key);
+        yield ROW_WEIGHT;
+    }
+    return into;
+}
+export function differing(left, right, same = Object.is) {
+    return finished(differences(left, right, same));
+}
+const drafts = new WeakMap();
+const GONE = Symbol('gone');
+export function drafted(base) {
+    const written = new Map();
+    const read = (key) => {
+        const held = written.get(key);
+        if (held === GONE)
+            return undefined;
+        return held ?? (Object.hasOwn(base, key) ? base[key] : undefined);
+    };
+    const draft = new Proxy({}, {
+        get(held, property, receiver) {
+            if (typeof property === 'string') {
+                const value = read(property);
+                if (value !== undefined)
+                    return value;
+            }
+            return Reflect.get(held, property, receiver);
+        },
+        has(held, property) {
+            return ((typeof property === 'string' && read(property) !== undefined) ||
+                Reflect.has(held, property));
+        },
+        ownKeys() {
+            const keys = new Set(Object.keys(base));
+            for (const [key, value] of written) {
+                if (value === GONE)
+                    keys.delete(key);
+                else
+                    keys.add(key);
+            }
+            return [...keys];
+        },
+        getOwnPropertyDescriptor(_held, property) {
+            if (typeof property !== 'string')
+                return undefined;
+            const value = read(property);
+            if (value === undefined)
+                return undefined;
+            return { value, writable: true, enumerable: true, configurable: true };
+        },
+        set(_held, property, value) {
+            if (typeof property !== 'string')
+                return false;
+            written.set(property, value);
+            return true;
+        },
+        deleteProperty(_held, property) {
+            if (typeof property !== 'string')
+                return false;
+            written.set(property, GONE);
+            return true;
+        },
+        defineProperty: () => false,
+    });
+    drafts.set(draft, { base, written });
+    return draft;
+}
+export function settled(draft) {
+    const held = drafts.get(draft);
+    const set = [];
+    const removed = [];
+    for (const [key, value] of held.written) {
+        if (value === GONE)
+            removed.push(key);
+        else
+            set.push([key, value]);
+    }
+    return patched(held.base, set, removed);
+}

package/dist/status.d.ts

@@ -1,9 +1,13 @@
 import type { Open } from './open.js';
+import type { ProviderRefusal } from './adapter.js';
 import type { ReturnReason } from './room-draft.js';
 export type AttentionEntry = {
     room: string;
     path: string;
     returned: ReturnReason;
+} | {
+    room: string;
+    refusal: ProviderRefusal;
 };
 export type SyncStatus = {
     state: Open<'pending' | 'syncing' | 'synced'>;

package/dist/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;IAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,UAMtB,CAAC;AAEF,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAE3D;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAErD;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAQhE"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAC;AAE/C,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;IAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,UAMtB,CAAC;AAEF,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAE3D;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAErD;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAQhE"}

package/dist/store.d.ts

@@ -1,13 +1,13 @@
 import type { ModelState } from './model.js';
 import type { Capability, HeadChange, Member, OperationScopes, ProviderLimit, ReplicaAdmission, TypedSelection } from './adapter.js';
-import type { AcceptedMessage } from './adapter.js';
+import type { AcceptedMessage, KeptReceipt } from './adapter.js';
 import type { ChangeBatch } from './change.js';
 import { type HeldBinary } from './overlay.js';
 import type { ChatDraftFile } from './file.js';
 import type { Submission } from './outcome.js';
 import type { RoomDraftRecord, SavedDraft } from './room-draft.js';
-export declare const STORE_SCHEMA = 23;
-export declare const AUTHORED_SCHEMA = 1;
+export declare const STORE_SCHEMA = 25;
+export declare const AUTHORED_SCHEMA = 3;
 export type ReplicaRecord = {
     locator: string;
     name: string;
@@ -23,10 +23,11 @@ export type ReplicaRecord = {
     documents: Readonly<Record<string, string>>;
     binaries: Readonly<Record<string, HeldBinary>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     written: Readonly<Record<string, string>>;
 };
-export type StagedLayer = Pick<ReplicaRecord, 'documents' | 'binaries' | 'revisions' | 'changes' | 'written'>;
+export type StagedLayer = Pick<ReplicaRecord, 'documents' | 'binaries' | 'revisions' | 'fileIds' | 'changes' | 'written'>;
 export type TransferRecord = {
     locator: string;
     transfer: string;
@@ -46,6 +47,9 @@ export type PendingState = {
     readonly upload?: unknown;
     readonly accepted?: string;
 };
+export type TargetRecord = {
+    established: boolean;
+};
 export type QueueRecord = {
     locator: string;
     pending: readonly {
@@ -60,20 +64,38 @@ export type PresentationRecord = {
 export type HeldConversation = {
     conversation: string;
     read: string | null | undefined;
-    messages: readonly AcceptedMessage[];
+    partial: boolean;
+};
+export type MessageWindow = {
+    messages: AcceptedMessage[];
+    more: boolean;
 };
 export type ConversationWrite = {
     conversation: string;
     messages: readonly AcceptedMessage[];
-    read?: string | null;
-    sealed?: boolean;
+    read?: {
+        at: string | null;
+        partial: boolean;
+    };
+};
+export type ChatSubmission = {
+    readonly operation: string;
+    readonly text: string;
+    readonly files: readonly ChatDraftFile[];
+    readonly turn: string | null;
 };
 export type ChatDraftRecord = {
     conversation: string;
     text: string;
     files: readonly ChatDraftFile[];
-    turn: string | null;
     revision: string;
+    submitted?: readonly ChatSubmission[];
+    moves?: readonly string[];
+};
+export type CallRecord = {
+    readonly operation: string;
+    readonly name: string;
+    readonly input: unknown;
 };
 export type RecordWrite = {
     next: ReplicaRecord;
@@ -83,6 +105,7 @@ export type RecordWrite = {
 export type AuthoredWrite = {
     locator: string;
     queue: readonly ChangeBatch[];
+    founded?: readonly ChangeBatch[];
     saved?: ReadonlyMap<string, readonly SavedDraft[]>;
     roomDrafts?: readonly RoomDraftRecord[];
     consumedRoomDrafts?: readonly string[];
@@ -99,6 +122,8 @@ export type RuntimeStore = {
     declare(limits: readonly ProviderLimit[], capabilities: readonly Capability[]): Promise<void>;
     member(): Promise<Member | null>;
     keepMember(member: Member | null): Promise<void>;
+    targets(): Promise<Readonly<Record<string, TargetRecord>>>;
+    keepTargets(targets: Readonly<Record<string, TargetRecord>>): Promise<void>;
     queues(): Promise<readonly QueueRecord[]>;
     submit(locator: string, id: string, submission: Submission, lost: boolean): Promise<void>;
     accept(locator: string, id: string, roomVersion: string): Promise<void>;
@@ -108,21 +133,43 @@ export type RuntimeStore = {
     present(record: PresentationRecord): Promise<void>;
     conversations(): Promise<readonly HeldConversation[]>;
     keepMessages(write: ConversationWrite): Promise<void>;
+    messageWindow(conversation: string, limit: number, before: readonly [string, string] | null): Promise<MessageWindow>;
+    messageCount(conversation: string): Promise<number>;
+    messagesAfter(conversation: string, identity: string | null): Promise<AcceptedMessage[]>;
+    messageIdentities(conversation: string): Promise<readonly string[]>;
+    turnArrived(conversation: string, turn: string): Promise<boolean>;
     dropConversations(conversations: readonly string[]): Promise<void>;
     chatDrafts(): Promise<readonly ChatDraftRecord[]>;
-    keepChatDraft(record: ChatDraftRecord): Promise<void>;
+    keepChatDrafts(records: readonly ChatDraftRecord[]): Promise<void>;
     dropChatDraft(conversation: string): Promise<void>;
+    calls(): Promise<readonly CallRecord[]>;
+    keepCall(record: CallRecord): Promise<void>;
+    dropCall(operation: string): Promise<void>;
     keepRoomDraft(record: RoomDraftRecord): Promise<void>;
     discardRoomDraft(locator: string, path: string): Promise<void>;
-    dropRooms(locators: readonly string[]): Promise<void>;
+    fences(): Promise<readonly string[]>;
+    erase(locators: readonly string[]): Promise<void>;
+    discard(locator: string): Promise<void>;
     transfers(): Promise<readonly TransferRecord[]>;
     staged(record: TransferRecord): Promise<StagedLayer>;
     stage(record: TransferRecord, page: StagedLayer): Promise<void>;
     abandon(locator: string): Promise<void>;
+    receivedHeads(): Promise<readonly KeptReceipt[]>;
+    receivedParts(key: string, count: number): Promise<readonly unknown[]>;
+    keepReceived(key: string, head: unknown, part?: {
+        index: number;
+        value: unknown;
+    }): Promise<void>;
+    dropReceived(keys: readonly string[]): Promise<void>;
     generation(): Promise<string | null>;
     rememberGeneration(value: string): Promise<void>;
     close(): void;
 };
-export declare function removeRuntimeStore(): Promise<void>;
-export declare function openRuntimeStore(): Promise<RuntimeStore>;
+export declare function authoredHolder(): Promise<string | null>;
+export declare function authoredBy(holder: string): Promise<boolean>;
+export declare function authoredBinding(): Promise<string | null>;
+export declare function bindAuthored(binding: string): Promise<void>;
+export declare function removeRuntimeStore(holder?: string): Promise<boolean>;
+export declare function openDatabase(name: string, version: number, upgrade: (opening: IDBOpenDBRequest, oldVersion: number) => void): Promise<IDBDatabase>;
+export declare function openRuntimeStore(fenced: (locator: string) => boolean): Promise<RuntimeStore>;
 //# sourceMappingURL=store.d.ts.map