@dxos/echo-pipeline 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/package.json

@@ -1,41 +1,35 @@
 {
   "name": "@dxos/echo-pipeline",
-  "version": "0.8.4-main.ae835ea",
+  "version": "0.8.4-main.bc2380dfbc",
   "description": "ECHO database.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
+      "default": "./dist/lib/neutral/testing/index.mjs"
     },
     "./filter": {
       "source": "./src/filter/index.ts",
       "types": "./dist/types/src/filter/index.d.ts",
-      "browser": "./dist/lib/browser/filter/index.mjs",
-      "node": "./dist/lib/node-esm/filter/index.mjs"
+      "default": "./dist/lib/neutral/filter/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "testing": [
-        "dist/types/src/testing/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "testing.d.ts",
     "testing.js",
@@ -43,50 +37,58 @@
     "src"
   ],
   "dependencies": {
-    "@automerge/automerge": "3.1.2",
-    "@automerge/automerge-repo": "2.4.0",
+    "@automerge/automerge": "3.2.6",
+    "@automerge/automerge-repo": "2.6.0-subduction.17",
+    "@automerge/automerge-subduction": "0.12.1",
+    "@effect/sql": "0.49.0",
+    "@effect/sql-sqlite-node": "0.50.1",
+    "bs58check": "^4.0.0",
     "crc-32": "^1.2.2",
-    "effect": "3.18.3",
+    "effect": "3.20.0",
+    "fast-deep-equal": "^3.1.3",
     "level-transcoder": "^1.0.1",
-    "lodash.isequal": "^4.5.0",
-    "@dxos/codec-protobuf": "0.8.4-main.ae835ea",
-    "@dxos/async": "0.8.4-main.ae835ea",
-    "@dxos/context": "0.8.4-main.ae835ea",
-    "@dxos/credentials": "0.8.4-main.ae835ea",
-    "@dxos/crypto": "0.8.4-main.ae835ea",
-    "@dxos/debug": "0.8.4-main.ae835ea",
-    "@dxos/echo-protocol": "0.8.4-main.ae835ea",
-    "@dxos/echo": "0.8.4-main.ae835ea",
-    "@dxos/edge-client": "0.8.4-main.ae835ea",
-    "@dxos/errors": "0.8.4-main.ae835ea",
-    "@dxos/feed-store": "0.8.4-main.ae835ea",
-    "@dxos/hypercore": "0.8.4-main.ae835ea",
-    "@dxos/invariant": "0.8.4-main.ae835ea",
-    "@dxos/keyring": "0.8.4-main.ae835ea",
-    "@dxos/keys": "0.8.4-main.ae835ea",
-    "@dxos/kv-store": "0.8.4-main.ae835ea",
-    "@dxos/indexing": "0.8.4-main.ae835ea",
-    "@dxos/log": "0.8.4-main.ae835ea",
-    "@dxos/messaging": "0.8.4-main.ae835ea",
-    "@dxos/network-manager": "0.8.4-main.ae835ea",
-    "@dxos/protocols": "0.8.4-main.ae835ea",
-    "@dxos/node-std": "0.8.4-main.ae835ea",
-    "@dxos/random-access-storage": "0.8.4-main.ae835ea",
-    "@dxos/teleport-extension-automerge-replicator": "0.8.4-main.ae835ea",
-    "@dxos/teleport-extension-gossip": "0.8.4-main.ae835ea",
-    "@dxos/teleport-extension-object-sync": "0.8.4-main.ae835ea",
-    "@dxos/timeframe": "0.8.4-main.ae835ea",
-    "@dxos/teleport": "0.8.4-main.ae835ea",
-    "@dxos/tracing": "0.8.4-main.ae835ea",
-    "@dxos/teleport-extension-replicator": "0.8.4-main.ae835ea",
-    "@dxos/typings": "0.8.4-main.ae835ea",
-    "@dxos/util": "0.8.4-main.ae835ea"
+    "semver": "^7.7.3",
+    "@dxos/async": "0.8.4-main.bc2380dfbc",
+    "@dxos/codec-protobuf": "0.8.4-main.bc2380dfbc",
+    "@dxos/context": "0.8.4-main.bc2380dfbc",
+    "@dxos/credentials": "0.8.4-main.bc2380dfbc",
+    "@dxos/debug": "0.8.4-main.bc2380dfbc",
+    "@dxos/crypto": "0.8.4-main.bc2380dfbc",
+    "@dxos/echo-protocol": "0.8.4-main.bc2380dfbc",
+    "@dxos/echo": "0.8.4-main.bc2380dfbc",
+    "@dxos/effect": "0.8.4-main.bc2380dfbc",
+    "@dxos/edge-client": "0.8.4-main.bc2380dfbc",
+    "@dxos/errors": "0.8.4-main.bc2380dfbc",
+    "@dxos/feed-store": "0.8.4-main.bc2380dfbc",
+    "@dxos/feed": "0.8.4-main.bc2380dfbc",
+    "@dxos/hypercore": "0.8.4-main.bc2380dfbc",
+    "@dxos/index-core": "0.8.4-main.bc2380dfbc",
+    "@dxos/invariant": "0.8.4-main.bc2380dfbc",
+    "@dxos/keyring": "0.8.4-main.bc2380dfbc",
+    "@dxos/kv-store": "0.8.4-main.bc2380dfbc",
+    "@dxos/log": "0.8.4-main.bc2380dfbc",
+    "@dxos/messaging": "0.8.4-main.bc2380dfbc",
+    "@dxos/keys": "0.8.4-main.bc2380dfbc",
+    "@dxos/network-manager": "0.8.4-main.bc2380dfbc",
+    "@dxos/protocols": "0.8.4-main.bc2380dfbc",
+    "@dxos/node-std": "0.8.4-main.bc2380dfbc",
+    "@dxos/teleport": "0.8.4-main.bc2380dfbc",
+    "@dxos/sql-sqlite": "0.8.4-main.bc2380dfbc",
+    "@dxos/teleport-extension-automerge-replicator": "0.8.4-main.bc2380dfbc",
+    "@dxos/teleport-extension-gossip": "0.8.4-main.bc2380dfbc",
+    "@dxos/teleport-extension-object-sync": "0.8.4-main.bc2380dfbc",
+    "@dxos/random-access-storage": "0.8.4-main.bc2380dfbc",
+    "@dxos/teleport-extension-replicator": "0.8.4-main.bc2380dfbc",
+    "@dxos/typings": "0.8.4-main.bc2380dfbc",
+    "@dxos/timeframe": "0.8.4-main.bc2380dfbc",
+    "@dxos/util": "0.8.4-main.bc2380dfbc",
+    "@dxos/tracing": "0.8.4-main.bc2380dfbc"
   },
   "devDependencies": {
-    "@types/lodash.isequal": "^4.5.0",
+    "@types/semver": "^7.7.1",
     "fast-check": "^3.19.0",
     "get-port-please": "^3.1.1",
-    "@dxos/test-utils": "0.8.4-main.ae835ea"
+    "@dxos/test-utils": "0.8.4-main.bc2380dfbc"
   },
   "publishConfig": {
     "access": "public"

package/src/automerge/automerge-host-subduction.test.ts

@@ -0,0 +1,263 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { getHeads } from '@automerge/automerge';
+import * as Automerge from '@automerge/automerge';
+import { type DocumentId, type Heads, generateAutomergeUrl, parseAutomergeUrl } from '@automerge/automerge-repo';
+import { describe, onTestFinished, test } from 'vitest';
+
+import { sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
+import type { CollectionId } from '@dxos/echo-protocol';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import type { LevelDB } from '@dxos/kv-store';
+import { createTestLevel } from '@dxos/kv-store/testing';
+import { openAndClose } from '@dxos/test-utils';
+import { range } from '@dxos/util';
+
+import { TestReplicationNetwork } from '../testing';
+import { AutomergeHost } from './automerge-host';
+
+describe('AutomergeHost with Subduction', () => {
+  test('can create documents', async ({ expect }) => {
+    const level = await createLevel();
+    const host = await setupAutomergeHost({ level });
+    const handle = await host.createDoc<any>();
+    handle.change((doc: any) => {
+      doc.text = 'Hello world';
+    });
+    await host.flush(Context.default());
+    expect(handle.doc()!.text).toEqual('Hello world');
+  });
+
+  test('changes are preserved in storage', async ({ expect }) => {
+    const level = await createLevel();
+    const host = await setupAutomergeHost({ level });
+    const handle = await host.createDoc<any>();
+    handle.change((doc: any) => {
+      doc.text = 'Hello world';
+    });
+    const url = handle.url;
+
+    await host.flush(Context.default());
+    await host.close();
+
+    const host2 = await setupAutomergeHost({ level });
+    const handle2 = await host2.loadDoc<any>(Context.default(), url);
+    invariant(handle2);
+    await handle2.whenReady();
+    expect(handle2.doc()!.text).toEqual('Hello world');
+    await host2.flush(Context.default());
+  });
+
+  test('load resolves when document is created from binary', async ({ expect }) => {
+    const level = await createLevel();
+    const host = await setupAutomergeHost({ level });
+
+    const document = Automerge.from({ text: 'Hello world' });
+    const binary = Automerge.save(document);
+    const { documentId } = parseAutomergeUrl(generateAutomergeUrl());
+
+    const loadPromise = host.loadDoc(Context.default(), documentId);
+
+    const createdHandle = await host.createDoc(binary, { preserveHistory: true, documentId });
+
+    const loadedHandle = await loadPromise;
+    invariant(loadedHandle);
+    expect(loadedHandle.doc()).toEqual(createdHandle.doc());
+  });
+
+  test('query single document heads', async ({ expect }) => {
+    const tmpPath = `/tmp/dxos-${PublicKey.random().toHex()}`;
+
+    const level = await createLevel(tmpPath);
+    const host = await setupAutomergeHost({ level });
+    const handle = await host.createDoc({ text: 'Hello world' });
+    const expectedHeads = getHeads(handle.doc()!);
+    await host.flush(Context.default());
+
+    expect(await host.getHeads([handle.documentId])).toEqual([expectedHeads]);
+    await host.close();
+    await level.close();
+
+    {
+      const host = await setupAutomergeHost({ level: await createLevel(tmpPath) });
+      expect(await host.getHeads([handle.documentId])).toEqual([expectedHeads]);
+    }
+  });
+
+  test('query multiple document heads', async ({ expect }) => {
+    const tmpPath = `/tmp/dxos-${PublicKey.random().toHex()}`;
+
+    const level = await createLevel(tmpPath);
+    const host = await setupAutomergeHost({ level });
+    const handles = await Promise.all(range(2, () => host.createDoc({ text: 'Hello world' })));
+    const expectedHeads: (Heads | undefined)[] = handles.map((handle) => getHeads(handle.doc()!));
+    await host.flush(Context.default());
+
+    const ids = handles.map((handle) => handle.documentId);
+    ids.splice(1, 0, 'non-existent-id' as DocumentId);
+    expectedHeads.splice(1, 0, undefined);
+
+    expect(await host.getHeads(ids)).toEqual(expectedHeads);
+    await host.close();
+    await level.close();
+
+    {
+      const level = await createLevel(tmpPath);
+      const host = await setupAutomergeHost({ level });
+      expect(await host.getHeads(ids)).toEqual(expectedHeads);
+      await host.close();
+      await level.close();
+    }
+  });
+
+  test('loads remote document over replication network', { timeout: 5_000 }, async ({ expect }) => {
+    const level1 = await createLevel();
+    const host1 = await setupAutomergeHost({ level: level1 });
+
+    const level2 = await createLevel();
+    const host2 = await setupAutomergeHost({ level: level2 });
+    const handle = await host2.createDoc({ text: 'Hello from Subduction' });
+    await host2.flush(Context.default());
+    await waitForSubductionSave();
+
+    const network = await new TestReplicationNetwork().open();
+    try {
+      await host1.addReplicator(Context.default(), await network.createReplicator());
+      await host2.addReplicator(Context.default(), await network.createReplicator());
+
+      const loaded = await host1.loadDoc<{ text: string }>(Context.default(), handle.documentId, { timeout: 1_000 });
+      invariant(loaded);
+      expect(loaded.doc()!.text).toEqual('Hello from Subduction');
+    } finally {
+      await host1.close();
+      await host2.close();
+      await network.close();
+    }
+  });
+
+  test('collection synchronization', { timeout: 5_000 }, async ({ expect }) => {
+    const NUM_DOCUMENTS = 10;
+
+    const level1 = await createLevel();
+    const host1 = await setupAutomergeHost({ level: level1 });
+
+    const level2 = await createLevel();
+    const host2 = await setupAutomergeHost({ level: level2 });
+    const documentIds: DocumentId[] = [];
+    for (const i of range(NUM_DOCUMENTS)) {
+      const handle = await host2.createDoc({ docIndex: i });
+      documentIds.push(handle.documentId);
+    }
+    await host2.flush(Context.default());
+    await waitForSubductionSave();
+
+    const network = await new TestReplicationNetwork().open();
+    try {
+      await host1.addReplicator(Context.default(), await network.createReplicator());
+      await host2.addReplicator(Context.default(), await network.createReplicator());
+
+      const collectionId = 'test-collection';
+      const collectionUpdates: CollectionId[] = [];
+      const unsubscribe = host1.collectionStateUpdated.on(({ collectionId }) => {
+        collectionUpdates.push(collectionId);
+      });
+      await host1.updateLocalCollectionState(collectionId, documentIds);
+      await host2.updateLocalCollectionState(collectionId, documentIds);
+
+      for (const documentId of documentIds) {
+        await expect
+          .poll(() => host1.getHeads([documentId]), { timeout: 1_000 })
+          .toEqual(await host2.getHeads([documentId]));
+      }
+
+      // collectionStateUpdated fires whenever host1 observes a `collection-state` from host2
+      // (see {@link CollectionSynchronizer.remoteStateUpdated}). At least one event must
+      // arrive for the heads to have converged via the collection-sync path rather than
+      // raw Subduction byte transport.
+      expect(collectionUpdates).toContain(collectionId as CollectionId);
+      unsubscribe();
+    } finally {
+      await host1.close();
+      await host2.close();
+      await network.close();
+    }
+  });
+
+  test('collection synchronization is bidirectional', { timeout: 10_000 }, async ({ expect }) => {
+    const host1DocumentIds: DocumentId[] = [];
+    const host2DocumentIds: DocumentId[] = [];
+
+    const level1 = await createLevel();
+    const host1 = await setupAutomergeHost({ level: level1 });
+    for (const i of range(3)) {
+      const handle = await host1.createDoc({ host: 1, docIndex: i });
+      host1DocumentIds.push(handle.documentId);
+    }
+    await host1.flush(Context.default());
+
+    const level2 = await createLevel();
+    const host2 = await setupAutomergeHost({ level: level2 });
+    for (const i of range(3)) {
+      const handle = await host2.createDoc({ host: 2, docIndex: i });
+      host2DocumentIds.push(handle.documentId);
+    }
+    await host2.flush(Context.default());
+    await waitForSubductionSave();
+
+    const network = await new TestReplicationNetwork().open();
+    try {
+      await host1.addReplicator(Context.default(), await network.createReplicator());
+      await host2.addReplicator(Context.default(), await network.createReplicator());
+
+      const host1CollectionId = 'test-host1-collection';
+      await host1.updateLocalCollectionState(host1CollectionId, host1DocumentIds);
+      await host2.updateLocalCollectionState(host1CollectionId, host1DocumentIds);
+
+      for (const documentId of host1DocumentIds) {
+        await expect
+          .poll(() => host2.getHeads([documentId]), { timeout: 1_000 })
+          .toEqual(await host1.getHeads([documentId]));
+      }
+
+      const host2CollectionId = 'test-host2-collection';
+      await host1.updateLocalCollectionState(host2CollectionId, host2DocumentIds);
+      await host2.updateLocalCollectionState(host2CollectionId, host2DocumentIds);
+
+      for (const documentId of host2DocumentIds) {
+        await expect
+          .poll(() => host1.getHeads([documentId]), { timeout: 1_000 })
+          .toEqual(await host2.getHeads([documentId]));
+      }
+    } finally {
+      await host1.close();
+      await host2.close();
+      await network.close();
+    }
+  });
+});
+
+const createLevel = async (tmpPath?: string) => {
+  const level = createTestLevel(tmpPath);
+  await openAndClose(level);
+  return level;
+};
+
+const waitForSubductionSave = async () => {
+  await sleep(150);
+};
+
+const setupAutomergeHost = async ({ level }: { level: LevelDB }) => {
+  const host = new AutomergeHost({
+    db: level,
+    useSubduction: true,
+  });
+  await host.open();
+  onTestFinished(async () => {
+    await host.close();
+  });
+  return host;
+};

package/src/automerge/automerge-host.test.ts

@@ -2,11 +2,13 @@
 // Copyright 2023 DXOS.org
 //
 
-import { getHeads } from '@automerge/automerge';
-import type { DocumentId, Heads } from '@automerge/automerge-repo';
+import * as A from '@automerge/automerge';
+import { type DocumentId, type Heads, generateAutomergeUrl, parseAutomergeUrl } from '@automerge/automerge-repo';
 import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { IndexMetadataStore } from '@dxos/indexing';
+import { sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import type { LevelDB } from '@dxos/kv-store';
 import { createTestLevel } from '@dxos/kv-store/testing';
@@ -14,38 +16,60 @@ import { openAndClose } from '@dxos/test-utils';
 import { range } from '@dxos/util';
 
 import { TestReplicationNetwork } from '../testing';
-
 import { AutomergeHost } from './automerge-host';
+import { type EchoNetworkAdapter } from './echo-network-adapter';
 
 describe('AutomergeHost', () => {
   test('can create documents', async () => {
     const level = await createLevel();
     const host = await setupAutomergeHost({ level });
-    const handle = host.repo.create<any>();
+    const handle = await host.createDoc<any>();
     handle.change((doc: any) => {
       doc.text = 'Hello world';
     });
-    await host.repo.flush();
+    await host.flush(Context.default());
     expect(handle.doc()!.text).toEqual('Hello world');
   });
 
   test('changes are preserved in storage', async () => {
     const level = await createLevel();
     const host = await setupAutomergeHost({ level });
-    const handle = host.repo.create();
+    const handle = await host.createDoc<any>();
     handle.change((doc: any) => {
       doc.text = 'Hello world';
     });
     const url = handle.url;
 
-    await host.repo.flush();
+    await host.flush(Context.default());
     await host.close();
 
     const host2 = await setupAutomergeHost({ level });
-    const handle2 = await host2.repo.find<any>(url);
+    const handle2 = await host2.loadDoc<any>(Context.default(), url);
+    invariant(handle2);
     await handle2.whenReady();
     expect(handle2.doc()!.text).toEqual('Hello world');
-    await host2.repo.flush();
+    await host2.flush(Context.default());
+  });
+
+  test('load resolves when document is created from binary', async () => {
+    const level = await createLevel();
+    const host = await setupAutomergeHost({ level });
+
+    // Create a document to get its binary representation
+    const document = A.from({ text: 'Hello world' });
+    const binary = A.save(document);
+    const { documentId } = parseAutomergeUrl(generateAutomergeUrl());
+
+    // Start loading a non-existent document (should hang until created)
+    const loadPromise = host.loadDoc(Context.default(), documentId);
+
+    // Create the document from binary - this should resolve the load
+    const createdHandle = await host.createDoc(binary, { preserveHistory: true, documentId });
+
+    // The load should now resolve
+    const loadedHandle = await loadPromise;
+    invariant(loadedHandle);
+    expect(loadedHandle.doc()).toEqual(createdHandle.doc());
   });
 
   test('query single document heads', async () => {
@@ -53,9 +77,9 @@ describe('AutomergeHost', () => {
 
     const level = await createLevel(tmpPath);
     const host = await setupAutomergeHost({ level });
-    const handle = host.createDoc({ text: 'Hello world' });
-    const expectedHeads = getHeads(handle.doc()!);
-    await host.flush();
+    const handle = await host.createDoc({ text: 'Hello world' });
+    const expectedHeads = A.getHeads(handle.doc()!);
+    await host.flush(Context.default());
 
     expect(await host.getHeads([handle.documentId])).toEqual([expectedHeads]);
     await host.close();
@@ -73,9 +97,9 @@ describe('AutomergeHost', () => {
 
     const level = await createLevel(tmpPath);
     const host = await setupAutomergeHost({ level });
-    const handles = range(2, () => host.createDoc({ text: 'Hello world' }));
-    const expectedHeads: (Heads | undefined)[] = handles.map((handle) => getHeads(handle.doc()!));
-    await host.flush();
+    const handles = await Promise.all(range(2, () => host.createDoc({ text: 'Hello world' })));
+    const expectedHeads: (Heads | undefined)[] = handles.map((handle) => A.getHeads(handle.doc()!));
+    await host.flush(Context.default());
 
     const ids = handles.map((handle) => handle.documentId);
     ids.splice(1, 0, 'non-existent-id' as DocumentId);
@@ -95,40 +119,130 @@ describe('AutomergeHost', () => {
     }
   });
 
-  test('collection synchronization', async () => {
+  test('loadDoc respects fetchFromNetwork', { timeout: 10_000 }, async () => {
+    const level1 = await createLevel();
+    const host1 = await setupAutomergeHost({ level: level1 });
+
+    const level2 = await createLevel();
+    const host2 = await setupAutomergeHost({ level: level2 });
+    const handle = await host2.createDoc({ text: 'Hello world' });
+    await host2.flush(Context.default());
+
+    const network = await new TestReplicationNetwork().open();
+    await host1.addReplicator(Context.default(), await network.createReplicator());
+    await host2.addReplicator(Context.default(), await network.createReplicator());
+
+    // (1) fetchFromNetwork=false on a doc not yet on disk: returns null immediately
+    // without waiting on the network, even though host2 has it.
+    expect(
+      await host1.loadDoc(Context.default(), handle.documentId, { fetchFromNetwork: false, timeout: 1_000 }),
+    ).toBeNull();
+
+    // (2) fetchFromNetwork=true: host1 announces, host2 sends bytes, doc syncs.
+    const loaded = await host1.loadDoc<{ text: string }>(Context.default(), handle.documentId, {
+      fetchFromNetwork: true,
+      timeout: 5_000,
+    });
+    invariant(loaded);
+    expect(loaded.doc()!.text).toEqual('Hello world');
+
+    // (3) Now that host1 has the doc on disk, fetchFromNetwork=false succeeds.
+    await host1.flush(Context.default());
+    const localOnly = await host1.loadDoc<{ text: string }>(Context.default(), handle.documentId, {
+      fetchFromNetwork: false,
+    });
+    invariant(localOnly);
+    expect(localOnly.doc()!.text).toEqual('Hello world');
+
+    await host1.close();
+    await host2.close();
+    await network.close();
+  });
+
+  test('loadDoc with fetchFromNetwork=false does not announce when doc is in storage', { timeout: 5_000 }, async () => {
+    // Pre-populate host1's storage with the doc, then close so that the
+    // host1 we test with has the doc on disk but did not author it (i.e.
+    // it's not in `_createdDocuments` and won't auto-announce).
+    const tmpPath = `/tmp/dxos-${PublicKey.random().toHex()}`;
+    let documentId: DocumentId;
+    {
+      const level = await createLevel(tmpPath);
+      const provider = await setupAutomergeHost({ level });
+      const handle = await provider.createDoc({ text: 'Hello world' });
+      documentId = handle.documentId;
+      await provider.flush(Context.default());
+      await provider.close();
+      await level.close();
+    }
+
+    const level1 = await createLevel(tmpPath);
+    const host1 = await setupAutomergeHost({ level: level1 });
+
+    const level2 = await createLevel();
+    const host2 = await setupAutomergeHost({ level: level2 });
+
+    const network = await new TestReplicationNetwork().open();
+    await host1.addReplicator(Context.default(), await network.createReplicator());
+    await host2.addReplicator(Context.default(), await network.createReplicator());
+
+    // Spy on host2's incoming-request event — fires when any peer sends
+    // an automerge `request` message for a doc to host2. If host1 ever
+    // announced wanting `documentId`, this would trigger.
+    const requests: DocumentId[] = [];
+    const adapter = (host2 as unknown as { _echoNetworkAdapter: EchoNetworkAdapter })._echoNetworkAdapter;
+    adapter.documentRequested.on(({ documentId: requestedId }) => {
+      requests.push(requestedId);
+    });
+
+    // Load the doc that's already on disk; should resolve from storage.
+    const loaded = await host1.loadDoc<{ text: string }>(Context.default(), documentId, {
+      fetchFromNetwork: false,
+    });
+    invariant(loaded);
+    expect(loaded.doc()!.text).toEqual('Hello world');
+
+    // Give any in-flight share-policy debounce a chance to fire.
+    await sleep(100);
+
+    expect(requests).not.toContain(documentId);
+
+    await host1.close();
+    await host2.close();
+    await network.close();
+  });
+
+  test('collection synchronization', { timeout: 30_000 }, async () => {
     const NUM_DOCUMENTS = 10;
 
     const level1 = await createLevel();
     const host1 = await setupAutomergeHost({ level: level1 });
 
     const level2 = await createLevel();
+    const host2 = await setupAutomergeHost({ level: level2 });
     const documentIds: DocumentId[] = [];
-    {
-      const host2 = await setupAutomergeHost({ level: level2 });
-      for (const i of range(NUM_DOCUMENTS)) {
-        const handle = host2.createDoc({ docIndex: i });
-        documentIds.push(handle.documentId);
-      }
-      await host2.flush();
-      await host2.close();
+    for (const i of range(NUM_DOCUMENTS)) {
+      const handle = await host2.createDoc({ docIndex: i });
+      documentIds.push(handle.documentId);
     }
+    await host2.flush(Context.default());
 
-    const host2 = await setupAutomergeHost({ level: level2 });
+    const network = await new TestReplicationNetwork().open();
+    await host1.addReplicator(Context.default(), await network.createReplicator());
+    await host2.addReplicator(Context.default(), await network.createReplicator());
 
     const collectionId = 'test-collection';
     await host1.updateLocalCollectionState(collectionId, documentIds);
     await host2.updateLocalCollectionState(collectionId, documentIds);
 
-    await using network = await new TestReplicationNetwork().open();
-    await host1.addReplicator(await network.createReplicator());
-    await host2.addReplicator(await network.createReplicator());
-
     for (const documentId of documentIds) {
-      await expect.poll(() => host1.getHeads([documentId])).toEqual(await host2.getHeads([documentId]));
+      await expect
+        .poll(() => host1.getHeads([documentId]), { timeout: 20_000 })
+        .toEqual(await host2.getHeads([documentId]));
     }
 
     await host1.close();
     await host2.close();
+    await network.close();
   });
 
   const createLevel = async (tmpPath?: string) => {
@@ -141,7 +255,6 @@ describe('AutomergeHost', () => {
 const setupAutomergeHost = async ({ level }: { level: LevelDB }) => {
   const host = new AutomergeHost({
     db: level,
-    indexMetadataStore: new IndexMetadataStore({ db: level.sublevel('index-metadata') }),
   });
   await host.open();
   onTestFinished(async () => {