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

package/dist/read-side.js

@@ -0,0 +1,440 @@
+import { and, BasicIndex, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, inArray, or, toArray, } from '@tanstack/db';
+import { ARRAY_INDEX, pointerSegments } from '@agentshouse/mdmodel';
+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 same(held, value) {
+    return Array.isArray(held) ? held.includes(value) : held === value;
+}
+function ordered(held, [operator, bound]) {
+    if (typeof held !== typeof bound || held === null || typeof held === 'object')
+        return false;
+    const left = held;
+    const right = bound;
+    if (operator === 'gt')
+        return left > right;
+    if (operator === 'gte')
+        return left >= right;
+    if (operator === 'lt')
+        return left < right;
+    return left <= right;
+}
+function satisfied(test, held) {
+    if (test.op === 'eq')
+        return same(held, test.value);
+    if (test.op === 'ne')
+        return !same(held, test.value);
+    if (test.op === 'in')
+        return test.values.some((value) => same(held, value));
+    if (test.op === 'nin')
+        return !test.values.some((value) => same(held, value));
+    if (test.op === 'range')
+        return test.bounds.every((bound) => ordered(held, bound));
+    if (test.op === 'all')
+        return Array.isArray(held) && test.values.every((value) => same(held, value));
+    return Array.isArray(held) && held.length === test.size;
+}
+function tested(test, reached) {
+    if (test.op === 'exists')
+        return test.exists === (reached !== undefined);
+    if (reached === undefined)
+        return test.op === 'ne' || test.op === 'nin';
+    return reached.some((held) => satisfied(test, held));
+}
+function conditioned(condition, row) {
+    if ('every' in condition)
+        return condition.every.every((item) => conditioned(item, row));
+    if ('some' in condition)
+        return condition.some.some((item) => conditioned(item, row));
+    return tested(condition.test, row.reached[condition.field]);
+}
+function narrowed(query, where, alias) {
+    return where === null ? query : query.fn.where((row) => conditioned(where, row[alias]));
+}
+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)]),
+    ]);
+}
+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 });
+    const joined = from
+        .where(({ r }) => every([eq(r.kind, 'reference'), ...(field === null ? [] : [inArray(field, r.forms)])]))
+        .innerJoin({ m: rows }, ({ r, m }) => eq(r[matched], m.key))
+        .where(({ m }) => scoped(scope, m, null, reach));
+    return narrowed(joined, scope.where, 'm')
+        .groupBy(({ r }) => r[kept])
+        .select(({ r }) => ({ key: r[kept] }));
+}
+function filtered(q, rows, plan) {
+    const from = q.from({ d: rows });
+    let query = narrowed(from.where(({ d }) => scoped(plan.root, d, plan.rooms, plan.reach)), plan.root.where, 'd');
+    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,
+        binary: d.binary,
+        ...(shape.fields === null ? {} : { 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 masked(pointers) {
+    const root = { whole: false, members: new Map() };
+    for (const pointer of pointers) {
+        let mask = root;
+        for (const token of pointerSegments(pointer)) {
+            const next = mask.members.get(token) ?? { whole: false, members: new Map() };
+            mask.members.set(token, next);
+            mask = next;
+        }
+        mask.whole = true;
+    }
+    return root;
+}
+function merged(left, right) {
+    if (left === undefined)
+        return right;
+    const members = new Map(left.members);
+    for (const [token, mask] of right.members)
+        members.set(token, merged(members.get(token), mask));
+    return { whole: left.whole || right.whole, members };
+}
+function cut(value, mask) {
+    if (mask.whole)
+        return value;
+    if (Array.isArray(value)) {
+        const each = {
+            whole: false,
+            members: new Map([...mask.members].filter(([token]) => !ARRAY_INDEX.test(token))),
+        };
+        const kept = [];
+        value.forEach((item, index) => {
+            const part = cut(item, merged(mask.members.get(String(index)), each));
+            if (part !== undefined)
+                kept[index] = part;
+        });
+        return kept.length === 0 ? undefined : kept;
+    }
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const kept = Object.entries(value).flatMap(([key, held]) => {
+        const member = mask.members.get(key);
+        const part = member === undefined ? undefined : cut(held, member);
+        return part === undefined ? [] : [[key, part]];
+    });
+    return kept.length === 0 ? undefined : Object.fromEntries(kept);
+}
+function selected(fields, pointers) {
+    return (cut(fields, masked(pointers)) ?? {});
+}
+function documentOf(row, shape) {
+    if (row.type === null) {
+        const binary = row.binary;
+        return {
+            room: row.room,
+            path: row.path,
+            ...(binary === null ? {} : { binaryFile: binary }),
+        };
+    }
+    return {
+        room: row.room,
+        path: row.path,
+        type: row.type,
+        ...(shape.fields === null
+            ? {}
+            : {
+                fields: shape.fields === 'all'
+                    ? row.fields
+                    : selected(row.fields, shape.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,16 @@
-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 { ReplicaRecord } from './store.js';
+import { type Refused, type Unconfirmed } from './transfer.js';
+export type Advancement = {
+    kind: 'still-current';
+} | {
+    kind: 'advanced';
+    record: ReplicaRecord;
+} | {
+    kind: 'beyond-horizon';
+} | RetryableRefusal | Unconfirmed | AdapterFailure;
 export type RefreshOutcome = {
     kind: 'still-current';
 } | {
@@ -9,6 +18,7 @@ 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 advancement(adapter: Adapter, authorization: Authorization, held: ReplicaRecord, remodel: Remodel, continuing: () => boolean): Promise<Advancement>;
+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,EACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAe,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5E,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B,gBAAgB,GAChB,WAAW,GACX,cAAc,CAAC;AAEnB,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,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,OAAO,GACxB,OAAO,CAAC,WAAW,CAAC,CAwEtB;AAED,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,CAKzB"}

package/dist/refresh.js

@@ -1,65 +1,88 @@
+import { acceptedBinaries } from './overlay.js';
 import { readStaged } from './replica.js';
 import { unconfirmed } from './transfer.js';
-export async function refreshRoom(adapter, authorization, confirmed, binding) {
-    const locator = confirmed.record.locator;
-    const fromRoomVersion = confirmed.record.roomVersion;
+export async function advancement(adapter, authorization, held, remodel, continuing) {
+    const locator = held.locator;
+    const fromRoomVersion = held.roomVersion;
     const first = await adapter.refresh(authorization, {
         locator,
-        selection: confirmed.record.replica.selection,
-        fromRoomVersion
+        selection: held.replica.selection,
+        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 binaryTargets = new Set(confirmed.record.binaryTargets);
-    const stage = (page)=>{
+    const models = remodel(first.models, {
+        collection: held.model,
+        selection: held.selectionModel,
+    });
+    const documents = { ...held.documents };
+    const revisions = { ...held.revisions };
+    const changes = { ...held.changes };
+    const written = { ...held.written };
+    const binaries = { ...held.binaries };
+    const stage = (page) => {
+        for (const path of Object.keys(page.documents)) {
+            delete binaries[path];
+            delete changes[path];
+            written[path] = roomVersion;
+        }
+        for (const path of Object.keys(page.binaryFiles)) {
+            delete documents[path];
+            delete changes[path];
+            delete written[path];
+        }
         Object.assign(documents, page.documents);
+        Object.assign(binaries, acceptedBinaries(page.binaryFiles));
         Object.assign(revisions, page.revisions);
-        for (const path of Object.keys(page.documents))binaryTargets.delete(path);
-        for (const target of page.binaryTargets){
-            delete documents[target];
-            delete revisions[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];
-            binaryTargets.delete(path);
+            delete changes[path];
+            delete written[path];
+            delete binaries[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,
+            selection: held.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({
-        ...confirmed.record,
-        roomVersion,
-        documents,
-        binaryTargets: [
-            ...binaryTargets
-        ].sort(),
-        revisions
-    }, binding);
-    return advanced === null ? unconfirmed : {
+    return {
         kind: 'advanced',
-        confirmed: advanced
+        record: {
+            ...held,
+            model: models.collection,
+            selectionModel: models.selection,
+            roomVersion,
+            documents,
+            binaries,
+            revisions,
+            changes,
+            written,
+        },
     };
 }
-
-//# sourceMappingURL=refresh.js.map
+export async function refreshRoom(adapter, authorization, confirmed, remodel, continuing) {
+    const advanced = await advancement(adapter, authorization, confirmed.record, remodel, continuing);
+    if (advanced.kind !== 'advanced')
+        return advanced;
+    const staged = readStaged(advanced.record, confirmed);
+    return staged.kind === 'staged' ? { kind: 'advanced', confirmed: staged.confirmed } : staged;
+}

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 { MutationResult } 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,36 @@ 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 confirmedOf(record: ReplicaRecord, previous?: ConfirmedLayer): ConfirmedLayer;
+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';
+};
+type Accepted = Extract<MutationResult, {
+    kind: 'accepted';
+}>;
+export declare function applyReturned(confirmed: ConfirmedLayer, submitted: ChangeBatch, accepted: Accepted, 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, current?: Readonly<Record<string, string>>): boolean;
+export declare function withdrawals(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean, local: 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,EAAmC,KAAK,WAAW,EAAqB,MAAM,aAAa,CAAC;AACnG,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAML,KAAK,KAAK,EACX,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,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,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,cAAc,CAK5F;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,CA2BnF;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,cAAc,GACvB,MAAM,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAW/B;AAoBD,KAAK,QAAQ,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC;AAE9D,wBAAgB,aAAa,CAC3B,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,CA+BR;AAgDD,wBAAgB,SAAS,CACvB,SAAS,EAAE,cAAc,EACzB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO,CA8BT;AA0ED,wBAAgB,MAAM,CACpB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,cAAc,EACzB,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GAC7C,OAAO,CAiBT;AAED,wBAAgB,WAAW,CACzB,SAAS,EAAE,cAAc,EACzB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,YAAY,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,EAC7C,KAAK,EAAE,OAAO,GACb,SAAS,WAAW,EAAE,CA2BxB"}