@fireproof/core 0.20.0-dev-preview-41 → 0.20.0-dev-preview-51

package/tests/blockstore/keyed-crypto.test.ts

@@ -1,12 +1,11 @@
-import { bs, ensureSuperThis, PARAM, rt } from "@fireproof/core";
+import { bs, ensureSuperThis, PARAM, rt, StoreType, storeType2DataMetaWal } from "@fireproof/core";
 import { BuildURI, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
 import { base58btc } from "multiformats/bases/base58";
-import { sha256 as hasher } from "multiformats/hashes/sha2";
-import * as dagCodec from "@ipld/dag-cbor";
+// import { sha256 as hasher } from "multiformats/hashes/sha2";
+// import * as dagCodec from "@ipld/dag-cbor";
+import * as cborg from "cborg";
 import type { KeyBagProviderIndexedDB } from "@fireproof/core/indexeddb";
 import { mockLoader, MockSuperThis, mockSuperThis } from "../helpers.js";
-import { KeyWithFingerPrint } from "../../src/blockstore/types.js";
-import { toKeyWithFingerPrint } from "../../src/runtime/key-bag.js";
 
 describe("KeyBag", () => {
   let url: URI;
@@ -113,10 +112,10 @@ describe("KeyBag", () => {
         return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeysItem;
       });
     }
-    expect((await toKeyWithFingerPrint(kb, Object.values(diskBag.keys)[0].key)).Ok().fingerPrint).toEqual(
+    expect((await rt.toKeyWithFingerPrint(kb, Object.values(diskBag.keys)[0].key)).Ok().fingerPrint).toEqual(
       (await res.Ok().get())?.fingerPrint,
     );
-    expect((await toKeyWithFingerPrint(kb, Object.values(diskBag2.keys)[0].key)).Ok().fingerPrint).toEqual(
+    expect((await rt.toKeyWithFingerPrint(kb, Object.values(diskBag2.keys)[0].key)).Ok().fingerPrint).toEqual(
       (await created.Ok().get())?.fingerPrint,
     );
     const algo = {
@@ -129,7 +128,7 @@ describe("KeyBag", () => {
     expect(await kb.rt.crypto.encrypt(algo, (await res.Ok().get())!.key, data))
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       .toEqual(await kb.rt.crypto.encrypt(algo, (await created.Ok().get())!.key, data));
-    const kf = (await created.Ok().get()) as KeyWithFingerPrint;
+    const kf = (await created.Ok().get()) as bs.KeyWithFingerPrint;
     expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag.keys)[0].key), data)).toEqual(
       await kb.rt.crypto.encrypt(algo, kf.key, data),
     );
@@ -150,11 +149,11 @@ describe("KeyBag", () => {
     }
     expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asKeysItem())).keys).length).toBe(1);
 
-    const myKey = (await rMyKey.Ok().get()) as KeyWithFingerPrint;
+    const myKey = (await rMyKey.Ok().get()) as bs.KeyWithFingerPrint;
     expect(myKey.fingerPrint).toMatch(/^z/);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     await rMyKey.Ok().upsert((await myKey.extract())!.key);
-    const myKey1 = (await rMyKey.Ok().get()) as KeyWithFingerPrint;
+    const myKey1 = (await rMyKey.Ok().get()) as bs.KeyWithFingerPrint;
     expect(myKey.fingerPrint).toEqual(myKey1.fingerPrint);
 
     expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asKeysItem())).keys).length).toBe(1);
@@ -164,13 +163,13 @@ describe("KeyBag", () => {
     const res1 = await rMyKey1.Ok().upsert(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     expect(res1.isOk()).toBeTruthy();
 
-    const myKey2 = (await rMyKey1.Ok().get()) as KeyWithFingerPrint;
+    const myKey2 = (await rMyKey1.Ok().get()) as bs.KeyWithFingerPrint;
     expect(myKey.fingerPrint).toEqual(myKey2.fingerPrint);
     expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asKeysItem())).keys).length).toBe(2);
 
     const res = await rMyKey1.Ok().upsert(kb.rt.crypto.randomBytes(kb.rt.keyLength), true);
     expect(res.isOk()).toBeTruthy();
-    const myKey3 = (await rMyKey.Ok().get()) as KeyWithFingerPrint;
+    const myKey3 = (await rMyKey.Ok().get()) as bs.KeyWithFingerPrint;
     expect(Object.keys((await kb.getNamedKey(name).then((i) => i.Ok().asKeysItem())).keys).length).toBe(3);
 
     expect(myKey.fingerPrint).not.toEqual(myKey3.fingerPrint);
@@ -185,7 +184,7 @@ describe("KeyBag", () => {
     });
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     const name = "default-key" + Math.random();
-    const fpr = (await toKeyWithFingerPrint(kb, key)).Ok().fingerPrint;
+    const fpr = (await rt.toKeyWithFingerPrint(kb, key)).Ok().fingerPrint;
     const rMyKey = await kb.getNamedKey(name, false, key);
     expect(rMyKey.isOk()).toBeTruthy();
     const myKey = rMyKey.Ok();
@@ -199,7 +198,7 @@ describe("KeyBag", () => {
     const keys = [{ key, fpr }];
     for (let i = 0; i < 10; ++i) {
       const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-      const fpr = (await toKeyWithFingerPrint(kb, key)).Ok().fingerPrint;
+      const fpr = (await rt.toKeyWithFingerPrint(kb, key)).Ok().fingerPrint;
       keys.push({ key, fpr });
       const rUpsert = await myKey.upsert(key, true);
       expect(rUpsert.Ok().modified).toBeTruthy();
@@ -278,7 +277,9 @@ describe("KeyedCryptoStore", () => {
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("cryptoAction");
       // expect(kc.isEncrypting).toBe(true);
-      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@test:${store.url().getParam(PARAM.STORE)}@`);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(
+        `@test-${storeType2DataMetaWal(store.url().getParam(PARAM.STORE) as StoreType)}@`,
+      );
     }
   });
 
@@ -297,7 +298,7 @@ describe("KeyedCryptoStore", () => {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const blk = await kc._encrypt({ bytes: testData, key: (await kc.key.get())!.key, iv });
       expect(blk).not.toEqual(testData);
-      const fpkey = (await genKey.Ok().get()) as KeyWithFingerPrint;
+      const fpkey = (await genKey.Ok().get()) as bs.KeyWithFingerPrint;
       expect(fpkey.fingerPrint).toEqual(fpkey.fingerPrint);
       const dec = new Uint8Array(await kc.crypto.decrypt(kc.algo(iv), fpkey.key, blk));
       expect(dec).toEqual(testData);
@@ -316,7 +317,7 @@ describe("KeyedCryptoStore", () => {
       expect(kc.constructor.name).toBe("cryptoAction");
       const testData = kb.rt.crypto.randomBytes(1024);
       const iv = kb.rt.crypto.randomBytes(12);
-      const ks = (await kc.key.get()) as KeyWithFingerPrint;
+      const ks = (await kc.key.get()) as bs.KeyWithFingerPrint;
       const blk = await kc._encrypt({ bytes: testData, key: ks.key, iv });
       expect(blk).not.toEqual(testData);
       const dec = await kc._decrypt({ bytes: blk, key: ks.key, iv });
@@ -348,12 +349,12 @@ describe("KeyedCrypto", () => {
     const iv = kb.rt.crypto.randomBytes(12);
     const codec = kycr.codec(iv, { noIVVerify: true });
     const blk = (await codec.encode(testData)) as Uint8Array;
-    const myDec = await rt.mf.block.decode<bs.IvKeyIdData, number, number>({ bytes: blk, hasher, codec: dagCodec });
-    expect(myDec.value.iv).toEqual(iv);
-    const kc = (await kycr.key.get()) as KeyWithFingerPrint;
-    expect(base58btc.encode(myDec.value.keyId)).toEqual(kc.fingerPrint);
+    const myDec = cborg.decode(blk) as bs.IvKeyIdData;
+    expect(myDec.iv).toEqual(iv);
+    const kc = (await kycr.key.get()) as bs.KeyWithFingerPrint;
+    expect(base58btc.encode(myDec.keyId)).toEqual(kc.fingerPrint);
     const dec = await codec.decode(blk);
-    expect(dec).toEqual(testData);
+    expect(dec.data).toEqual(testData);
   });
 
   it("codec implict iv", async () => {
@@ -362,7 +363,7 @@ describe("KeyedCrypto", () => {
     const blk = await codec.encode(testData);
     expect(blk.length).toBeGreaterThanOrEqual(12 + testData.length);
     const dec = await codec.decode(blk);
-    expect(dec).toEqual(testData);
+    expect(dec.data).toEqual(testData);
   });
 
   it("codec implict iv same for multiple clients", async () => {

package/tests/blockstore/loader.test.ts

@@ -154,8 +154,8 @@ describe("basic Loader with two commits", function () {
 
   it("should have a car log", function () {
     expect(loader.carLog.length).toBe(2);
-    expect(loader.carLog[0].toString()).toBe(carCid.toString());
-    expect(loader.carLog[1].toString()).toBe(carCid0.toString());
+    expect(loader.carLog.asArray()[0].toString()).toBe(carCid.toString());
+    expect(loader.carLog.asArray()[1].toString()).toBe(carCid0.toString());
   });
 
   it("should commit", async () => {

package/tests/blockstore/store.test.ts

@@ -1,7 +1,6 @@
 import { CID } from "multiformats";
 import { rt, bs, NotFoundError, PARAM, ensureSuperThis } from "@fireproof/core";
 import { Result } from "@adviser/cement";
-import { createAttachedStores } from "../../src/blockstore/attachable-store.js";
 import { mockLoader, noopUrl } from "../helpers.js";
 
 // function runtime(sthis: SuperThis) {
@@ -17,8 +16,8 @@ import { mockLoader, noopUrl } from "../helpers.js";
 //   };
 // }
 
-describe("DataStore", function () {
-  let store: bs.DataStore;
+describe("CarStore", function () {
+  let store: bs.CarStore;
   const sthis = ensureSuperThis();
   const loader = mockLoader(sthis);
 
@@ -29,7 +28,7 @@ describe("DataStore", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    const at = await createAttachedStores(noopUrl("test"), loader);
+    const at = await bs.createAttachedStores(noopUrl("test"), loader);
     store = at.stores.car;
     await store.start(at.stores);
   });
@@ -49,8 +48,8 @@ describe("DataStore", function () {
   });
 });
 
-describe("DataStore with a saved car", function () {
-  let store: bs.DataStore;
+describe("CarStore with a saved car", function () {
+  let store: bs.CarStore;
   let car: bs.AnyBlock;
 
   const sthis = ensureSuperThis();
@@ -64,7 +63,7 @@ describe("DataStore with a saved car", function () {
   beforeEach(async () => {
     await sthis.start();
 
-    const at = await createAttachedStores(noopUrl("test2"), loader);
+    const at = await bs.createAttachedStores(noopUrl("test2"), loader);
     store = at.stores.car;
     await store.start(at.stores);
     car = {
@@ -105,7 +104,7 @@ describe("MetaStore", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    const at = await createAttachedStores(noopUrl("test"), loader);
+    const at = await bs.createAttachedStores(noopUrl("test"), loader);
     store = at.stores.meta;
     await store.start(at.stores);
   });
@@ -145,7 +144,7 @@ describe("MetaStore with a saved header", function () {
 
   beforeEach(async () => {
     await sthis.start();
-    const at = await createAttachedStores(noopUrl("test3-meta"), loader);
+    const at = await bs.createAttachedStores(noopUrl("test3-meta"), loader);
     store = at.stores.meta;
     await store.start(at.stores);
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");

package/tests/fireproof/all-gateway.test.ts

@@ -32,9 +32,9 @@ import { Future } from "@adviser/cement";
 
 describe("noop Gateway", function () {
   let db: Ledger;
-  let carStore: bs.DataStore;
+  let carStore: bs.CarStore;
   let metaStore: bs.MetaStore;
-  let fileStore: bs.DataStore;
+  let fileStore: bs.FileStore;
   let walStore: bs.WALStore;
   let carGateway: bs.SerdeGateway;
   let metaGateway: bs.SerdeGateway;
@@ -90,10 +90,10 @@ describe("noop Gateway", function () {
 
   it("should have correct store types in URLs", async () => {
     // Check that all stores have the correct store type in their URL
-    expect(carStore.url().toString()).toContain("store=data");
+    expect(carStore.url().toString()).toContain("store=car");
     expect(carStore.url().toString()).toContain("suffix=.car");
     expect(metaStore.url().toString()).toContain("store=meta");
-    expect(fileStore.url().toString()).toContain("store=data");
+    expect(fileStore.url().toString()).toContain("store=file");
     expect(walStore.url().toString()).toContain("store=wal");
   });
 

package/tests/fireproof/attachable.test.ts

@@ -1,6 +1,207 @@
-import { Attachable, Database, fireproof, GatewayUrlsParam } from "@fireproof/core";
+import { URI } from "@adviser/cement";
+import { stripper } from "@adviser/cement/utils";
+import { Attachable, Database, ensureSuperThis, fireproof, GatewayUrlsParam, PARAM, rt, Attached, bs } from "@fireproof/core";
+import { CarReader } from "@ipld/car/reader";
+import * as dagCbor from "@ipld/dag-cbor";
+import { sleep } from "../helpers.js";
+import { mockLoader } from "../helpers.js";
+
+describe("meta check", () => {
+  const sthis = ensureSuperThis();
+  it("empty Database", async () => {
+    const name = `remote-db-${sthis.nextId().str}`;
+    const db = fireproof(name, {
+      storeUrls: {
+        base: `memory://${name}`,
+      },
+    });
+    await db.ready();
+    const gws = db.ledger.crdt.blockstore.loader.attachedStores.local();
+    await db.close();
+    expect(
+      Array.from(((gws.active.car.realGateway as rt.gw.DefSerdeGateway).gw as rt.gw.memory.MemoryGateway).memorys.entries()).filter(
+        ([k]) => k.startsWith(`memory://${name}`),
+      ),
+    ).toEqual([]);
+  });
+
+  it("one record Database", async () => {
+    const name = `remote-db-${sthis.nextId().str}`;
+    const db = fireproof(name, {
+      storeUrls: {
+        base: `memory://${name}`,
+      },
+    });
+    await db.put({ _id: `id-${0}`, value: `value-${0}` });
+    await db.close();
+
+    const db1 = fireproof(name, {
+      storeUrls: {
+        base: `memory://${name}`,
+      },
+    });
+    await db1.close();
+  });
+
+  it("multiple record Database", async () => {
+    const name = `remote-db-${sthis.nextId().str}`;
+    const base = `memory://${name}?storekey=insecure`;
+    const db = fireproof(name, {
+      storeUrls: {
+        base,
+      },
+    });
+    await db.ready();
+    await db.put({ _id: `id-${0}`, value: `value-${0}` });
+    const gws = db.ledger.crdt.blockstore.loader.attachedStores.local();
+    expect(db.ledger.crdt.blockstore.loader.carLog.asArray().map((i) => i.map((i) => i.toString()))).toEqual([
+      ["baembeieldbalgnyxqp7rmj4cbrot75gweavqy3aw22km43zsfufrihfn7e"],
+      ["baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu"],
+    ]);
+    await db.close();
+    expect(
+      Array.from(((gws.active.car.realGateway as rt.gw.DefSerdeGateway).gw as rt.gw.memory.MemoryGateway).memorys.entries())
+        .filter(([k]) => k.startsWith(`memory://${name}`))
+        .map(([k]) =>
+          stripper(
+            ["name", "storekey", "version"],
+            Array.from(URI.from(k).getParams).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {}),
+          ),
+        ),
+    ).toEqual([
+      {
+        key: "baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu",
+        store: "car",
+        suffix: ".car",
+      },
+      {
+        key: "main",
+        store: "wal",
+      },
+      {
+        key: "main",
+        store: "meta",
+      },
+      {
+        key: "baembeieldbalgnyxqp7rmj4cbrot75gweavqy3aw22km43zsfufrihfn7e",
+        store: "car",
+        suffix: ".car",
+      },
+    ]);
+
+    const db1 = fireproof(name, {
+      storeUrls: {
+        base,
+      },
+    });
+    expect(db1.ledger).not.equal(db.ledger);
+    await db1.ready();
+    expect(db1.ledger.crdt.blockstore.loader.carLog.asArray().map((i) => i.map((i) => i.toString()))).toEqual([
+      ["baembeieldbalgnyxqp7rmj4cbrot75gweavqy3aw22km43zsfufrihfn7e"],
+      ["baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu"],
+    ]);
+
+    const gensis = await db1.get(PARAM.GENESIS_CID);
+    expect(gensis).toEqual({ _id: PARAM.GENESIS_CID });
+
+    const val = await db1.allDocs();
+    expect(val.rows).toEqual([
+      {
+        key: "id-0",
+        value: {
+          _id: "id-0",
+          value: "value-0",
+        },
+      },
+    ]);
+    const car = Array.from(
+      ((gws.active.car.realGateway as rt.gw.DefSerdeGateway).gw as rt.gw.memory.MemoryGateway).memorys.entries(),
+    )
+      .filter(([k]) => k.startsWith(`memory://${name}`))
+      .map(([k, v]) => [URI.from(k).getParam(PARAM.KEY), v])
+      .find(([k]) => k === "baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu") as [string, Uint8Array];
+    const rawReader = await CarReader.fromBytes(car[1]);
+    const blocks = [];
+    for await (const block of rawReader.blocks()) {
+      blocks.push(block);
+    }
+    expect(dagCbor.decode(blocks[1].bytes)).toEqual({
+      doc: {
+        _id: "baembeiarootfireproofgenesisblockaaaafireproofgenesisblocka",
+      },
+    });
+
+    expect(blocks.map((i) => i.cid.toString())).toEqual([
+      "bafyreibxibqhi6wh5klrje7ne4htffeqyyqfd6y7x2no6wnhid4nixizau",
+      "bafyreidnvv4mwvweup5w52ddre2sl4syhvczm6ejqsmuekajowdl2cf2q4",
+      "bafyreihh6nbfbhgkf5lz7hhsscjgiquw426rxzr3fprbgonekzmyvirrhe",
+      "bafyreiejg3twlaxr7gfvvhtxrhvwaydytdv4guidmtvaz5dskm6gp73ryi",
+      "bafyreiblui55o25dopc5faol3umsnuohb5carto7tot4kicnkfc37he4h4",
+    ]);
+  });
+});
+
+describe("activate store", () => {
+  // activate(store: DataAndMetaStore | CoerceURI): ActiveStore {
+  //   if (isCoerceURI(store)) {
+  //     throw this.loadable.sthis.logger.Error().Msg("store must be an object").AsError();
+  //   }
+  //   return new ActiveStoreImpl(store as DataAndMetaStore, this);
+  // }
+
+  const sthis = ensureSuperThis();
+  let attach: bs.AttachedStores;
+  let firstAttached: Attached;
+  let secondAttached: Attached;
+  beforeEach(async () => {
+    attach = new bs.AttachedRemotesImpl(mockLoader(sthis));
+    firstAttached = await attach.attach({
+      name: "first",
+      prepare: async () => ({
+        car: { url: "memory://first?store=car" },
+        meta: { url: "memory://first?store=meta" },
+        file: { url: "memory://first" },
+        wal: { url: "memory://first?store=wal" },
+      }),
+    });
+
+    secondAttached = await attach.attach({
+      name: "second",
+      prepare: async () => ({
+        car: { url: "memory://second?store=car" },
+        meta: { url: "memory://second?store=meta" },
+        file: { url: "memory://second?store=file" },
+      }),
+    });
+  });
+
+  it("activate by store", async () => {
+    expect(attach.activate(secondAttached.stores).active.car.url().toString()).toBe(
+      "memory://second?name=second&store=car&storekey=%40second-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate(firstAttached.stores).local().active.car.url().toString()).toBe(
+      "memory://first?name=first&store=car&storekey=%40first-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate(firstAttached.stores).active.meta.url().toString()).toBe(
+      "memory://first?name=first&store=meta&storekey=%40first-meta%40&version=v0.19-memory",
+    );
+  });
+
+  it("activate by store", async () => {
+    expect(attach.activate("memory://second").active.car.url().toString()).toBe(
+      "memory://second?name=second&store=car&storekey=%40second-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate("memory://second").remotes()[0].active.car.url().toString()).toEqual(
+      "memory://second?name=second&store=car&storekey=%40second-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate("memory://first?store=meta").active.car.url().toString()).toBe(
+      "memory://first?name=first&store=car&storekey=%40first-data%40&suffix=.car&version=v0.19-memory",
+    );
+  });
+});
 
 describe("join function", () => {
+  const sthis = ensureSuperThis();
   // export const connect: ConnectFunction = (
   //     db: Database,
   //     remoteDbName = "",
@@ -29,9 +230,9 @@ describe("join function", () => {
     }
     prepare(): Promise<GatewayUrlsParam> {
       return Promise.resolve({
-        car: { url: "memory://${this.name}" },
-        meta: { url: "memory://${this.name}" },
-        file: { url: "memory://${this.name}" },
+        car: { url: `memory://car/${this.name}` },
+        meta: { url: `memory://meta/${this.name}` },
+        file: { url: `memory://file/${this.name}` },
       });
     }
   }
@@ -40,43 +241,116 @@ describe("join function", () => {
   }
 
   let db: Database;
+  let joinableDBs: string[] = [];
   beforeAll(async () => {
-    const set = Math.random().toString(16);
-    await Promise.all(
-      Array.from({ length: 10 }).map(async (_, i) => {
-        const db = fireproof(`remote-db-${i}-${set}`, {
+    const set = sthis.nextId().str;
+    joinableDBs = await Promise.all(
+      new Array(10).fill(1).map(async (_, i) => {
+        const name = `remote-db-${i}-${set}`;
+        const db = fireproof(name, {
           storeUrls: {
-            base: `memory://remote-db-${i}-${set}`,
+            // base: `memory://${name}`,
+            data: {
+              car: `memory://car/${name}`,
+              meta: `memory://meta/${name}`,
+              file: `memory://file/${name}`,
+              wal: `memory://wal/${name}`,
+            },
           },
         });
+        // await db.put({ _id: `genesis`, value: `genesis` });
+        // await db.ready();
         for (let j = 0; j < 10; j++) {
-          await db.put({ _id: `${i}-${j}`, value: `${i}-${set}` });
+          await db.put({ _id: `${i}-${j}`, value: `${i}-${j}` });
         }
+        expect(await db.get(PARAM.GENESIS_CID)).toEqual({ _id: PARAM.GENESIS_CID });
         await db.close();
-        return db;
+        return name;
       }),
     );
+    // await new Promise((resolve) => setTimeout(resolve, 1000));
 
     db = fireproof(`db-${set}`, {
       storeUrls: {
         base: `memory://db-${set}`,
       },
     });
+    // await db.put({ _id: `genesis`, value: `genesis` });
+    for (let j = 0; j < 10; j++) {
+      await db.put({ _id: `db-${j}`, value: `db-${set}` });
+    }
+    expect(await db.get(PARAM.GENESIS_CID)).toEqual({ _id: PARAM.GENESIS_CID });
   });
   afterAll(async () => {
     await db.close();
   });
 
-  it("it is joinable", async () => {
-    for (let i = 0; i < 10; i++) {
-      // create  meta/car/files store from aJoinable
-      // retrieve meta from attachable and subscribe to it
-      // merge incoming meta with local
-      // the attach meta includes source url's which ref back to aJoinable Attachable
+  it("it is joinable detachable", async () => {
+    const my = fireproof("my", {
+      storeUrls: {
+        base: "memory://my",
+      },
+    });
+    await my.put({ _id: "genesis", value: "genesis" });
+    await Promise.all(
+      joinableDBs.map(async (name) => {
+        const tmp = fireproof(name, {
+          storeUrls: {
+            data: {
+              car: `memory://car/${name}`,
+              meta: `memory://meta/${name}`,
+              file: `memory://file/${name}`,
+              wal: `memory://wal/${name}`,
+            },
+          },
+        });
+        const res = await tmp.allDocs();
+        expect(res.rows.length).toBe(10);
+        await tmp.close();
+        const attached = await my.attach(aJoinable(name));
+        expect(attached).toBeDefined();
+      }),
+    );
+    expect(my.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(joinableDBs.length);
+    await my.close();
+    expect(my.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(0);
+  });
+
+  it("it is inbound syncing", async () => {
+    await Promise.all(
+      joinableDBs.map(async (name) => {
+        const attached = await db.attach(aJoinable(name));
+        expect(attached).toBeDefined();
+      }),
+    );
+    await sleep(100);
+    expect(db.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(joinableDBs.length);
+    const res = await db.allDocs();
+    expect(res.rows.length).toBe(10 + 10 * joinableDBs.length);
+  });
 
-      const attached = await db.attach(aJoinable("i" + i));
-      expect(attached).toBeDefined();
-      await attached.detach();
-    }
+  it("it empty inbound syncing", async () => {
+    const name = `empty-db-${sthis.nextId().str}`;
+    const db = fireproof(name, {
+      storeUrls: {
+        // base: `memory://${name}`,
+        data: {
+          car: `memory://car/${name}`,
+          meta: `memory://meta/${name}`,
+          file: `memory://file/${name}`,
+          wal: `memory://wal/${name}`,
+        },
+      },
+    });
+    await Promise.all(
+      joinableDBs.map(async (name) => {
+        const attached = await db.attach(aJoinable(name));
+        expect(attached).toBeDefined();
+      }),
+    );
+    await sleep(100);
+    expect(db.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(joinableDBs.length);
+    const res = await db.allDocs();
+    expect(res.rows.length).toBe(10 * joinableDBs.length);
   });
 });