@weaveprotocol/core 0.1.2 → 0.2.1

package/dist/storage/segment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module storage/segment
+ * A batch of record versions, as a mirror keeps them: exactly as they travel
+ * on the wire — private bodies still sealed — packed into one immutable file.
+ *
+ * A segment's name sorts (a counter, for people reading a listing) and ends
+ * in the hash of its bytes, so an upload retried after a timeout lands on the
+ * same name, and two writers never write the same file differently.
+ */
+import type { Expression } from '../types.js';
+export declare const SEGMENT_SUFFIX = ".seg";
+/** Packs versions into a segment's bytes */
+export declare function packSegment(versions: ReadonlyArray<Expression>): Uint8Array;
+/** The versions in a segment; none for bytes that are not one */
+export declare function unpackSegment(bytes: Uint8Array): Expression[];
+/** A segment's file name: `000042-<first 16 hex of its hash>.seg` */
+export declare function segmentName(counter: number, bytes: Uint8Array): Promise<string>;
+/** Roughly how many bytes a version takes in a segment */
+export declare const versionSize: (version: Expression) => number;
+//# sourceMappingURL=segment.d.ts.map

package/dist/storage/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../src/storage/segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,eAAO,MAAM,cAAc,SAAS,CAAC;AAErC,4CAA4C;AAC5C,wBAAgB,WAAW,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,UAAU,CAE3E;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,EAAE,CAQ7D;AAED,qEAAqE;AACrE,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAGrF;AAED,0DAA0D;AAC1D,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,WAA+C,CAAC"}

package/dist/storage/segment.js

@@ -0,0 +1,27 @@
+import { sha256 } from '../utils/hash.js';
+import { utf8Decode, utf8Encode } from '../utils/encoding.js';
+export const SEGMENT_SUFFIX = '.seg';
+/** Packs versions into a segment's bytes */
+export function packSegment(versions) {
+    return utf8Encode(JSON.stringify({ v: 1, versions }));
+}
+/** The versions in a segment; none for bytes that are not one */
+export function unpackSegment(bytes) {
+    try {
+        const parsed = JSON.parse(utf8Decode(bytes));
+        if (parsed.v !== 1 || !Array.isArray(parsed.versions))
+            return [];
+        return parsed.versions.filter((version) => typeof version === 'object' && version !== null && typeof version.id === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+/** A segment's file name: `000042-<first 16 hex of its hash>.seg` */
+export async function segmentName(counter, bytes) {
+    const hash = Array.from((await sha256(bytes)).subarray(0, 8), (b) => b.toString(16).padStart(2, '0')).join('');
+    return `${String(counter).padStart(6, '0')}-${hash}${SEGMENT_SUFFIX}`;
+}
+/** Roughly how many bytes a version takes in a segment */
+export const versionSize = (version) => utf8Encode(JSON.stringify(version)).length;
+//# sourceMappingURL=segment.js.map

package/dist/storage/segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.js","sourceRoot":"","sources":["../../src/storage/segment.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE9D,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC;AAErC,4CAA4C;AAC5C,MAAM,UAAU,WAAW,CAAC,QAAmC;IAC7D,OAAO,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;AACxD,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,aAAa,CAAC,KAAiB;IAC7C,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAwC,CAAC;QACpF,IAAI,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;YAAE,OAAO,EAAE,CAAC;QACjE,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,EAAyB,EAAE,CAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,IAAI,OAAQ,OAAsB,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC;IACvK,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED,qEAAqE;AACrE,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,OAAe,EAAE,KAAiB;IAClE,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC/G,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,GAAG,cAAc,EAAE,CAAC;AACxE,CAAC;AAED,0DAA0D;AAC1D,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,OAAmB,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC"}

package/dist/storage/storage-provider.d.ts

@@ -1,32 +1,37 @@
 /**
  * @module storage-provider
- * A space's store: record versions, and the Merkle Search Tree that indexes them.
- *
- * The tree maps **record keys to version ids**:
+ * A space's store: record versions, and plain entries saying which is which.
  *
  * ```
- * r/<key>              → the current version          (every record)
- * g/<key>              → the record's first version   (once it has been edited)
- * h/<key>/<seq>/<id>   → a superseded version         (only if marked `retain`)
+ * r/<key>                      → the current version          (every record)
+ * g/<key>                      → the record's first version   (once it has been edited)
+ * h/<key>/<seq>/<id>           → a superseded version         (only if marked `retain`)
+ * i/<collection>/<time>/<id>   → every version kept, by collection — what sync compares
  * ```
  *
  * A version that arrives is compared with the one at `r/<key>` by the ordering
  * rule (`records/version.ts`). The winner takes `r/<key>`; the loser's body is
  * dropped — unless it is the record's first version, kept as proof of who
  * created it, or its writer marked it `retain`. The same set of versions gives
- * the same tree whatever order they arrive in, which is what lets two peers
- * converge.
+ * the same entries whatever order they arrive in, which is what lets two
+ * peers converge.
+ *
+ * Sync compares the `i/` entries: the set of versions kept, one collection at
+ * a time (`sync/negentropy.ts`). Nothing else is stored for it. The sets are
+ * read once and kept in memory, updated by every change made here; a change
+ * made by another writer of the same store (a tab, a folder's other device)
+ * reaches them through {@link StorageProvider.invalidate}.
  */
 import type { StorageAdapter, Expression } from '../types.js';
+import { ItemSet, type Sum } from '../sync/negentropy.js';
 export interface StorageProvider {
     /**
      * Takes in a version of a record: it becomes current if it supersedes the
      * current one, and is kept or dropped otherwise. Idempotent.
-     * @returns The new tree root
      */
-    addExpression(expression: Expression): Promise<string | null>;
-    /** Drops a version from the tree and the store, wherever it is indexed. */
-    removeExpression(id: string): Promise<string | null>;
+    addExpression(expression: Expression): Promise<void>;
+    /** Drops a version from the store and wherever it is indexed. */
+    removeExpression(id: string): Promise<void>;
     /** A version by its id, current or not, if this store holds it. */
     getExpression(id: string): Promise<Expression | null>;
     /** The current version of a record — possibly a delete. */
@@ -35,51 +40,42 @@ export interface StorageProvider {
     getGenesis(key: string): Promise<Expression | null>;
     /** Every version of a record this store keeps: current, first, and retained. Newest first. */
     history(key: string): Promise<Expression[]>;
-    /** {@link history} for every record whose key starts with `prefix`, reading only that part of the tree. */
+    /** {@link history} for every record whose key starts with `prefix`, reading only those entries. */
     histories(prefix: string): Promise<Map<string, Expression[]>>;
     /** Current versions of every record, deletes included. */
     listCurrent(): Promise<Expression[]>;
     /** Current versions in one collection, deletes included — found through the store's collection index. */
     queryExpressions(collection: string): Promise<Expression[]>;
-    /** Every tree entry, for sync and copying: `r/…`, `g/…`, `h/…` keys and the version ids under them. */
-    entries(): Promise<Array<{
-        key: string;
-        value: string;
-    }>>;
-    /** Get the current MST root CID. */
-    getRootCid(): Promise<string | null>;
+    /** The id of every version this store keeps — current, first and retained. */
+    versionIds(): Promise<string[]>;
+    /** The versions kept in one collection, as sync compares them: sorted, with sums. */
+    items(collection: string): Promise<ItemSet>;
+    /** Every collection this store keeps anything in, and the sum of its version ids. */
+    sums(): Promise<ReadonlyMap<string, Sum>>;
     /**
-     * Deletes the tree nodes the root no longer reaches. Every change rewrites
-     * the path to one entry and leaves the old path behind, so without this a
-     * store grows with every edit ever made rather than with its records.
-     *
-     * Tabs share a browser's store, and a change another tab has in flight may
-     * build on nodes this one's root has left. So a node is deleted only once it
-     * was already unreachable at a compaction at least `graceMs` earlier —
-     * remembered in the store, so it holds across sessions. A store whose other
-     * writers can lag by more than that — a folder behind a sync service — must
-     * not be compacted at all.
-     * @returns How many nodes were deleted
+     * One fingerprint of everything kept, hex. Equal fingerprints mean the
+     * same versions kept — for status, and for tests.
      */
-    compact(): Promise<number>;
+    fingerprint(): Promise<string>;
+    /** Forgets what was read into memory: another writer changed the store underneath. */
+    invalidate(): void;
     /** Get the underlying storage adapter. */
     getAdapter(): StorageAdapter;
     /** Close the storage adapter. */
     close(): Promise<void>;
 }
-export interface StorageProviderOptions {
-    /** Compact on its own after this many changes (see `compact`). Off by default. */
-    readonly compactEvery?: number;
-    /** How long a node stays unreachable before `compact` deletes it. Default a minute. */
-    readonly graceMs?: number;
-}
 export declare const CURRENT_PREFIX = "r/";
 export declare const GENESIS_PREFIX = "g/";
 export declare const HISTORY_PREFIX = "h/";
+export declare const ITEM_PREFIX = "i/";
+/**
+ * Where a version sorts for sync: its own time, in whole seconds. Only an
+ * order — a wrong clock makes a version slower to find, never lost.
+ */
+export declare function syncTime(version: Pick<Expression, 'createdAt'>): number;
 /**
  * Creates a StorageProvider wrapping an adapter.
  * @param adapter The initialized storage adapter.
- * @returns The StorageProvider orchestrator.
  */
-export declare function createStorageProvider(adapter: StorageAdapter, options?: StorageProviderOptions): StorageProvider;
+export declare function createStorageProvider(adapter: StorageAdapter): StorageProvider;
 //# sourceMappingURL=storage-provider.d.ts.map

package/dist/storage/storage-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-provider.d.ts","sourceRoot":"","sources":["../../src/storage/storage-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAW,MAAM,aAAa,CAAC;AAKvE,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9D,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrD,mEAAmE;IACnE,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACtD,2DAA2D;IAC3D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACpD,kFAAkF;IAClF,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACpD,8FAA8F;IAC9F,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC5C,2GAA2G;IAC3G,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAC9D,0DAA0D;IAC1D,WAAW,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACrC,yGAAyG;IACzG,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC5D,uGAAuG;IACvG,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IAC1D,oCAAoC;IACpC,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrC;;;;;;;;;;;;OAYG;IACH,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3B,0CAA0C;IAC1C,UAAU,IAAI,cAAc,CAAC;IAC7B,iCAAiC;IACjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAQD,MAAM,WAAW,sBAAsB;IACrC,kFAAkF;IAClF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,uFAAuF;IACvF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,cAAc,OAAO,CAAC;AAOnC;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,GAAE,sBAA2B,GAAG,eAAe,CAsMpH"}
+{"version":3,"file":"storage-provider.d.ts","sourceRoot":"","sources":["../../src/storage/storage-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAW,MAAM,aAAa,CAAC;AAIvE,OAAO,EAAmD,OAAO,EAA4B,KAAK,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAErI,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,mEAAmE;IACnE,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACtD,2DAA2D;IAC3D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACpD,kFAAkF;IAClF,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACpD,8FAA8F;IAC9F,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC5C,mGAAmG;IACnG,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IAC9D,0DAA0D;IAC1D,WAAW,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACrC,yGAAyG;IACzG,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC5D,8EAA8E;IAC9E,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAChC,qFAAqF;IACrF,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,qFAAqF;IACrF,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC1C;;;OAGG;IACH,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,sFAAsF;IACtF,UAAU,IAAI,IAAI,CAAC;IACnB,0CAA0C;IAC1C,UAAU,IAAI,cAAc,CAAC;IAC7B,iCAAiC;IACjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,WAAW,OAAO,CAAC;AAOhC;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,GAAG,MAAM,CAGvE;AA8BD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CA8P9E"}

package/dist/storage/storage-provider.js

@@ -1,191 +1,273 @@
 /**
  * @module storage-provider
- * A space's store: record versions, and the Merkle Search Tree that indexes them.
- *
- * The tree maps **record keys to version ids**:
+ * A space's store: record versions, and plain entries saying which is which.
  *
  * ```
- * r/<key>              → the current version          (every record)
- * g/<key>              → the record's first version   (once it has been edited)
- * h/<key>/<seq>/<id>   → a superseded version         (only if marked `retain`)
+ * r/<key>                      → the current version          (every record)
+ * g/<key>                      → the record's first version   (once it has been edited)
+ * h/<key>/<seq>/<id>           → a superseded version         (only if marked `retain`)
+ * i/<collection>/<time>/<id>   → every version kept, by collection — what sync compares
  * ```
  *
  * A version that arrives is compared with the one at `r/<key>` by the ordering
  * rule (`records/version.ts`). The winner takes `r/<key>`; the loser's body is
  * dropped — unless it is the record's first version, kept as proof of who
  * created it, or its writer marked it `retain`. The same set of versions gives
- * the same tree whatever order they arrive in, which is what lets two peers
- * converge.
+ * the same entries whatever order they arrive in, which is what lets two
+ * peers converge.
+ *
+ * Sync compares the `i/` entries: the set of versions kept, one collection at
+ * a time (`sync/negentropy.ts`). Nothing else is stored for it. The sets are
+ * read once and kept in memory, updated by every change made here; a change
+ * made by another writer of the same store (a tab, a folder's other device)
+ * reaches them through {@link StorageProvider.invalidate}.
  */
-import { insertIntoMST, deleteFromMST, lookupInMST, listMSTEntries, collectReachableCids } from './mst.js';
 import { byVersion, supersedes } from '../records/version.js';
-import { utf8Encode, utf8Decode } from '../utils/encoding.js';
-const ROOT_KEY = '__mst_root';
-/** Unreachable nodes found by the last compaction, and when */
-const CONDEMNED_KEY = '__condemned';
-/** A tree node's key in the store: its CID, `b` and 52 base32 characters */
-const NODE_KEY = /^b[a-z2-7]{52}$/;
+import { utf8Encode, utf8Decode, bytesToHex } from '../utils/encoding.js';
+import { cidDigest } from '../utils/hash.js';
+import { addToSum, combineSums, EMPTY_SUM, fingerprintOf, ItemSet, removeFromSum } from '../sync/negentropy.js';
 export const CURRENT_PREFIX = 'r/';
 export const GENESIS_PREFIX = 'g/';
 export const HISTORY_PREFIX = 'h/';
+export const ITEM_PREFIX = 'i/';
 const currentKey = (key) => `${CURRENT_PREFIX}${key}`;
 const genesisKey = (key) => `${GENESIS_PREFIX}${key}`;
 /** `seq` padded so a key's history lists in order */
 const historyKey = (e) => `${HISTORY_PREFIX}${e.key}/${String(e.seq).padStart(15, '0')}/${e.id}`;
+/**
+ * Where a version sorts for sync: its own time, in whole seconds. Only an
+ * order — a wrong clock makes a version slower to find, never lost.
+ */
+export function syncTime(version) {
+    const ms = Date.parse(version.createdAt);
+    return Number.isFinite(ms) && ms > 0 ? Math.floor(ms / 1000) : 0;
+}
+/** Collection names may hold anything; the entry needs them free of `/`. */
+const itemKey = (e) => `${ITEM_PREFIX}${encodeURIComponent(e.collection)}/${syncTime(e)}/${e.id}`;
+/** Reads an `i/` entry back: null for anything malformed, or an id that is not a content id */
+function parseItemKey(key) {
+    const [, collection, time, id, extra] = key.split('/');
+    if (collection === undefined || time === undefined || id === undefined || extra !== undefined)
+        return null;
+    const digest = cidDigest(id);
+    const timestamp = Number(time);
+    if (!digest || !Number.isSafeInteger(timestamp) || timestamp < 0)
+        return null;
+    try {
+        return { collection: decodeURIComponent(collection), id, item: { timestamp, id: digest } };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Creates a StorageProvider wrapping an adapter.
  * @param adapter The initialized storage adapter.
- * @returns The StorageProvider orchestrator.
  */
-export function createStorageProvider(adapter, options = {}) {
-    async function getRootCid(store = adapter) {
-        const bytes = await store.get(ROOT_KEY);
-        return bytes ? utf8Decode(bytes) : null;
-    }
-    // Every change reads the root, rewrites the path to one entry, and writes a
-    // new root. Two of those interleaved would each start from the same root and
-    // the second would silently drop the first's entry. So changes take turns.
+export function createStorageProvider(adapter) {
+    // Every change reads the current version, then writes. Two of those
+    // interleaved would each decide against the same current version, and one
+    // would lose its place. So changes take turns.
     let tail = Promise.resolve();
     const exclusively = (change) => {
         const run = tail.then(change, change);
         tail = run.catch(() => { });
         return run;
     };
+    // ─── What sync compares, in memory ─────────────────────────────────
+    /** Versions kept, by collection, then by id. Null until first needed. */
+    let kept = null;
+    /** Sorted sets, built when a reconciliation asks for one and dropped when their collection changes */
+    const sets = new Map();
+    /** The sum of each collection's ids, kept up to date on every change: a hello needs no sorting */
+    let totals = null;
+    /** Read in turn with changes, so none lands between the listing and the sets being kept up to date */
+    const loadKept = async () => kept ??
+        exclusively(async () => {
+            if (kept)
+                return kept;
+            const loaded = new Map();
+            for (const key of await adapter.list(ITEM_PREFIX)) {
+                const parsed = parseItemKey(key);
+                if (!parsed)
+                    continue;
+                (loaded.get(parsed.collection) ?? loaded.set(parsed.collection, new Map()).get(parsed.collection)).set(parsed.id, parsed.item);
+            }
+            kept = loaded;
+            totals = new Map();
+            for (const [collection, byId] of loaded) {
+                let sum = EMPTY_SUM;
+                for (const item of byId.values())
+                    sum = addToSum(sum, item.id);
+                totals.set(collection, sum);
+            }
+            return loaded;
+        });
+    /** Keeps the in-memory sets in step with a change just written */
+    const track = (added, removed) => {
+        for (const e of [...added, ...removed])
+            sets.delete(e.collection);
+        if (!kept || !totals)
+            return;
+        for (const e of removed) {
+            const item = kept.get(e.collection)?.get(e.id);
+            if (!item)
+                continue;
+            kept.get(e.collection).delete(e.id);
+            totals.set(e.collection, removeFromSum(totals.get(e.collection) ?? EMPTY_SUM, item.id));
+        }
+        for (const e of added) {
+            const digest = cidDigest(e.id);
+            const byId = kept.get(e.collection) ?? kept.set(e.collection, new Map()).get(e.collection);
+            if (!digest || byId.has(e.id))
+                continue;
+            byId.set(e.id, { timestamp: syncTime(e), id: digest });
+            totals.set(e.collection, addToSum(totals.get(e.collection) ?? EMPTY_SUM, digest));
+        }
+    };
+    // ─── Changes ───────────────────────────────────────────────────────
     /**
-     * Runs one change of the tree. Its node writes are held and made in one
-     * batch with the new root, so a change lands whole or not at all, in one
-     * transaction rather than one per node. Versions it drops are deleted only
-     * after, so the tree never names a record that is gone.
+     * Runs one change. Its entry writes are held and made in one batch, so a
+     * change lands whole or not at all. Versions it drops are deleted only
+     * after, so no entry ever names a record that is gone.
      */
     const change = (run) => exclusively(async () => {
         const writes = new Map();
-        const tree = {
-            ...adapter,
-            get: async (key) => (writes.has(key) ? writes.get(key) : adapter.get(key)),
-            has: async (key) => (writes.has(key) ? writes.get(key) !== null : adapter.has(key)),
-            put: async (key, value) => void writes.set(key, value),
-            delete: async (key) => void writes.set(key, null),
+        const added = new Map();
+        const dropped = new Map();
+        const entries = {
+            get: async (key) => {
+                const bytes = writes.has(key) ? writes.get(key) : await adapter.get(key);
+                return bytes ? utf8Decode(bytes) : null;
+            },
+            set: (key, id) => void writes.set(key, utf8Encode(id)),
+            unset: (key) => void writes.set(key, null),
+            keep: async (version) => {
+                await adapter.putExpression(version);
+                writes.set(itemKey(version), utf8Encode(version.id));
+                added.set(version.id, version);
+                dropped.delete(version.id);
+            },
+            drop: (version) => {
+                writes.set(itemKey(version), null);
+                dropped.set(version.id, version);
+                added.delete(version.id);
+            },
         };
-        const dropped = [];
-        const before = await getRootCid();
-        const root = await run(tree, before, (id) => dropped.push(id));
-        if (root === before && writes.size === 0 && dropped.length === 0)
-            return root;
-        writes.set(ROOT_KEY, root ? utf8Encode(root) : null);
+        await run(entries);
+        if (writes.size === 0 && dropped.size === 0)
+            return;
         await adapter.batch([...writes].map(([key, value]) => (value ? { type: 'put', key, value } : { type: 'delete', key })));
-        for (const id of dropped)
+        for (const id of dropped.keys())
             await adapter.deleteExpression(id);
-        changed();
-        return root;
-    });
-    const graceMs = options.graceMs ?? 60_000;
-    const compact = () => exclusively(async () => {
-        const reachable = await collectReachableCids(adapter, await getRootCid());
-        const dead = (await adapter.list('b')).filter((key) => NODE_KEY.test(key) && !reachable.has(key));
-        const saved = await adapter.get(CONDEMNED_KEY);
-        const earlier = saved ? JSON.parse(utf8Decode(saved)) : null;
-        const ripe = graceMs === 0 ? dead : earlier && Date.now() - earlier.at >= graceMs ? earlier.cids : null;
-        const condemn = (cids) => ({ type: 'put', key: CONDEMNED_KEY, value: utf8Encode(JSON.stringify({ at: Date.now(), cids })) });
-        // Too soon to delete anything: remember what is dead now, unless an earlier list is already waiting.
-        if (ripe === null) {
-            if (!earlier)
-                await adapter.batch([condemn(dead)]);
-            return 0;
-        }
-        const doomed = new Set(ripe);
-        const deleting = dead.filter((key) => doomed.has(key));
-        await adapter.batch([...deleting.map((key) => ({ type: 'delete', key })), condemn(dead.filter((key) => !doomed.has(key)))]);
-        return deleting.length;
+        track([...added.values()], [...dropped.values()]);
     });
-    let changes = 0;
-    /** Counts a change, and compacts once enough have piled up */
-    const changed = () => {
-        if (options.compactEvery && ++changes >= options.compactEvery) {
-            changes = 0;
-            void compact().catch(() => { });
-        }
-    };
     /**
      * Places a version that is not current: the record's first version if it is
      * the lowest-id one seen, history if retained, otherwise gone.
      */
-    async function demote(tree, root, version, current, drop) {
+    async function demote(entries, version, current) {
         // A first version is kept as proof of who created the record — the one
         // with the lowest id, if several devices each created the same chosen key.
         // Not while the record is still at seq 0: then the current version is it.
         if (version.seq === 0 && current.seq > 0) {
-            const heldId = await lookupInMST(tree, root, genesisKey(version.key));
+            const heldId = await entries.get(genesisKey(version.key));
             if (heldId === version.id)
-                return root;
+                return;
             if (heldId === null || version.id < heldId) {
-                await adapter.putExpression(version);
-                root = await insertIntoMST(tree, root, genesisKey(version.key), version.id);
+                await entries.keep(version);
+                entries.set(genesisKey(version.key), version.id);
                 const displaced = heldId ? await adapter.getExpression(heldId) : null;
-                return displaced ? keepOrDrop(tree, root, displaced, drop) : root;
+                if (displaced)
+                    await keepOrDrop(entries, displaced);
+                return;
             }
         }
-        return keepOrDrop(tree, root, version, drop);
+        await keepOrDrop(entries, version);
     }
-    async function keepOrDrop(tree, root, version, drop) {
+    async function keepOrDrop(entries, version) {
         if (version.retain) {
-            await adapter.putExpression(version);
-            return insertIntoMST(tree, root, historyKey(version), version.id);
+            await entries.keep(version);
+            entries.set(historyKey(version), version.id);
+            return;
         }
-        drop(version.id);
-        return root;
+        entries.drop(version);
     }
     const load = async (ids) => (await Promise.all([...ids].map((id) => adapter.getExpression(id)))).filter((v) => v !== null);
+    const readId = async (key) => {
+        const bytes = await adapter.get(key);
+        return bytes ? utf8Decode(bytes) : null;
+    };
     async function histories(prefix) {
-        const root = await getRootCid();
         const ids = new Map();
-        for (const tree of [CURRENT_PREFIX, GENESIS_PREFIX, HISTORY_PREFIX]) {
-            for (const entry of await listMSTEntries(adapter, root, `${tree}${prefix}`)) {
-                // `r/<key>`, `g/<key>`, `h/<key>/<seq>/<id>` — a record key holds no `/`.
-                const key = entry.key.split('/')[1];
-                (ids.get(key) ?? ids.set(key, new Set()).get(key)).add(entry.value);
+        const add = (key, id) => (ids.get(key) ?? ids.set(key, new Set()).get(key)).add(id);
+        for (const entry of [CURRENT_PREFIX, GENESIS_PREFIX]) {
+            for (const name of await adapter.list(`${entry}${prefix}`)) {
+                const id = await readId(name);
+                if (id)
+                    add(name.slice(entry.length), id);
             }
         }
+        // `h/<key>/<seq>/<id>` — a record key holds no `/`, and the id is in the entry's name.
+        for (const name of await adapter.list(`${HISTORY_PREFIX}${prefix}`)) {
+            const [, key, , id] = name.split('/');
+            if (key && id)
+                add(key, id);
+        }
         const result = new Map();
         for (const [key, held] of ids)
             result.set(key, (await load(held)).sort(byVersion));
         return result;
     }
-    async function currentOf(tree, root, key) {
-        const id = await lookupInMST(tree, root, currentKey(key));
-        return id ? adapter.getExpression(id) : null;
+    async function items(collection) {
+        const cached = sets.get(collection);
+        if (cached)
+            return cached;
+        const set = new ItemSet((await loadKept()).get(collection)?.values() ?? []);
+        sets.set(collection, set);
+        return set;
+    }
+    async function sums() {
+        await loadKept();
+        return new Map([...(totals ?? [])].filter(([, sum]) => sum.count > 0));
     }
     return Object.freeze({
         addExpression(incoming) {
-            return change(async (tree, root, drop) => {
-                const current = await currentOf(tree, root, incoming.key);
-                if (current?.id === incoming.id)
-                    return root;
+            return change(async (entries) => {
+                const currentId = await entries.get(currentKey(incoming.key));
+                if (currentId === incoming.id)
+                    return;
+                const current = currentId ? await adapter.getExpression(currentId) : null;
                 if (current && !supersedes(incoming, current))
-                    return demote(tree, root, incoming, current, drop);
-                await adapter.putExpression(incoming);
-                root = await insertIntoMST(tree, root, currentKey(incoming.key), incoming.id);
-                return current ? demote(tree, root, current, incoming, drop) : root;
+                    return demote(entries, incoming, current);
+                await entries.keep(incoming);
+                entries.set(currentKey(incoming.key), incoming.id);
+                if (current)
+                    await demote(entries, current, incoming);
             });
         },
         removeExpression(id) {
-            return change(async (tree, root, drop) => {
+            return change(async (entries) => {
                 const version = await adapter.getExpression(id);
-                for (const key of version ? [currentKey(version.key), genesisKey(version.key), historyKey(version)] : []) {
-                    if ((await lookupInMST(tree, root, key)) === id)
-                        root = await deleteFromMST(tree, root, key);
+                if (!version)
+                    return;
+                for (const key of [currentKey(version.key), genesisKey(version.key)]) {
+                    if ((await entries.get(key)) === id)
+                        entries.unset(key);
                 }
-                drop(id);
-                return root;
+                entries.unset(historyKey(version));
+                entries.drop(version);
             });
         },
         async getExpression(id) {
             return adapter.getExpression(id);
         },
         async getCurrent(key) {
-            return currentOf(adapter, await getRootCid(), key);
+            const id = await readId(currentKey(key));
+            return id ? adapter.getExpression(id) : null;
         },
         async getGenesis(key) {
-            const id = await lookupInMST(adapter, await getRootCid(), genesisKey(key));
+            const id = await readId(genesisKey(key));
             return id ? adapter.getExpression(id) : null;
         },
         async history(key) {
@@ -193,28 +275,37 @@ export function createStorageProvider(adapter, options = {}) {
         },
         histories,
         async listCurrent() {
-            return load((await listMSTEntries(adapter, await getRootCid(), CURRENT_PREFIX)).map((e) => e.value));
+            const ids = await Promise.all((await adapter.list(CURRENT_PREFIX)).map(readId));
+            return load(ids.filter((id) => id !== null));
         },
         async queryExpressions(collection) {
-            // The index holds every version kept, not only current ones; the tree says which is current.
-            const root = await getRootCid();
+            // The index holds every version kept, not only current ones; the entries say which is current.
             const held = await adapter.queryExpressions(collection, Infinity);
-            const current = await Promise.all(held.map(async (v) => (await lookupInMST(adapter, root, currentKey(v.key))) === v.id));
+            const current = await Promise.all(held.map(async (v) => (await readId(currentKey(v.key))) === v.id));
             return held.filter((_, i) => current[i]);
         },
-        async entries() {
-            return listMSTEntries(adapter, await getRootCid());
+        async versionIds() {
+            return [...(await loadKept()).values()].flatMap((byId) => [...byId.keys()]);
         },
-        async getRootCid() {
-            return getRootCid();
+        items,
+        sums,
+        async fingerprint() {
+            let total = EMPTY_SUM;
+            for (const sum of (await sums()).values())
+                total = combineSums(total, sum);
+            return bytesToHex(await fingerprintOf(total));
+        },
+        invalidate() {
+            kept = null;
+            totals = null;
+            sets.clear();
         },
-        compact,
         getAdapter() {
             return adapter;
         },
         async close() {
             await adapter.close();
-        }
+        },
     });
 }
 //# sourceMappingURL=storage-provider.js.map