@fireproof/core 0.19.99 → 0.19.101

package/{node-filesystem-INX4ZTHE.js → node-filesystem-CFRXFSO7.js}

@@ -1,13 +1,13 @@
 import {
   toArrayBuffer
-} from "./chunk-WS3YRPIA.js";
-import "./chunk-OFGPKRCM.js";
+} from "./chunk-HQ7D3PEU.js";
+import "./chunk-3EB3ENHT.js";
+import "./chunk-PZ5AY32C.js";
 
 // src/runtime/gateways/file/node-filesystem.ts
-import { runtimeFn } from "@adviser/cement";
 var NodeFileSystem = class {
   async start() {
-    this.fs = await import("node:fs/promises");
+    this.fs = await import("fs/promises");
     return this;
   }
   async mkdir(path, options) {
@@ -27,19 +27,16 @@ var NodeFileSystem = class {
     return toArrayBuffer(ret);
   }
   stat(path) {
-    return this.fs?.stat(path);
+    return this.fs.stat(path);
   }
   async unlink(path) {
     return this.fs?.unlink(path);
   }
   async writefile(path, data) {
-    if (runtimeFn().isDeno) {
-      return this.fs?.writeFile(path, data);
-    }
     return this.fs?.writeFile(path, Buffer.from(data));
   }
 };
 export {
   NodeFileSystem
 };
-//# sourceMappingURL=node-filesystem-INX4ZTHE.js.map
+//# sourceMappingURL=node-filesystem-CFRXFSO7.js.map

package/node-filesystem-CFRXFSO7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/gateways/file/node-filesystem.ts"],"sourcesContent":["import type { PathLike, MakeDirectoryOptions, ObjectEncodingOptions } from \"fs\";\nimport type { mkdir, readdir, rm, copyFile, readFile, stat, unlink, writeFile } from \"fs/promises\";\nimport { toArrayBuffer } from \"./utils.js\";\nimport { FPStats, SysFileSystem } from \"../../../types.js\";\n\nexport class NodeFileSystem implements SysFileSystem {\n  fs?: {\n    mkdir: typeof mkdir;\n    readdir: typeof readdir;\n    rm: typeof rm;\n    copyFile: typeof copyFile;\n    readFile: typeof readFile;\n    stat: typeof stat;\n    unlink: typeof unlink;\n    writeFile: typeof writeFile;\n  };\n\n  async start(): Promise<SysFileSystem> {\n    this.fs = await import(\"fs/promises\");\n    return this;\n  }\n  async mkdir(path: PathLike, options?: { recursive: boolean }): Promise<string | undefined> {\n    return this.fs?.mkdir(path, options);\n  }\n  async readdir(path: PathLike, options?: ObjectEncodingOptions): Promise<string[]> {\n    return this.fs?.readdir(path, options) as Promise<string[]>;\n  }\n  async rm(path: PathLike, options?: MakeDirectoryOptions & { recursive: boolean }): Promise<void> {\n    return this.fs?.rm(path, options);\n  }\n  async copyFile(source: PathLike, destination: PathLike): Promise<void> {\n    return this.fs?.copyFile(source, destination);\n  }\n  async readfile(path: PathLike, options?: { encoding: BufferEncoding; flag?: string }): Promise<Uint8Array> {\n    const ret = (await this.fs?.readFile(path, options)) as Buffer;\n    return toArrayBuffer(ret);\n  }\n  stat(path: PathLike): Promise<FPStats> {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this.fs!.stat(path);\n  }\n  async unlink(path: PathLike): Promise<void> {\n    return this.fs?.unlink(path);\n  }\n  async writefile(path: PathLike, data: Uint8Array | string): Promise<void> {\n    return this.fs?.writeFile(path, Buffer.from(data));\n  }\n}\n"],"mappings":";;;;;;;AAKO,IAAM,iBAAN,MAA8C;AAAA,EAYnD,MAAM,QAAgC;AACpC,SAAK,KAAK,MAAM,OAAO,aAAa;AACpC,WAAO;AAAA,EACT;AAAA,EACA,MAAM,MAAM,MAAgB,SAA+D;AACzF,WAAO,KAAK,IAAI,MAAM,MAAM,OAAO;AAAA,EACrC;AAAA,EACA,MAAM,QAAQ,MAAgB,SAAoD;AAChF,WAAO,KAAK,IAAI,QAAQ,MAAM,OAAO;AAAA,EACvC;AAAA,EACA,MAAM,GAAG,MAAgB,SAAwE;AAC/F,WAAO,KAAK,IAAI,GAAG,MAAM,OAAO;AAAA,EAClC;AAAA,EACA,MAAM,SAAS,QAAkB,aAAsC;AACrE,WAAO,KAAK,IAAI,SAAS,QAAQ,WAAW;AAAA,EAC9C;AAAA,EACA,MAAM,SAAS,MAAgB,SAA4E;AACzG,UAAM,MAAO,MAAM,KAAK,IAAI,SAAS,MAAM,OAAO;AAClD,WAAO,cAAc,GAAG;AAAA,EAC1B;AAAA,EACA,KAAK,MAAkC;AAErC,WAAO,KAAK,GAAI,KAAK,IAAI;AAAA,EAC3B;AAAA,EACA,MAAM,OAAO,MAA+B;AAC1C,WAAO,KAAK,IAAI,OAAO,IAAI;AAAA,EAC7B;AAAA,EACA,MAAM,UAAU,MAAgB,MAA0C;AACxE,WAAO,KAAK,IAAI,UAAU,MAAM,OAAO,KAAK,IAAI,CAAC;AAAA,EACnD;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.19.99",
+  "version": "0.19.101",
   "description": "Live database for the web.",
   "type": "module",
   "module": "./index.js",
@@ -60,7 +60,9 @@
     "ipfs-unixfs-exporter": "^13.6.1",
     "memfs": "^4.12.0",
     "p-limit": "^6.1.0",
-    "react": "^18.3.1"
+    "react": "^18.3.1",
+    "p-map": "^7.0.2",
+    "p-retry": "^6.2.0"
   },
   "scripts": {}
 }

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

@@ -0,0 +1,129 @@
+import { bs, PARAM, rt } from "@fireproof/core";
+import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
+import { base58btc } from "multiformats/bases/base58";
+import { mockSuperThis } from "../helpers";
+
+describe("KeyBag indexdb and file", () => {
+  let url: URI;
+  const sthis = mockSuperThis();
+  beforeAll(async () => {
+    await sthis.start();
+    if (runtimeFn().isBrowser) {
+      url = URI.from("indexdb://fp-keybag");
+    } else {
+      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+    }
+  });
+  it("default-path", async () => {
+    const old = sthis.env.get("FP_KEYBAG_URL");
+    sthis.env.delete("FP_KEYBAG_URL");
+    const kb = await rt.kb.getKeyBag(sthis);
+    if (runtimeFn().isBrowser) {
+      expect(kb.rt.url.toString()).toBe(`indexdb://fp-keybag`);
+    } else {
+      expect(kb.rt.url.toString()).toBe(`file://${sthis.env.get("HOME")}/.fireproof/keybag`);
+    }
+    sthis.env.set("FP_KEYBAG_URL", old);
+  });
+  it("from env", async () => {
+    const old = sthis.env.get("FP_KEYBAG_URL");
+    sthis.env.set("FP_KEYBAG_URL", url.toString());
+    const kb = await rt.kb.getKeyBag(sthis);
+    expect(kb.rt.url.toString()).toBe(url.toString());
+    sthis.env.set("FP_KEYBAG_URL", old);
+  });
+  it("simple add", async () => {
+    const kb = await rt.kb.getKeyBag(sthis, {
+      url: url.toString(),
+      crypto: toCryptoRuntime({
+        randomBytes: (size) => new Uint8Array(size).map((_, i) => i),
+      }),
+    });
+    const name = "setkey" + Math.random();
+    expect((await kb.getNamedKey(name, true)).isErr()).toBeTruthy();
+
+    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
+    const res = await kb.setNamedKey(name, key);
+    expect(res.isOk()).toBeTruthy();
+    expect((await kb.getNamedKey(name, true)).Ok()).toEqual(res.Ok());
+
+    const name2 = "implicit";
+    const created = await kb.getNamedKey(name2);
+    expect(created.isOk()).toBeTruthy();
+
+    expect((await kb.getNamedKey(name2)).Ok()).toEqual(created.Ok());
+
+    let diskBag: rt.kb.KeyItem;
+    let diskBag2: rt.kb.KeyItem;
+    const provider = await kb.rt.getBag();
+    if (runtimeFn().isBrowser) {
+      const p = provider as rt.kb.KeyBagProviderIndexDB;
+      diskBag = await p._prepare().then((db) => db.get("bag", name));
+      diskBag2 = await p._prepare().then((db) => db.get("bag", name2));
+    } else {
+      const p = provider as rt.kb.KeyBagProviderFile;
+      const { sysFS } = await p._prepare(name);
+
+      diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
+        return JSON.parse(new TextDecoder().decode(data)) as rt.kb.KeyItem;
+      });
+      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
+        return JSON.parse(new TextDecoder().decode(data)) as rt.kb.KeyItem;
+      });
+    }
+    expect(await kb.toKeyWithFingerPrint(diskBag.key)).toEqual(res);
+    expect(await kb.toKeyWithFingerPrint(diskBag2.key)).toEqual(created);
+    const algo = {
+      name: "AES-GCM",
+      iv: kb.rt.crypto.randomBytes(12),
+      tagLength: 128,
+    };
+    const data = kb.rt.crypto.randomBytes(122);
+    expect(await kb.rt.crypto.encrypt(algo, res.Ok().key, data)).toEqual(await kb.rt.crypto.encrypt(algo, created.Ok().key, data));
+    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(diskBag.key), data)).toEqual(
+      await kb.rt.crypto.encrypt(algo, created.Ok().key, data),
+    );
+    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(diskBag2.key), data)).toEqual(
+      await kb.rt.crypto.encrypt(algo, created.Ok().key, data),
+    );
+  });
+});
+
+describe("KeyedCryptoStore", () => {
+  let kb: rt.kb.KeyBag;
+  // let logger: Logger;
+  let baseUrl: URI;
+  const sthis = mockSuperThis();
+  beforeEach(async () => {
+    await sthis.start();
+    // logger = MockLogger().logger;
+    let kbUrl: URI;
+    if (runtimeFn().isBrowser) {
+      kbUrl = URI.from("indexdb://fp-keybag");
+      baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
+    } else {
+      kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+      baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
+    }
+    baseUrl = baseUrl.build().defParam(PARAM.NAME, "test").URI();
+    kb = await rt.kb.getKeyBag(sthis, {
+      url: kbUrl,
+    });
+  });
+  it("no crypto", async () => {
+    const strt = bs.toStoreRuntime(sthis);
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
+
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, keybag: kb }),
+      strt.makeMetaStore({ sthis, url, keybag: kb }),
+      strt.makeWALStore({ sthis, url, keybag: kb }),
+    ]) {
+      const store = await pstore;
+      // await store.start();
+      const kc = await store.keyedCrypto();
+      expect(kc.constructor.name).toBe("noCrypto");
+      // expect(kc.isEncrypting).toBe(false);
+    }
+  });
+});

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

@@ -1,219 +1,86 @@
-import { bs, rt } from "@fireproof/core";
-import { BuildURI, Logger, MockLogger, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
+import { bs, PARAM, rt } from "@fireproof/core";
+import { 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 { MockSuperThis, mockSuperThis } from "../helpers";
-
-describe("KeyBag", () => {
-  let url: URI;
-  let sthis: MockSuperThis;
-
-  beforeEach(async () => {
-    sthis = mockSuperThis();
-    await sthis.start();
-    if (runtimeFn().isBrowser) {
-      url = URI.from("indexdb://fp-keybag");
-    } else {
-      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    }
-  });
-  it("default-path", async () => {
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.delete("FP_KEYBAG_URL");
-    const kb = await rt.kb.getKeyBag(sthis);
-    if (runtimeFn().isBrowser) {
-      expect(kb.rt.url.toString()).toBe(`indexdb://fp-keybag`);
-    } else {
-      expect(kb.rt.url.toString()).toBe(`file://${sthis.env.get("HOME")}/.fireproof/keybag`);
-    }
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-  it("from env", async () => {
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.set("FP_KEYBAG_URL", url.toString());
-    const kb = await rt.kb.getKeyBag(sthis);
-    expect(kb.rt.url.toString()).toBe(url.toString());
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-
-  it("extract keyMaterial", async () => {
-    const dkb = await rt.kb.getKeyBag(sthis);
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.set("FP_KEYBAG_URL", BuildURI.from(dkb.rt.url).setParam("extractKey", "_deprecated_internal_api").toString());
-    const kb = await rt.kb.getKeyBag(sthis);
-    const key = kb.rt.crypto.randomBytes(kb.rt.keyLength);
-    const keyStr = base58btc.encode(key);
-    const res = await kb.setNamedKey("extract.test", keyStr);
-    expect(res.isOk()).toBeTruthy();
-    const gkb = await kb.getNamedExtractableKey("extract.test", true);
-    expect(gkb.isOk()).toBeTruthy();
-    expect(await gkb.Ok().extract()).toEqual({
-      key,
-      keyStr,
-    });
-    sthis.env.set("FP_KEYBAG_URL", old);
-    await sthis.logger.Flush();
-    expect(sthis.logCollector.Logs()).toEqual([
-      {
-        level: "warn",
-        module: "KeyBag",
-        msg: "extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!",
-      },
-    ]);
-  });
-
-  it("simple add", async () => {
-    const kb = await rt.kb.getKeyBag(sthis, {
-      url: url.toString(),
-      crypto: toCryptoRuntime({
-        randomBytes: (size) => new Uint8Array(size).map((_, i) => i),
-      }),
-    });
-    const name = "setkey" + Math.random();
-    expect((await kb.getNamedKey(name, true)).isErr()).toBeTruthy();
-
-    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const res = await kb.setNamedKey(name, key);
-    expect(res.isOk()).toBeTruthy();
-    expect((await kb.getNamedKey(name, true)).Ok()).toEqual(res.Ok());
-
-    const name2 = "implicit";
-    const created = await kb.getNamedKey(name2);
-    expect(created.isOk()).toBeTruthy();
-
-    expect((await kb.getNamedKey(name2)).Ok()).toEqual(created.Ok());
-
-    let diskBag: rt.kb.KeyItem;
-    let diskBag2: rt.kb.KeyItem;
-    const provider = await kb.rt.getBag();
-    if (runtimeFn().isBrowser) {
-      const p = provider as rt.kb.KeyBagProviderIndexDB;
-      diskBag = await p._prepare().then((db) => db.get("bag", name));
-      diskBag2 = await p._prepare().then((db) => db.get("bag", name2));
-    } else {
-      const p = provider as rt.kb.KeyBagProviderFile;
-      const { sysFS } = await p._prepare(name);
-
-      diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
-        return JSON.parse(new TextDecoder().decode(data)) as rt.kb.KeyItem;
-      });
-      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
-        return JSON.parse(new TextDecoder().decode(data)) as rt.kb.KeyItem;
-      });
-    }
-    expect(await kb.toKeyWithFingerPrint(diskBag.key)).toEqual(res);
-    expect(await kb.toKeyWithFingerPrint(diskBag2.key)).toEqual(created);
-    const algo = {
-      name: "AES-GCM",
-      iv: kb.rt.crypto.randomBytes(12),
-      tagLength: 128,
-    };
-    const data = kb.rt.crypto.randomBytes(122);
-    expect(await kb.rt.crypto.encrypt(algo, res.Ok().key, data)).toEqual(await kb.rt.crypto.encrypt(algo, created.Ok().key, data));
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(diskBag.key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, created.Ok().key, data),
-    );
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(diskBag2.key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, created.Ok().key, data),
-    );
-  });
-});
+import { mockSuperThis } from "../helpers";
 
 describe("KeyedCryptoStore", () => {
   let kb: rt.kb.KeyBag;
-  let logger: Logger;
+  // let logger: Logger;
   let baseUrl: URI;
   const sthis = mockSuperThis();
   beforeEach(async () => {
     await sthis.start();
-    logger = MockLogger().logger;
-    let kbUrl: URI;
-    if (runtimeFn().isBrowser) {
-      kbUrl = URI.from("indexdb://fp-keybag");
-      baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
+    // logger = MockLogger().logger;
+    // let kbUrl: URI;
+    // if (runtimeFn().isBrowser) {
+    //   kbUrl = URI.from("indexdb://fp-keybag");
+    //   baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
+    // } else {
+    //   kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+    //   baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
+    // }
+    // baseUrl = baseUrl.build().defParam(PARAM.NAME, "test").URI();
+
+    const envURL = sthis.env.get("FP_KEYBAG_URL");
+    if (envURL) {
+      baseUrl = bs.getDefaultURI(sthis, URI.from(envURL).protocol);
     } else {
-      kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-      // baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
-      baseUrl = URI.from(sthis.env.get("FP_STORAGE_URL"));
+      baseUrl = bs.getDefaultURI(sthis);
     }
+    baseUrl = baseUrl.build().setParam(PARAM.NAME, "test").URI();
     kb = await rt.kb.getKeyBag(sthis, {
-      url: kbUrl,
+      // url: kbUrl,
     });
   });
   it("no crypto", async () => {
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: baseUrl.build().setParam("storekey", "insecure"),
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    const strt = bs.toStoreRuntime(sthis);
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
+
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, keybag: kb }),
+      strt.makeMetaStore({ sthis, url, keybag: kb }),
+      strt.makeWALStore({ sthis, url, keybag: kb }),
+    ]) {
       const store = await pstore;
       // await store.start();
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("noCrypto");
       // expect(kc.isEncrypting).toBe(false);
+      expect(kc.constructor.name).toBe("noCrypto");
+      // expect(kc.isEncrypting).toBe(false);
     }
   });
 
   it("create key", async () => {
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: baseUrl,
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
-      const store = await bs.ensureStart(await pstore, logger);
+    const strt = bs.toStoreRuntime(sthis);
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url: baseUrl, keybag: kb }),
+      strt.makeMetaStore({ sthis, url: baseUrl, keybag: kb }),
+      strt.makeWALStore({ sthis, url: baseUrl, keybag: kb }),
+    ]) {
+      const store = await pstore; // await bs.ensureStart(await pstore, logger);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       // expect(kc.isEncrypting).toBe(true);
-      expect(store.url().getParam("storekey")).toBe(`@test:${store.url().getParam("store")}@`);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@test:${store.url().getParam(PARAM.STORE)}@`);
     }
   });
 
   it("key ref keybag", async () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     const genKey = await kb.setNamedKey("@heute@", key);
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: baseUrl.build().setParam("storekey", "@heute@").URI(),
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "@heute@").URI();
+    const strt = bs.toStoreRuntime(sthis);
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, keybag: kb }),
+      strt.makeMetaStore({ sthis, url, keybag: kb }),
+      strt.makeWALStore({ sthis, url, keybag: kb }),
+    ]) {
       const store = await pstore;
       // await store.start();
-      expect(store.url().getParam("storekey")).toBe(`@heute@`);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(`@heute@`);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       const testData = kb.rt.crypto.randomBytes(1024);
@@ -229,25 +96,17 @@ describe("KeyedCryptoStore", () => {
 
   it("key", async () => {
     const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const loader = {
-      sthis,
-      name: "test",
-      ebOpts: {
-        keyBag: {
-          keyRuntime: kb.rt,
-        },
-        store: {
-          stores: {
-            base: BuildURI.from(baseUrl).setParam("storekey", key),
-          },
-        },
-      },
-    } as unknown as bs.Loadable;
-    const strt = bs.toStoreRuntime({}, sthis);
-    for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
+    const strt = bs.toStoreRuntime(sthis);
+    const url = baseUrl.build().setParam(PARAM.STORE_KEY, key).URI();
+    for (const pstore of [
+      strt.makeDataStore({ sthis, url, keybag: kb }),
+      strt.makeMetaStore({ sthis, url, keybag: kb }),
+      strt.makeWALStore({ sthis, url, keybag: kb }),
+    ]) {
+      // for (const pstore of [strt.makeDataStore(loader), strt.makeMetaStore(loader), strt.makeWALStore(loader)]) {
       const store = await pstore;
       // await store.start();
-      expect(store.url().getParam("storekey")).toBe(key);
+      expect(store.url().getParam(PARAM.STORE_KEY)).toBe(key);
       const kc = await store.keyedCrypto();
       expect(kc.constructor.name).toBe("keyedCrypto");
       const testData = kb.rt.crypto.randomBytes(1024);
@@ -266,14 +125,14 @@ describe("KeyedCrypto", () => {
   let keyStr: string;
   const sthis = mockSuperThis();
   beforeEach(async () => {
-    let url: URI;
-    if (runtimeFn().isBrowser) {
-      url = URI.from("indexdb://fp-keybag");
-    } else {
-      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    }
+    // let url: URI;
+    // if (runtimeFn().isBrowser) {
+    //   url = URI.from("indexdb://fp-keybag");
+    // } else {
+    //   url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+    // }
     kb = await rt.kb.getKeyBag(sthis, {
-      url,
+      // url,
     });
     keyStr = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
     kycr = await rt.kc.keyedCryptoFactory(URI.from(`test://bla?storekey=${keyStr}`), kb, sthis);
@@ -307,26 +166,3 @@ describe("KeyedCrypto", () => {
     expect(blk).toEqual(blk2);
   });
 });
-
-// describe("KeyedCryptoStore RunLength", () => {
-//   const logger = MockLogger().logger;
-//   it("de/encode", () => {
-//     for (const data of [
-//       new Uint8Array(),
-//       new Uint8Array(10).fill(10),
-//       new Uint8Array(127).fill(127),
-//       new Uint8Array(128).fill(128),
-//       new Uint8Array(1024).fill(17),
-//     ]) {
-//       const res = rt.kc.encodeRunLength(data, logger);
-//       expect(res.length).toBeLessThanOrEqual(data.length + (data.length > 127 ? 4 : 1));
-//       for (let ofs = 0; ofs < 1024; ofs += 61) {
-//         const ofsRes = new Uint8Array([...new Uint8Array(ofs).fill(23), ...res]);
-//         const dec = rt.kc.decodeRunLength(ofsRes, ofs, logger);
-//         expect(dec.data).toEqual(data);
-//         expect(dec.data.length).toBe(data.length);
-//         expect(dec.next).toBe(ofs + data.length + (data.length > 127 ? 4 : 1));
-//       }
-//     }
-//   });
-// });

package/tests/blockstore/loader.test.ts

@@ -4,17 +4,18 @@ import { BlockView } from "multiformats";
 import { CID } from "multiformats/cid";
 import { MemoryBlockstore } from "@web3-storage/pail/block";
 import { CRDTMeta, IndexTransactionMeta, SuperThis, bs, rt } from "@fireproof/core";
-import { mockSuperThis } from "../helpers";
+import { mockSuperThis, simpleBlockOpts } from "../helpers";
 
 class MyMemoryBlockStore extends bs.EncryptedBlockstore {
   readonly memblock = new MemoryBlockstore();
   loader: bs.Loader;
   constructor(sthis: SuperThis) {
-    const ebOpts = {
-      name: "MyMemoryBlockStore",
-    };
+    const ebOpts = simpleBlockOpts(sthis, "MyMemoryBlockStore"); //, "MyMemoryBlockStore");
+    // const ebOpts = {
+    //   name: "MyMemoryBlockStore",
+    // } as bs.BlockstoreOpts;
     super(sthis, ebOpts);
-    this.loader = new bs.Loader("MyMemoryBlockStore", {}, sthis);
+    this.loader = new bs.Loader(sthis, ebOpts);
   }
   ready(): Promise<void> {
     return Promise.resolve();
@@ -63,7 +64,10 @@ describe("basic Loader simple", function () {
     await sthis.start();
     const mockM = new MyMemoryBlockStore(sthis);
     t = new bs.CarTransaction(mockM as bs.EncryptedBlockstore);
-    loader = new bs.Loader(testDbName, { public: true }, sthis);
+    loader = new bs.Loader(sthis, {
+      ...simpleBlockOpts(sthis, testDbName),
+      public: true,
+    });
     await loader.ready();
     block = await rt.mf.block.encode({
       value: { hello: "world" },
@@ -100,17 +104,20 @@ describe("basic Loader with two commits", function () {
   let carCid0: bs.CarGroup;
 
   const sthis = mockSuperThis();
-
-  afterEach(async function () {
+  afterEach(async () => {
     await loader.close();
     await loader.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     const mockM = new MyMemoryBlockStore(sthis);
     t = new bs.CarTransaction(mockM);
-    loader = new bs.Loader("test-loader-two-commit", { public: true }, sthis);
+    loader = new bs.Loader(sthis, {
+      ...simpleBlockOpts(sthis, "test-loader-two-commit"),
+      public: true,
+    });
+
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,
@@ -211,8 +218,9 @@ describe("basic Loader with index commits", function () {
   beforeEach(async function () {
     const name = "test-loader-index" + Math.random();
     await sthis.start();
+    await sthis.start();
     // t = new CarTransaction()
-    ib = new bs.EncryptedBlockstore(sthis, { name });
+    ib = new bs.EncryptedBlockstore(sthis, simpleBlockOpts(sthis, name));
     block = await rt.mf.block.encode({
       value: { hello: "world" },
       hasher,