@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c1954630fadb6

package/dist/read-side.js

@@ -0,0 +1,377 @@
+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 reached(reach, room, document) {
+    return reach === null
+        ? []
+        : [or(inArray(room, [...reach.rooms]), inArray(document, [...reach.documents]))];
+}
+function scoped(scope, row, rooms, reach) {
+    return every([
+        eq(row.kind, 'document'),
+        ...(rooms === null ? [] : [inArray(row.room, [...rooms])]),
+        ...reached(reach, row.room, row.key),
+        ...(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, reach) {
+    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, reach))
+        .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, plan.reach));
+    if (plan.hop !== null) {
+        const hop = related(q, rows, plan.hop, plan.hop.field, 'source', plan.reach);
+        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', plan.reach);
+        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, plan.reach)) } : {}),
+        ...(shape.change ? { change: d.change } : {}),
+    }));
+}
+function backlinked(q, rows, document, reach) {
+    const from = q.from({ r: rows });
+    return from
+        .where(({ r }) => every([eq(r.target, document.key), ...reached(reach, r.room, r.source)]))
+        .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),
+    };
+}
+export 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();
+        },
+    };
+}

package/dist/refresh.d.ts

@@ -1,7 +1,7 @@
-import type { AttachedModelBinding } from './model.js';
-import type { Adapter, AdapterFailure, Authorization } from './adapter.js';
+import type { Adapter, AdapterFailure, Authorization, RetryableRefusal } from './adapter.js';
+import type { Remodel } from './bootstrap.js';
 import { type ConfirmedLayer } from './replica.js';
-import { type Unconfirmed } from './transfer.js';
+import { type Refused, type Unconfirmed } from './transfer.js';
 export type RefreshOutcome = {
     kind: 'still-current';
 } | {
@@ -9,6 +9,6 @@ export type RefreshOutcome = {
     confirmed: ConfirmedLayer;
 } | {
     kind: 'beyond-horizon';
-} | Unconfirmed | AdapterFailure;
-export declare function refreshRoom(adapter: Adapter, authorization: Authorization, confirmed: ConfirmedLayer, binding: AttachedModelBinding | null): Promise<RefreshOutcome>;
+} | RetryableRefusal | Unconfirmed | Refused | AdapterFailure;
+export declare function refreshRoom(adapter: Adapter, authorization: Authorization, confirmed: ConfirmedLayer, remodel: Remodel, continuing: () => boolean): Promise<RefreshOutcome>;
 //# sourceMappingURL=refresh.d.ts.map

package/dist/refresh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../src/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,aAAa,EAAe,MAAM,cAAc,CAAC;AACxF,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9D,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,cAAc,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B,WAAW,GACX,cAAc,CAAC;AAEnB,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,oBAAoB,GAAG,IAAI,GACnC,OAAO,CAAC,cAAc,CAAC,CAsDzB"}
+{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../src/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,aAAa,EAGb,gBAAgB,EAEjB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAe,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5E,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,cAAc,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B,gBAAgB,GAChB,WAAW,GACX,OAAO,GACP,cAAc,CAAC;AAEnB,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,OAAO,GACxB,OAAO,CAAC,cAAc,CAAC,CA8EzB"}

package/dist/refresh.js

@@ -1,65 +1,84 @@
+import { declaredAttachments } from './attachment.js';
 import { readStaged } from './replica.js';
 import { unconfirmed } from './transfer.js';
-export async function refreshRoom(adapter, authorization, confirmed, binding) {
+export async function refreshRoom(adapter, authorization, confirmed, remodel, continuing) {
     const locator = confirmed.record.locator;
     const fromRoomVersion = confirmed.record.roomVersion;
     const first = await adapter.refresh(authorization, {
         locator,
         selection: confirmed.record.replica.selection,
-        fromRoomVersion
+        fromRoomVersion,
     });
-    if (first.kind !== 'net-advancement') return first;
+    if (first.kind !== 'net-advancement')
+        return first;
     const roomVersion = first.roomVersion;
-    const documents = {
-        ...confirmed.record.documents
-    };
-    const revisions = {
-        ...confirmed.record.revisions
-    };
+    const models = remodel(first.models, {
+        collection: confirmed.record.model,
+        selection: confirmed.record.selectionModel,
+    });
+    const documents = { ...confirmed.record.documents };
+    const revisions = { ...confirmed.record.revisions };
+    const changes = { ...confirmed.record.changes };
+    const written = { ...confirmed.record.written };
     const binaryTargets = new Set(confirmed.record.binaryTargets);
-    const stage = (page)=>{
+    const attachments = [];
+    const stage = (page) => {
+        if (page.attachments !== undefined)
+            attachments.push(page.attachments);
         Object.assign(documents, page.documents);
         Object.assign(revisions, page.revisions);
-        for (const path of Object.keys(page.documents))binaryTargets.delete(path);
-        for (const target of page.binaryTargets){
+        for (const path of Object.keys(page.documents)) {
+            binaryTargets.delete(path);
+            delete changes[path];
+            written[path] = roomVersion;
+        }
+        for (const target of page.binaryTargets) {
             delete documents[target];
             delete revisions[target];
+            delete changes[target];
+            delete written[target];
             binaryTargets.add(target);
         }
-        for (const path of page.removals){
+        Object.assign(changes, page.changes);
+        for (const path of page.removals) {
             delete documents[path];
             delete revisions[path];
+            delete changes[path];
+            delete written[path];
             binaryTargets.delete(path);
         }
     };
     stage(first);
     let pageToken = first.pageToken;
-    while(pageToken !== undefined){
+    while (pageToken !== undefined) {
+        if (!continuing())
+            return unconfirmed;
         const page = await adapter.refresh(authorization, {
             locator,
             selection: confirmed.record.replica.selection,
             fromRoomVersion,
-            pageToken
+            pageToken,
         });
-        if (page.kind === 'still-current' || page.kind === 'beyond-horizon') return unconfirmed;
-        if (page.kind !== 'net-advancement') return page;
-        if (page.roomVersion !== roomVersion) return unconfirmed;
+        if (page.kind === 'still-current' || page.kind === 'beyond-horizon')
+            return unconfirmed;
+        if (page.kind !== 'net-advancement')
+            return page;
+        if (page.roomVersion !== roomVersion)
+            return unconfirmed;
         stage(page);
         pageToken = page.pageToken;
     }
-    const advanced = readStaged({
+    const staged = readStaged({
         ...confirmed.record,
+        model: models.collection,
+        selectionModel: models.selection,
         roomVersion,
         documents,
-        binaryTargets: [
-            ...binaryTargets
-        ].sort(),
-        revisions
-    }, binding);
-    return advanced === null ? unconfirmed : {
-        kind: 'advanced',
-        confirmed: advanced
-    };
+        binaryTargets: [...binaryTargets].sort(),
+        revisions,
+        changes,
+        written,
+        attachments: attachments.length === 0 ? confirmed.record.attachments : declaredAttachments(attachments),
+    }, confirmed);
+    return staged.kind === 'staged' ? { kind: 'advanced', confirmed: staged.confirmed } : staged;
 }
-
-//# sourceMappingURL=refresh.js.map

package/dist/replica.d.ts

@@ -1,8 +1,9 @@
-import type { AttachedModelBinding } from './model.js';
 import { type ChangeBatch } from './change.js';
 import { type Collection, type Composition } from './collection.js';
 import { type Layer } from './overlay.js';
+import type { RoomAttachment } from './adapter.js';
 import type { ReplicaRecord } from './store.js';
+import type { Refused } from './transfer.js';
 export type ConfirmedLayer = {
     record: ReplicaRecord;
     collection: Collection;
@@ -10,14 +11,33 @@ export type ConfirmedLayer = {
 export type VisibleLayer = Layer & {
     collection: Collection;
 };
+export type Staged = {
+    kind: 'staged';
+    confirmed: ConfirmedLayer;
+} | Refused;
 export type Replica = {
     confirmed: ConfirmedLayer;
     queue: readonly ChangeBatch[];
     visible: VisibleLayer;
+    replay: readonly ReplayStep[];
+};
+type ReplayStep = {
+    id: string;
+    before: Layer;
+    after: Layer;
+    effective: ChangeBatch;
+    collection?: Collection;
 };
 export declare function compositionOf(record: ReplicaRecord): Composition;
-export declare function readConfirmed(record: ReplicaRecord): ConfirmedLayer | null;
-export declare function readStaged(record: ReplicaRecord, binding: AttachedModelBinding | null): ConfirmedLayer | null;
-export declare function applyReturned(confirmed: ConfirmedLayer, documents: Readonly<Record<string, string>>, revisions: Readonly<Record<string, string>>, removals: readonly string[], roomVersion: string, binding: AttachedModelBinding | null): ConfirmedLayer | null;
-export declare function replicaOf(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[]): Replica;
+export declare function readConfirmed(record: ReplicaRecord, previous?: ConfirmedLayer): Staged;
+export declare function sameMembership(record: ReplicaRecord, other: ReplicaRecord): boolean;
+export declare function readStaged(record: ReplicaRecord, previous?: ConfirmedLayer): Staged;
+export declare function readReclassified(record: ReplicaRecord, previous: ConfirmedLayer): Staged | {
+    kind: 'deferred';
+};
+export declare function applyReturned(confirmed: ConfirmedLayer, documents: Readonly<Record<string, string>>, revisions: Readonly<Record<string, string>>, removals: readonly string[], attachments: readonly RoomAttachment[] | undefined, roomVersion: string, writtenAt: string): Staged;
+export declare function replicaOf(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], previous?: Replica): Replica;
+export declare function landed(batch: ChangeBatch, confirmed: ConfirmedLayer): boolean;
+export declare function withdrawals(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean): readonly ChangeBatch[];
+export {};
 //# sourceMappingURL=replica.d.ts.map

package/dist/replica.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replica.d.ts","sourceRoot":"","sources":["../src/replica.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAW,KAAK,KAAK,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG;IACjC,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,cAAc,CAAC;IAC1B,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9B,OAAO,EAAE,YAAY,CAAC;CACvB,CAAC;AAEF,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CAShE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,GAAG,IAAI,CAG1E;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,GAAG,IAAI,GACnC,cAAc,GAAG,IAAI,CAcvB;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,oBAAoB,GAAG,IAAI,GACnC,cAAc,GAAG,IAAI,CAmBvB;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAuB3F"}
+{"version":3,"file":"replica.d.ts","sourceRoot":"","sources":["../src/replica.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,KAAK,WAAW,EAAqB,MAAM,aAAa,CAAC;AAC1F,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAA0C,KAAK,KAAK,EAAE,MAAM,cAAc,CAAC;AAGlF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG;IACjC,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,cAAc,CAAA;CAAE,GAAG,OAAO,CAAC;AAE7E,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,cAAc,CAAC;IAC1B,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9B,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;CAC/B,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,WAAW,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CAQhE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM,CAWtF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAKnF;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM,CAkBnF;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,cAAc,GACvB,MAAM,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAM/B;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,WAAW,EAAE,SAAS,cAAc,EAAE,GAAG,SAAS,EAClD,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,CAmCR;AAsDD,wBAAgB,SAAS,CACvB,SAAS,EAAE,cAAc,EACzB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO,CAgCT;AAkFD,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc,GAAG,OAAO,CAa7E;AAED,wBAAgB,WAAW,CACzB,SAAS,EAAE,cAAc,EACzB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,YAAY,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,GAC5C,SAAS,WAAW,EAAE,CAmBxB"}