@fireproof/core 0.19.121-dev → 0.20.0-dev-preview-05

package/index.js

@@ -1,172 +1,466 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/ledger.ts
+import { BuildURI as BuildURI2, KeyedResolvOnce as KeyedResolvOnce4, ResolveOnce as ResolveOnce7, URI as URI12 } from "@adviser/cement";
+
+// src/utils.ts
 import {
-  FILESTORE_VERSION
-} from "./chunk-7EWIAXTM.js";
-import {
-  getFileName,
-  getFileSystem,
-  getPath
-} from "./chunk-F4FC6B2T.js";
-import {
-  NotFoundError,
+  LoggerImpl,
+  IsLogger,
   Result,
-  UInt8ArrayEqual,
-  dataDir,
-  ensureLogger,
-  ensureSuperLog,
-  ensureSuperThis,
-  exceptionWrapper,
-  getKey,
-  getName,
-  getStore,
-  isNotFoundError,
-  onSuperThis
-} from "./chunk-RXC4JGJT.js";
-import {
-  __export
-} from "./chunk-PZ5AY32C.js";
+  ResolveOnce,
+  isURL,
+  envFactory,
+  toCryptoRuntime,
+  JSONFormatter,
+  YAMLFormatter
+} from "@adviser/cement";
 
-// src/database.ts
-import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
+// src/types.ts
+function isFalsy(value) {
+  return value === false && value === null && value === void 0;
+}
+var PARAM = /* @__PURE__ */ ((PARAM2) => {
+  PARAM2["SUFFIX"] = "suffix";
+  PARAM2["URL_GEN"] = "urlGen";
+  PARAM2["STORE_KEY"] = "storekey";
+  PARAM2["STORE"] = "store";
+  PARAM2["KEY"] = "key";
+  PARAM2["INDEX"] = "index";
+  PARAM2["NAME"] = "name";
+  PARAM2["VERSION"] = "version";
+  PARAM2["RUNTIME"] = "runtime";
+  PARAM2["FRAG_SIZE"] = "fragSize";
+  PARAM2["IV_VERIFY"] = "ivVerify";
+  PARAM2["IV_HASH"] = "ivHash";
+  PARAM2["FRAG_FID"] = "fid";
+  PARAM2["FRAG_OFS"] = "ofs";
+  PARAM2["FRAG_LEN"] = "len";
+  PARAM2["FRAG_HEAD"] = "headerSize";
+  PARAM2["EXTRACTKEY"] = "extractKey";
+  return PARAM2;
+})(PARAM || {});
+function throwFalsy(value) {
+  if (isFalsy(value)) {
+    throw new Error("value is Falsy");
+  }
+  return value;
+}
+function falsyToUndef(value) {
+  if (isFalsy(value)) {
+    return void 0;
+  }
+  return value;
+}
+
+// src/utils.ts
+import { base58btc } from "multiformats/bases/base58";
+var _globalLogger = new ResolveOnce();
+function globalLogger() {
+  return _globalLogger.once(() => new LoggerImpl());
+}
+var registerFP_DEBUG = new ResolveOnce();
+var SuperThisImpl = class _SuperThisImpl {
+  constructor(opts) {
+    this.logger = opts.logger;
+    this.env = opts.env;
+    this.crypto = opts.crypto;
+    this.pathOps = opts.pathOps;
+    this.txt = opts.txt;
+    this.ctx = { ...opts.ctx };
+  }
+  nextId(bytes = 6) {
+    const bin = this.crypto.randomBytes(bytes);
+    return {
+      str: base58btc.encode(bin),
+      bin
+    };
+  }
+  timeOrderedNextId(now) {
+    now = typeof now === "number" ? now : (/* @__PURE__ */ new Date()).getTime();
+    const t = (281474976710656 + now).toString(16).replace(/^1/, "");
+    const bin = this.crypto.randomBytes(10);
+    bin[1] = bin[1] & 240 | (bin[1] | 8 && 11);
+    const hex = Array.from(bin).map((i) => i.toString(16).padStart(2, "0")).join("");
+    return {
+      str: `${t.slice(0, 8)}-${t.slice(8)}-7${hex.slice(0, 3)}-${hex.slice(3, 7)}-${hex.slice(7, 19)}`
+    };
+  }
+  start() {
+    return Promise.resolve();
+  }
+  clone(override) {
+    return new _SuperThisImpl({
+      logger: override.logger || this.logger,
+      env: envFactory(override.env) || this.env,
+      crypto: override.crypto || this.crypto,
+      pathOps: override.pathOps || this.pathOps,
+      txt: override.txt || this.txt,
+      ctx: { ...this.ctx, ...override.ctx }
+    });
+  }
+};
+function presetEnv() {
+  const penv = new Map([
+    // ["FP_DEBUG", "xxx"],
+    // ["FP_ENV", "development"],
+    ...Array.from(
+      Object.entries(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis[Symbol.for("FP_PRESET_ENV")] || {}
+      )
+    )
+    // .map(([k, v]) => [k, v as string])
+  ]);
+  return penv;
+}
+var pathOpsImpl = class {
+  join(...paths) {
+    return paths.map((i) => i.replace(/\/+$/, "")).join("/");
+  }
+  dirname(path) {
+    return path.split("/").slice(0, -1).join("/");
+  }
+  basename(path) {
+    return path.split("/").pop() || "";
+  }
+  // homedir() {
+  //     throw new Error("SysContainer:homedir is not available in seeded state");
+  //   }
+};
+var pathOps = new pathOpsImpl();
+var txtOps = /* @__PURE__ */ ((txtEncoder, txtDecoder) => ({
+  encode: (input) => txtEncoder.encode(input),
+  decode: (input) => txtDecoder.decode(coerceIntoUint8(input).Ok())
+  // eslint-disable-next-line no-restricted-globals
+}))(new TextEncoder(), new TextDecoder());
+var _onSuperThis = /* @__PURE__ */ new Map();
+function onSuperThis(fn) {
+  const key = `onSuperThis-${Math.random().toString(36).slice(2)}`;
+  _onSuperThis.set(key, fn);
+  return () => {
+    _onSuperThis.delete(key);
+  };
+}
+function ensureSuperThis(osthis) {
+  const env = envFactory({
+    symbol: osthis?.env?.symbol || "FP_ENV",
+    presetEnv: osthis?.env?.presetEnv || presetEnv()
+  });
+  const ret = new SuperThisImpl({
+    logger: osthis?.logger || globalLogger(),
+    env,
+    crypto: osthis?.crypto || toCryptoRuntime(),
+    ctx: osthis?.ctx || {},
+    pathOps,
+    txt: osthis?.txt || txtOps
+  });
+  _onSuperThis.forEach((fn) => fn(ret));
+  return ret;
+}
+function ensureSuperLog(sthis, componentName, ctx) {
+  return sthis.clone({
+    logger: ensureLogger(sthis, componentName, ctx)
+  });
+}
+function ensureLogger(sthis, componentName, ctx) {
+  let logger;
+  if (sthis && IsLogger(sthis.logger)) {
+    logger = sthis.logger;
+  } else {
+    logger = globalLogger();
+  }
+  const cLogger = logger.With().Module(componentName);
+  const debug = [];
+  let exposeStack = false;
+  if (ctx) {
+    if ("debug" in ctx) {
+      if (typeof ctx.debug === "string" && ctx.debug.length > 0) {
+        debug.push(ctx.debug);
+      } else {
+        debug.push(componentName);
+      }
+      delete ctx.debug;
+    }
+    if ("exposeStack" in ctx) {
+      exposeStack = true;
+      delete ctx.exposeStack;
+    }
+    if ("exposeStack" in ctx) {
+      exposeStack = true;
+      delete ctx.exposeStack;
+    }
+    if ("this" in ctx) {
+      cLogger.Str("this", sthis.nextId(4).str);
+      delete ctx.this;
+    }
+    for (const [key, value] of Object.entries(ctx)) {
+      switch (typeof value) {
+        case "string":
+          cLogger.Str(key, value);
+          break;
+        case "number":
+          cLogger.Uint64(key, value);
+          break;
+        default:
+          if (value instanceof Date) {
+            cLogger.Str(key, value.toISOString());
+          } else if (isURL(value)) {
+            cLogger.Str(key, value.toString());
+          } else if (typeof value === "function") {
+            cLogger.Ref(key, value);
+          } else {
+            cLogger.Any(key, value);
+          }
+          break;
+      }
+    }
+  }
+  registerFP_DEBUG.once(async () => {
+    sthis.env.onSet(
+      (key, value) => {
+        switch (key) {
+          case "FP_FORMAT": {
+            switch (value) {
+              case "jsonice":
+                logger.SetFormatter(new JSONFormatter(logger.TxtEnDe(), 2));
+                break;
+              case "yaml":
+                logger.SetFormatter(new YAMLFormatter(logger.TxtEnDe(), 2));
+                break;
+              case "json":
+              default:
+                logger.SetFormatter(new JSONFormatter(logger.TxtEnDe()));
+                break;
+            }
+            break;
+          }
+          case "FP_DEBUG":
+            logger.SetDebug(value || []);
+            break;
+          case "FP_STACK":
+            logger.SetExposeStack(!!value);
+            break;
+        }
+      },
+      "FP_FORMAT",
+      "FP_DEBUG",
+      "FP_STACK"
+    );
+  }).finally(() => {
+  });
+  if (debug.length > 0) {
+    logger.SetDebug(debug);
+  }
+  if (exposeStack) {
+    logger.SetExposeStack(true);
+  }
+  const out = cLogger.Logger();
+  if (sthis.env.get("FP_CONSTRUCTOR_DEBUG")) {
+    out.Debug().Msg("constructor");
+  }
+  return out;
+}
+function getStore(url, sthis, joiner) {
+  const store = url.getParam("store" /* STORE */);
+  switch (store) {
+    case "data":
+    case "wal":
+    case "meta":
+      break;
+    default:
+      throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
+      throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
+  }
+  let name = store;
+  if (url.hasParam("index")) {
+    name = joiner(url.getParam("index" /* INDEX */) || "idx", name);
+  }
+  return { store, name };
+}
+function getKey(url, logger) {
+  const result = url.getParam("key" /* KEY */);
+  if (!result) throw logger.Error().Str("url", url.toString()).Msg(`key not found`).AsError();
+  return result;
+}
+function getName(sthis, url) {
+  let result = url.getParam("name" /* NAME */);
+  if (!result) {
+    result = sthis.pathOps.dirname(url.pathname);
+    if (result.length === 0) {
+      throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
+    }
+  }
+  return result;
+}
+async function exceptionWrapper(fn) {
+  return fn().catch((e) => Result.Err(e));
+}
+var NotFoundError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.code = "ENOENT";
+  }
+};
+function isNotFoundError(e) {
+  if (Result.Is(e)) {
+    if (e.isOk()) return false;
+    e = e.Err();
+  }
+  if (e.code === "ENOENT") return true;
+  return false;
+}
+function UInt8ArrayEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function inplaceFilter(i, pred) {
+  const founds = [];
+  for (let j = 0; j < i.length; j++) {
+    if (!pred(i[j], j)) {
+      founds.push(j);
+    }
+  }
+  for (let j = founds.length - 1; j >= 0; j--) {
+    i.splice(founds[j], 1);
+  }
+  return i;
+}
+function toSortedArray(set) {
+  if (!set) return [];
+  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => ({ [k]: v }));
+}
+function coerceIntoUint8(raw2) {
+  if (raw2 instanceof Uint8Array) {
+    return Result.Ok(raw2);
+  }
+  if (Result.Is(raw2)) {
+    return raw2;
+  }
+  return Result.Err("Not a Uint8Array");
+}
+async function coercePromiseIntoUint8(raw2) {
+  if (raw2 instanceof Uint8Array) {
+    return Result.Ok(raw2);
+  }
+  if (Result.Is(raw2)) {
+    return raw2;
+  }
+  if (typeof raw2.then === "function") {
+    try {
+      return coercePromiseIntoUint8(await raw2);
+    } catch (e) {
+      return Result.Err(e);
+    }
+  }
+  return Result.Err("Not a Uint8Array");
+}
 
 // src/write-queue.ts
-function writeQueue(worker, payload = Infinity, unbounded = false) {
-  const queue = [];
-  let isProcessing = false;
-  async function process() {
-    if (isProcessing || queue.length === 0) return;
-    isProcessing = true;
-    const tasksToProcess = queue.splice(0, payload);
-    const updates = tasksToProcess.map((item) => item.task);
-    if (unbounded) {
+import { Future } from "@adviser/cement";
+function defaultWriteQueueOpts(opts = {}) {
+  return {
+    ...opts,
+    chunkSize: opts.chunkSize && opts.chunkSize > 0 ? opts.chunkSize : 32
+  };
+}
+var WriteQueueImpl = class {
+  constructor(sthis, worker, opts) {
+    this.queue = [];
+    this.isProcessing = false;
+    this.logger = ensureLogger(sthis, "WriteQueueImpl");
+    this.worker = worker;
+    this.opts = defaultWriteQueueOpts(opts);
+  }
+  testEmptyQueue() {
+    if (this.waitForEmptyQueue && this.queue.length === 0) {
+      this.waitForEmptyQueue.resolve();
+    }
+  }
+  async process() {
+    if (this.isProcessing || this.queue.length === 0) {
+      this.testEmptyQueue();
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      this.logger.Debug().Any("opts", this.opts).Len(this.queue).Msg("Processing tasks");
+      const tasksToProcess = this.queue.splice(0, this.opts.chunkSize);
+      const updates = tasksToProcess.map((item) => item.tasks).filter((item) => item);
       const promises = updates.map(async (update, index2) => {
         try {
-          const result = await worker([update]);
+          const result = await this.worker(update);
           tasksToProcess[index2].resolve(result);
         } catch (error) {
-          tasksToProcess[index2].reject(error);
+          tasksToProcess[index2].reject(this.logger.Error().Err(error).Msg("Error processing task").AsError());
         }
       });
-      await Promise.all(promises);
-    } else {
-      try {
-        const result = await worker(updates);
-        tasksToProcess.forEach((task) => task.resolve(result));
-      } catch (error) {
-        tasksToProcess.forEach((task) => task.reject(error));
-      }
+      await Promise.allSettled(promises);
+      this.logger.Debug().Any("opts", this.opts).Len(this.queue).Msg("Processed tasks");
+    } catch (error) {
+      this.logger.Error().Err(error).Msg("Error processing tasks");
+    } finally {
+      this.isProcessing = false;
+      setTimeout(() => this.process(), 0);
     }
-    isProcessing = false;
-    void process();
   }
-  return {
-    push(task) {
-      return new Promise((resolve, reject) => {
-        queue.push({ task, resolve, reject });
-        void process();
-      });
-    }
-  };
-}
-
-// src/crdt.ts
-import { ResolveOnce as ResolveOnce5 } from "@adviser/cement";
-
-// src/runtime/wait-pr-multiformats/block.ts
-var block_exports = {};
-__export(block_exports, {
-  Block: () => Block,
-  create: () => create,
-  createUnsafe: () => createUnsafe,
-  decode: () => decode,
-  encode: () => encode
-});
-import { bytes as binary, CID } from "multiformats";
-import { Block as mfBlock } from "multiformats/block";
-var Block = mfBlock;
-async function decode({
-  bytes,
-  codec: codec3,
-  hasher: hasher7
-}) {
-  if (bytes == null) throw new Error('Missing required argument "bytes"');
-  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
-  const value = await Promise.resolve(codec3.decode(bytes));
-  const hash = await hasher7.digest(bytes);
-  const cid = CID.create(1, codec3.code, hash);
-  return new mfBlock({ value, bytes, cid });
-}
-async function encode({
-  value,
-  codec: codec3,
-  hasher: hasher7
-}) {
-  if (typeof value === "undefined") throw new Error('Missing required argument "value"');
-  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
-  const bytes = await Promise.resolve(codec3.encode(value));
-  const hash = await hasher7.digest(bytes);
-  const cid = CID.create(1, codec3.code, hash);
-  return new mfBlock({ value, bytes, cid });
-}
-async function create({
-  bytes,
-  cid,
-  hasher: hasher7,
-  codec: codec3
-}) {
-  if (bytes == null) throw new Error('Missing required argument "bytes"');
-  if (hasher7 == null) throw new Error('Missing required argument "hasher"');
-  const value = await Promise.resolve(codec3.decode(bytes));
-  const hash = await hasher7.digest(bytes);
-  if (!binary.equals(cid.multihash.bytes, hash.bytes)) {
-    throw new Error("CID hash does not match bytes");
+  bulk(tasks) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ tasks, resolve, reject });
+      this.process();
+    });
   }
-  return createUnsafe({
-    bytes,
-    cid,
-    value,
-    codec: codec3
-  });
-}
-async function createUnsafe({
-  bytes,
-  cid,
-  value: maybeValue,
-  codec: codec3
-}) {
-  const value = await Promise.resolve(maybeValue !== void 0 ? maybeValue : codec3?.decode(bytes));
-  if (value === void 0) throw new Error('Missing required argument, must either provide "value" or "codec"');
-  return new Block({
-    cid,
-    bytes,
-    value
-  });
+  push(task) {
+    return this.bulk([task]);
+  }
+  close() {
+    this.waitForEmptyQueue = new Future();
+    this.testEmptyQueue();
+    return this.waitForEmptyQueue.asPromise();
+  }
+};
+function writeQueue(sthis, worker, opts) {
+  return new WriteQueueImpl(sthis, worker, opts);
 }
 
-// src/crdt-helpers.ts
-import { parse as parse3 } from "multiformats/link";
-import { sha256 as hasher5 } from "multiformats/hashes/sha2";
-import * as codec from "@fireproof/vendor/@ipld/dag-cbor";
-import { put, get, entries, root } from "@fireproof/vendor/@web3-storage/pail/crdt";
-import { EventFetcher, vis } from "@fireproof/vendor/@web3-storage/pail/clock";
-import * as Batch from "@fireproof/vendor/@web3-storage/pail/crdt/batch";
+// src/crdt.ts
+import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
 
 // src/blockstore/index.ts
 var blockstore_exports = {};
 __export(blockstore_exports, {
   BaseBlockstore: () => BaseBlockstore,
+  Car2FPMsg: () => Car2FPMsg,
   CarTransaction: () => CarTransaction,
   CompactionFetcher: () => CompactionFetcher,
   ConnectionBase: () => ConnectionBase,
+  DbMetaEventEqual: () => DbMetaEventEqual,
+  DbMetaEventsEqual: () => DbMetaEventsEqual,
   EncryptedBlockstore: () => EncryptedBlockstore,
-  FragmentGateway: () => FragmentGateway,
+  FPEnvelopeType: () => FPEnvelopeType,
+  File2FPMsg: () => File2FPMsg,
+  InterceptorGateway: () => InterceptorGateway,
   Loader: () => Loader,
-  addCryptoKeyToGatewayMetaPayload: () => addCryptoKeyToGatewayMetaPayload,
-  ensureStart: () => ensureStart,
-  getGatewayFromURL: () => getGatewayFromURL,
+  PassThroughGateway: () => PassThroughGateway,
+  createDbMetaEvent: () => createDbMetaEvent,
+  defaultGatewayFactoryItem: () => defaultGatewayFactoryItem,
+  ensureStoreEnDeFile: () => ensureStoreEnDeFile,
+  getDefaultURI: () => getDefaultURI,
+  getGatewayFactoryItem: () => getGatewayFactoryItem,
+  getStartedGateway: () => getStartedGateway,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
-  setCryptoKeyFromGatewayMetaPayload: () => setCryptoKeyFromGatewayMetaPayload,
-  testStoreFactory: () => testStoreFactory,
   toCIDBlock: () => toCIDBlock,
   toStoreRuntime: () => toStoreRuntime
 });
@@ -175,9 +469,15 @@ __export(blockstore_exports, {
 function toCIDBlock(block) {
   return block;
 }
+function DbMetaEventEqual(a, b) {
+  return a.eventCid.equals(b.eventCid) && a.parents.length === b.parents.length && a.parents.every((p, i) => p.equals(b.parents[i])) && a.dbMeta.cars.length === b.dbMeta.cars.length && a.dbMeta.cars.every((c, i) => c.equals(b.dbMeta.cars[i]));
+}
+function DbMetaEventsEqual(a, b) {
+  return a.length === b.length && a.every((e, i) => DbMetaEventEqual(e, b[i]));
+}
 
 // src/blockstore/store-factory.ts
-import { KeyedResolvOnce as KeyedResolvOnce2, URI as URI5 } from "@adviser/cement";
+import { KeyedResolvOnce as KeyedResolvOnce3, Result as Result10 } from "@adviser/cement";
 
 // src/runtime/files.ts
 var files_exports = {};
@@ -251,30 +551,83 @@ var UnixFSFileBuilder = class {
 };
 
 // src/blockstore/store.ts
-import { format as format2, parse as parse2 } from "@fireproof/vendor/@ipld/dag-json";
-import { exception2Result, ResolveOnce as ResolveOnce3, Result as Result5 } from "@adviser/cement";
+import { exception2Result, ResolveOnce as ResolveOnce4, Result as Result5 } from "@adviser/cement";
 
-// src/types.ts
-function isFalsy(value) {
-  return value === false && value === null && value === void 0;
+// src/blockstore/loader.ts
+import pLimit from "p-limit";
+import { CarReader } from "@fireproof/vendor/@ipld/car/reader";
+import { ResolveOnce as ResolveOnce3 } from "@adviser/cement";
+
+// src/runtime/wait-pr-multiformats/block.ts
+var block_exports = {};
+__export(block_exports, {
+  Block: () => Block,
+  create: () => create,
+  createUnsafe: () => createUnsafe,
+  decode: () => decode,
+  encode: () => encode
+});
+import { bytes as binary, CID } from "multiformats";
+import { Block as mfBlock } from "multiformats/block";
+var Block = mfBlock;
+async function decode({
+  bytes,
+  codec: codec3,
+  hasher: hasher7
+}) {
+  if (bytes == null) throw new Error('Missing required argument "bytes"');
+  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
+  const value = await Promise.resolve(codec3.decode(bytes));
+  const hash = await hasher7.digest(bytes);
+  const cid = CID.create(1, codec3.code, hash);
+  return new mfBlock({ value, bytes, cid });
 }
-function throwFalsy(value) {
-  if (isFalsy(value)) {
-    throw new Error("value is Falsy");
-  }
-  return value;
+async function encode({
+  value,
+  codec: codec3,
+  hasher: hasher7
+}) {
+  if (typeof value === "undefined") throw new Error('Missing required argument "value"');
+  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
+  const bytes = await Promise.resolve(codec3.encode(value));
+  const hash = await hasher7.digest(bytes);
+  const cid = CID.create(1, codec3.code, hash);
+  return new mfBlock({ value, bytes, cid });
 }
-function falsyToUndef(value) {
-  if (isFalsy(value)) {
-    return void 0;
+async function create({
+  bytes,
+  cid,
+  hasher: hasher7,
+  codec: codec3
+}) {
+  if (bytes == null) throw new Error('Missing required argument "bytes"');
+  if (hasher7 == null) throw new Error('Missing required argument "hasher"');
+  const value = await Promise.resolve(codec3.decode(bytes));
+  const hash = await hasher7.digest(bytes);
+  if (!binary.equals(cid.multihash.bytes, hash.bytes)) {
+    throw new Error("CID hash does not match bytes");
   }
-  return value;
+  return createUnsafe({
+    bytes,
+    cid,
+    value,
+    codec: codec3
+  });
+}
+async function createUnsafe({
+  bytes,
+  cid,
+  value: maybeValue,
+  codec: codec3
+}) {
+  const value = await Promise.resolve(maybeValue !== void 0 ? maybeValue : codec3?.decode(bytes));
+  if (value === void 0) throw new Error('Missing required argument, must either provide "value" or "codec"');
+  return new Block({
+    cid,
+    bytes,
+    value
+  });
 }
-
-// src/blockstore/loader.ts
-import pLimit from "p-limit";
-import { CarReader } from "@fireproof/vendor/@ipld/car/reader";
-import { ResolveOnce as ResolveOnce2 } from "@adviser/cement";
 
 // src/blockstore/loader-helpers.ts
 import { sha256 as hasher } from "multiformats/hashes/sha2";
@@ -293,7 +646,7 @@ async function parseCarFile(reader, logger) {
 
 // src/blockstore/transaction.ts
 import { MemoryBlockstore } from "@fireproof/vendor/@web3-storage/pail/block";
-import { toCryptoRuntime } from "@adviser/cement";
+import { toCryptoRuntime as toCryptoRuntime2 } from "@adviser/cement";
 var CarTransaction = class extends MemoryBlockstore {
   constructor(parent, opts = { add: true, noLoader: false }) {
     super();
@@ -311,7 +664,6 @@ var CarTransaction = class extends MemoryBlockstore {
 };
 function defaultedBlockstoreRuntime(sthis, opts, component, ctx) {
   const logger = ensureLogger(sthis, component, ctx);
-  const store = opts.store || {};
   return {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     applyMeta: (meta, snap) => {
@@ -323,30 +675,27 @@ function defaultedBlockstoreRuntime(sthis, opts, component, ctx) {
     },
     autoCompact: 100,
     public: false,
-    name: void 0,
+    // name: undefined,
     threshold: 1e3 * 1e3,
     ...opts,
     logger,
     keyBag: opts.keyBag || {},
-    crypto: toCryptoRuntime(opts.crypto),
-    store,
-    storeRuntime: toStoreRuntime(store, sthis)
+    crypto: toCryptoRuntime2(opts.crypto),
+    storeUrls: opts.storeUrls,
+    // storeEnDeFile: ensureStoreEnDeFile(opts.storeEnDeFile),
+    // store,
+    storeRuntime: toStoreRuntime(sthis, ensureStoreEnDeFile(opts.storeEnDeFile))
   };
 }
-function blockstoreFactory(sthis, opts) {
-  if (opts.name) {
-    return new EncryptedBlockstore(sthis, opts);
-  } else {
-    return new BaseBlockstore(opts);
-  }
-}
 var BaseBlockstore = class {
-  constructor(ebOpts = {}) {
+  constructor(ebOpts) {
     this.transactions = /* @__PURE__ */ new Set();
     this.sthis = ensureSuperThis(ebOpts);
     this.ebOpts = defaultedBlockstoreRuntime(this.sthis, ebOpts, "BaseBlockstore");
     this.logger = this.ebOpts.logger;
+    this.loader = new Loader(this.sthis, ebOpts);
   }
+  // readonly name?: string;
   // ready: Promise<void>;
   ready() {
     return Promise.resolve();
@@ -370,8 +719,11 @@ var BaseBlockstore = class {
   }
   // TransactionMeta
   async transaction(fn, _opts) {
+    this.logger.Debug().Msg("enter transaction");
     const t = new CarTransaction(this, _opts);
+    this.logger.Debug().Msg("post CarTransaction");
     const done = await fn(t);
+    this.logger.Debug().Msg("post fn");
     this.lastTxMeta = done;
     return { t, meta: done };
   }
@@ -380,7 +732,7 @@ var BaseBlockstore = class {
   }
   async commitTransaction(t, done, opts) {
     if (!this.loader) throw this.logger.Error().Msg("loader required to commit").AsError();
-    const cars = await this.loader?.commit(t, done, opts);
+    const cars = await this.loader.commit(t, done, opts);
     if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
       setTimeout(() => void this.compact(), 10);
     }
@@ -405,14 +757,11 @@ var EncryptedBlockstore = class extends BaseBlockstore {
   constructor(sthis, ebOpts) {
     super(ebOpts);
     this.compacting = false;
-    this.logger = ensureLogger(this.sthis, "EncryptedBlockstore");
-    const { name } = ebOpts;
-    if (!name) {
-      throw this.logger.Error().Msg("name required").AsError();
-    }
-    this.name = name;
-    this.loader = new Loader(this.name, ebOpts, sthis);
+    this.logger = ensureLogger(this.sthis, "EncryptedBlockstore", {
+      this: 1
+    });
   }
+  // readonly name: string;
   ready() {
     return this.loader.ready();
   }
@@ -431,8 +780,11 @@ var EncryptedBlockstore = class extends BaseBlockstore {
     return falsyToUndef(await this.loader.getBlock(cid));
   }
   async transaction(fn, opts = { noLoader: false }) {
+    this.logger.Debug().Msg("enter transaction");
     const { t, meta: done } = await super.transaction(fn);
+    this.logger.Debug().Msg("post super.transaction");
     const cars = await this.loader.commit(t, done, opts);
+    this.logger.Debug().Msg("post this.loader.commit");
     if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
       setTimeout(() => void this.compact(), 10);
     }
@@ -444,7 +796,7 @@ var EncryptedBlockstore = class extends BaseBlockstore {
   }
   async getFile(car, cid) {
     await this.ready();
-    if (!this.loader) throw this.logger.Error().Msg("loader required to get file, database must be named").AsError();
+    if (!this.loader) throw this.logger.Error().Msg("loader required to get file, ledger must be named").AsError();
     const reader = await this.loader.loadFileCar(
       car
       /*, isPublic */
@@ -462,7 +814,7 @@ var EncryptedBlockstore = class extends BaseBlockstore {
     const blockLog = new CompactionFetcher(this);
     this.compacting = true;
     const meta = await compactFn(blockLog);
-    await this.loader?.commit(blockLog.loggedBlocks, meta, {
+    await this.loader.commit(blockLog.loggedBlocks, meta, {
       compact: true,
       noLoader: true
     });
@@ -504,7 +856,7 @@ var CompactionFetcher = class {
 };
 
 // src/blockstore/commit-queue.ts
-import { Future } from "@adviser/cement";
+import { Future as Future2 } from "@adviser/cement";
 var CommitQueue = class {
   constructor() {
     this.queue = [];
@@ -515,7 +867,7 @@ var CommitQueue = class {
     if (this.queue.length === 0 && !this.processing) {
       return Promise.resolve();
     }
-    const fn = new Future();
+    const fn = new Future2();
     this._waitIdleItems.add(fn);
     return fn.asPromise();
   }
@@ -558,30 +910,111 @@ var CommitQueue = class {
 var key_bag_exports = {};
 __export(key_bag_exports, {
   KeyBag: () => KeyBag,
+  defaultKeyBagOpts: () => defaultKeyBagOpts,
   defaultKeyBagUrl: () => defaultKeyBagUrl,
   getKeyBag: () => getKeyBag,
   registerKeyBagProviderFactory: () => registerKeyBagProviderFactory
 });
 import {
   KeyedResolvOnce,
-  ResolveOnce,
+  ResolveOnce as ResolveOnce2,
   ResolveSeq,
   Result as Result2,
-  runtimeFn,
-  toCryptoRuntime as toCryptoRuntime2,
-  URI
+  runtimeFn as runtimeFn2,
+  toCryptoRuntime as toCryptoRuntime3,
+  URI as URI3
 } from "@adviser/cement";
-import { base58btc } from "multiformats/bases/base58";
+import { base58btc as base58btc2 } from "multiformats/bases/base58";
+
+// src/runtime/gateways/file/sys-file-system-factory.ts
+import { runtimeFn } from "@adviser/cement";
+function sysFileSystemFactory(uri) {
+  const rt = runtimeFn();
+  switch (true) {
+    case rt.isNodeIsh:
+      return import("@fireproof/core/node").then((m) => m.getSysFileSystem(uri));
+    case rt.isDeno:
+      return import("@fireproof/core/deno").then((m) => m.getSysFileSystem(uri));
+    default:
+      throw new Error(`unsupported runtime:${rt}`);
+  }
+}
+
+// src/runtime/gateways/file/key-bag-file.ts
+var KeyBagProviderFile = class {
+  async _prepare(id) {
+    await this.sthis.start();
+    const sysFS = await sysFileSystemFactory(this.url);
+    const dirName = this.url.pathname;
+    await sysFS.mkdir(dirName, { recursive: true });
+    return {
+      dirName,
+      sysFS,
+      fName: this.sthis.pathOps.join(dirName, `${id.replace(/[^a-zA-Z0-9]/g, "_")}.json`)
+    };
+  }
+  constructor(url, sthis) {
+    this.url = url;
+    this.sthis = sthis;
+    this.logger = sthis.logger;
+  }
+  async get(id) {
+    const ctx = await this._prepare(id);
+    try {
+      const p = await ctx.sysFS.readfile(ctx.fName);
+      const ki = JSON.parse(this.sthis.txt.decode(p));
+      return ki;
+    } catch (e) {
+      if (isNotFoundError(e)) {
+        return void 0;
+      }
+      throw this.logger.Error().Err(e).Str("file", ctx.dirName).Msg("read bag failed").AsError();
+    }
+  }
+  async set(id, item) {
+    const ctx = await this._prepare(id);
+    const p = this.sthis.txt.encode(JSON.stringify(item, null, 2));
+    await ctx.sysFS.writefile(ctx.fName, p);
+  }
+};
+
+// src/runtime/key-bag-memory.ts
+var memoryKeyBag = /* @__PURE__ */ new Map();
+var KeyBagProviderMemory = class {
+  constructor(url, sthis) {
+    this.url = url;
+    this.sthis = sthis;
+  }
+  key(id) {
+    return `${this.url.pathname}/${id}`;
+  }
+  async get(id) {
+    const binKeyItem = memoryKeyBag.get(this.key(id));
+    if (binKeyItem) {
+      const ki = JSON.parse(this.sthis.txt.decode(binKeyItem));
+      return ki;
+    }
+    return void 0;
+  }
+  async set(id, item) {
+    const p = this.sthis.txt.encode(JSON.stringify(item, null, 2));
+    memoryKeyBag.set(this.key(id), p);
+  }
+};
+
+// src/runtime/key-bag.ts
 var KeyBag = class {
   constructor(rt) {
     this.rt = rt;
-    this._warnOnce = new ResolveOnce();
+    this._warnOnce = new ResolveOnce2();
     this._seq = new ResolveSeq();
-    this.logger = ensureLogger(rt.sthis, "KeyBag");
+    this.logger = ensureLogger(rt.sthis, "KeyBag", {
+      // id: rt.id(),
+    });
     this.logger.Debug().Msg("KeyBag created");
   }
   async subtleKey(key) {
-    const extractable = this.rt.url.getParam("extractKey") === "_deprecated_internal_api";
+    const extractable = this.rt.url.getParam("extractKey" /* EXTRACTKEY */) === "_deprecated_internal_api";
     if (extractable) {
       this._warnOnce.once(
         () => this.logger.Warn().Msg("extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!")
@@ -590,7 +1023,7 @@ var KeyBag = class {
     return await this.rt.crypto.importKey(
       "raw",
       // raw or jwk
-      base58btc.decode(key),
+      base58btc2.decode(key),
       // hexStringToUint8Array(key), // raw data
       "AES-GCM",
       extractable,
@@ -598,7 +1031,7 @@ var KeyBag = class {
     );
   }
   async ensureKeyFromUrl(url, keyFactory) {
-    const storeKey = url.getParam("storekey");
+    const storeKey = url.getParam("storekey" /* STORE_KEY */);
     if (storeKey === "insecure") {
       return Result2.Ok(url);
     }
@@ -608,7 +1041,7 @@ var KeyBag = class {
       if (ret.isErr()) {
         return ret;
       }
-      const urb = url.build().setParam("storekey", keyName);
+      const urb = url.build().setParam("storekey" /* STORE_KEY */, keyName);
       return Result2.Ok(urb.URI());
     }
     if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
@@ -620,12 +1053,12 @@ var KeyBag = class {
     return Result2.Ok(url);
   }
   async toKeyWithFingerPrint(keyStr) {
-    const material = base58btc.decode(keyStr);
+    const material = base58btc2.decode(keyStr);
     const key = await this.subtleKey(keyStr);
     const fpr = await this.rt.crypto.digestSHA256(material);
     return Result2.Ok({
       key,
-      fingerPrint: base58btc.encode(new Uint8Array(fpr))
+      fingerPrint: base58btc2.encode(new Uint8Array(fpr))
     });
   }
   async setNamedKey(name, key) {
@@ -654,7 +1087,7 @@ var KeyBag = class {
         const ext = new Uint8Array(await this.rt.crypto.exportKey("raw", named.key));
         return {
           key: ext,
-          keyStr: base58btc.encode(ext)
+          keyStr: base58btc2.encode(ext)
         };
       }
     });
@@ -673,7 +1106,7 @@ var KeyBag = class {
         this.logger.Debug().Str("id", id).Str("name", name).Msg("failIfNotFound getNamedKey");
         return Result2.Err(new Error(`Key not found: ${name}`));
       }
-      const ret = await this._setNamedKey(name, base58btc.encode(this.rt.crypto.randomBytes(this.rt.keyLength)));
+      const ret = await this._setNamedKey(name, base58btc2.encode(this.rt.crypto.randomBytes(this.rt.keyLength)));
       this.logger.Debug().Str("id", id).Str("name", name).Result("fpr", ret).Msg("createKey getNamedKey-post");
       return ret;
     });
@@ -684,15 +1117,20 @@ var keyBagProviderFactories = new Map(
     {
       protocol: "file:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderFile } = await import("./key-bag-file-PWZ3QE7B.js");
         return new KeyBagProviderFile(url, sthis);
       }
     },
     {
       protocol: "indexdb:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderIndexDB } = await import("./key-bag-indexdb-SYG3YD4D.js");
-        return new KeyBagProviderIndexDB(url, sthis);
+        const { KeyBagProviderImpl } = await import("@fireproof/core/web");
+        return new KeyBagProviderImpl(url, sthis);
+      }
+    },
+    {
+      protocol: "memory:",
+      factory: async (url, sthis) => {
+        return new KeyBagProviderMemory(url, sthis);
       }
     }
   ].map((i) => [i.protocol, i])
@@ -707,15 +1145,15 @@ function registerKeyBagProviderFactory(item) {
 function defaultKeyBagUrl(sthis) {
   let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
   let url;
-  if (runtimeFn().isBrowser) {
-    url = URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
+  if (runtimeFn2().isBrowser) {
+    url = URI3.from(bagFnameOrUrl || "indexdb://fp-keybag");
   } else {
     if (!bagFnameOrUrl) {
       const home = sthis.env.get("HOME");
       bagFnameOrUrl = `${home}/.fireproof/keybag`;
-      url = URI.from(`file://${bagFnameOrUrl}`);
+      url = URI3.from(`file://${bagFnameOrUrl}`);
     } else {
-      url = URI.from(bagFnameOrUrl);
+      url = URI3.from(bagFnameOrUrl);
     }
   }
   const logger = ensureLogger(sthis, "defaultKeyBagUrl");
@@ -723,32 +1161,44 @@ function defaultKeyBagUrl(sthis) {
   return url;
 }
 function defaultKeyBagOpts(sthis, kbo) {
+  kbo = kbo || {};
   if (kbo.keyRuntime) {
     return kbo.keyRuntime;
   }
   const logger = ensureLogger(sthis, "KeyBag");
   let url;
   if (kbo.url) {
-    url = URI.from(kbo.url);
+    url = URI3.from(kbo.url);
     logger.Debug().Url(url).Msg("from opts");
   } else {
-    url = defaultKeyBagUrl(sthis);
+    let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
+    if (runtimeFn2().isBrowser) {
+      url = URI3.from(bagFnameOrUrl || "indexdb://fp-keybag");
+    } else {
+      if (!bagFnameOrUrl) {
+        const home = sthis.env.get("HOME");
+        bagFnameOrUrl = `${home}/.fireproof/keybag`;
+        url = URI3.from(`file://${bagFnameOrUrl}`);
+      } else {
+        url = URI3.from(bagFnameOrUrl);
+      }
+    }
+    logger.Debug().Url(url).Msg("from env");
   }
   const kitem = keyBagProviderFactories.get(url.protocol);
   if (!kitem) {
     throw logger.Error().Url(url).Msg("unsupported protocol").AsError();
   }
-  const getBag = async () => kitem.factory(url, sthis);
   if (url.hasParam("masterkey")) {
     throw logger.Error().Url(url).Msg("masterkey is not supported").AsError();
   }
   return {
     url,
-    crypto: kbo.crypto || toCryptoRuntime2({}),
+    crypto: kbo.crypto || toCryptoRuntime3({}),
     sthis,
     logger,
     keyLength: kbo.keyLength || 16,
-    getBag,
+    getBag: () => kitem.factory(url, sthis),
     id: () => {
       return url.toString();
     }
@@ -773,7 +1223,7 @@ async function encodeCarFile(roots, t, codec3) {
     size += CBW.blockLength({ cid, bytes });
   }
   const buffer = new Uint8Array(size);
-  const writer = CBW.createWriter(buffer, { headerSize });
+  const writer = CBW.createWriter(buffer.buffer, { headerSize });
   for (const r of roots) {
     writer.addRoot(r);
   }
@@ -928,7 +1378,7 @@ function uniqueCids(list, remove = /* @__PURE__ */ new Set()) {
   return [...byString.values()];
 }
 var Loader = class {
-  constructor(name, ebOpts, sthis) {
+  constructor(sthis, ebOpts) {
     this.commitQueue = new CommitQueue();
     this.isCompacting = false;
     this.carReaders = /* @__PURE__ */ new Map();
@@ -938,14 +1388,17 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = pLimit(1);
-    this.onceReady = new ResolveOnce2();
-    this.name = name;
+    this._carStore = new ResolveOnce3();
+    this._fileStore = new ResolveOnce3();
+    this._WALStore = new ResolveOnce3();
+    this._metaStore = new ResolveOnce3();
+    this.onceReady = new ResolveOnce3();
     this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
       sthis,
       {
-        ...ebOpts,
-        name
+        ...ebOpts
+        // name,
       },
       "Loader"
     );
@@ -954,21 +1407,52 @@ var Loader = class {
       await this.handleDbMetasFromStore([dbMeta]);
     });
   }
-  // readonly id = uuidv4();
-  async keyBag() {
-    return getKeyBag(this.sthis, this.ebOpts.keyBag);
-  }
   async carStore() {
-    return this.ebOpts.storeRuntime.makeDataStore(this);
+    return this._carStore.once(
+      async () => this.ebOpts.storeRuntime.makeDataStore({
+        sthis: this.sthis,
+        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+        url: this.ebOpts.storeUrls.data,
+        // keybag: await this.keyBag(),
+        loader: this
+      })
+    );
   }
   async fileStore() {
-    return this.ebOpts.storeRuntime.makeDataStore(this);
+    return this._fileStore.once(
+      async () => this.ebOpts.storeRuntime.makeDataStore({
+        sthis: this.sthis,
+        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+        url: this.ebOpts.storeUrls.file,
+        // keybag: await this.keyBag(),
+        loader: this
+      })
+    );
   }
   async WALStore() {
-    return this.ebOpts.storeRuntime.makeWALStore(this);
+    return this._WALStore.once(
+      async () => this.ebOpts.storeRuntime.makeWALStore({
+        sthis: this.sthis,
+        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+        url: this.ebOpts.storeUrls.wal,
+        // keybag: await this.keyBag(),
+        loader: this
+      })
+    );
   }
   async metaStore() {
-    return this.ebOpts.storeRuntime.makeMetaStore(this);
+    return this._metaStore.once(
+      async () => this.ebOpts.storeRuntime.makeMetaStore({
+        sthis: this.sthis,
+        gatewayInterceptor: this.ebOpts.gatewayInterceptor,
+        url: this.ebOpts.storeUrls.meta,
+        // keybag: await this.keyBag(),
+        loader: this
+      })
+    );
+  }
+  keyBag() {
+    return getKeyBag(this.sthis, this.ebOpts.keyBag);
   }
   async ready() {
     return this.onceReady.once(async () => {
@@ -981,6 +1465,7 @@ var Loader = class {
     });
   }
   async close() {
+    await this.commitQueue.waitIdle();
     const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
     await Promise.all(toClose.map((store) => store.close()));
   }
@@ -1050,11 +1535,11 @@ var Loader = class {
   }
   async commit(t, done, opts = { noLoader: false, compact: false }) {
     await this.ready();
-    const fstore = await this.fileStore();
+    const carStore = await this.carStore();
     const params = {
-      encoder: (await fstore.keyedCrypto()).codec(),
+      encoder: (await carStore.keyedCrypto()).codec(),
       carLog: this.carLog,
-      carStore: fstore,
+      carStore,
       WALStore: await this.WALStore(),
       metaStore: await this.metaStore(),
       threshold: this.ebOpts.threshold
@@ -1263,7 +1748,7 @@ __export(keyed_crypto_exports, {
   BlockIvKeyIdCodec: () => BlockIvKeyIdCodec,
   keyedCryptoFactory: () => keyedCryptoFactory
 });
-import { base58btc as base58btc2 } from "multiformats/bases/base58";
+import { base58btc as base58btc3 } from "multiformats/bases/base58";
 import { sha256 as hasher4 } from "multiformats/hashes/sha2";
 import * as CBOR from "@fireproof/vendor/cborg";
 var generateIV = {
@@ -1288,12 +1773,12 @@ var generateIV = {
       return hashArray;
     },
     verify: async function(ko, crypto, iv, data) {
-      return ko.url.getParam("ivverify") !== "disable" && UInt8ArrayEqual(iv, await this.calc(ko, crypto, data));
+      return ko.url.getParam("ivVerify" /* IV_VERIFY */) !== "disable" && UInt8ArrayEqual(iv, await this.calc(ko, crypto, data));
     }
   }
 };
 function getGenerateIVFn(url, opts) {
-  const ivhash = opts.ivCalc || url.getParam("ivhash") || "hash";
+  const ivhash = opts.ivCalc || url.getParam("ivHash" /* IV_HASH */) || "hash";
   return generateIV[ivhash] || generateIV["hash"];
 }
 var BlockIvKeyIdCodec = class {
@@ -1308,7 +1793,7 @@ var BlockIvKeyIdCodec = class {
     const calcIv = this.iv || await getGenerateIVFn(this.ko.url, this.opts).calc(this.ko, this.ko.crypto, data);
     const { iv } = this.ko.algo(calcIv);
     const fprt = await this.ko.fingerPrint();
-    const keyId = base58btc2.decode(fprt);
+    const keyId = base58btc3.decode(fprt);
     this.ko.logger.Debug().Str("fp", fprt).Msg("encode");
     return CBOR.encode({
       iv,
@@ -1325,9 +1810,9 @@ var BlockIvKeyIdCodec = class {
     }
     const { iv, keyId, data } = CBOR.decode(bytes);
     const fprt = await this.ko.fingerPrint();
-    this.ko.logger.Debug().Str("fp", base58btc2.encode(keyId)).Msg("decode");
-    if (base58btc2.encode(keyId) !== fprt) {
-      throw this.ko.logger.Error().Str("fp", fprt).Str("keyId", base58btc2.encode(keyId)).Msg("keyId mismatch").AsError();
+    this.ko.logger.Debug().Str("fp", base58btc3.encode(keyId)).Msg("decode");
+    if (base58btc3.encode(keyId) !== fprt) {
+      throw this.ko.logger.Error().Str("fp", fprt).Str("keyId", base58btc3.encode(keyId)).Msg("keyId mismatch").AsError();
     }
     const result = await this.ko._decrypt({ iv, bytes: data });
     if (!this.opts?.noIVVerify && !await getGenerateIVFn(this.ko.url, this.opts).verify(this.ko, this.ko.crypto, iv, result)) {
@@ -1414,7 +1899,7 @@ var noCrypto = class {
   }
 };
 async function keyedCryptoFactory(url, kb, sthis) {
-  const storekey = url.getParam("storekey");
+  const storekey = url.getParam("storekey" /* STORE_KEY */);
   if (storekey && storekey !== "insecure") {
     let rkey = await kb.getNamedKey(storekey, true);
     if (rkey.isErr()) {
@@ -1429,277 +1914,167 @@ async function keyedCryptoFactory(url, kb, sthis) {
   return new noCrypto(url, kb.rt.crypto, sthis);
 }
 
-// src/blockstore/fragment-gateway.ts
+// src/blockstore/fp-envelope.ts
 import { Result as Result3 } from "@adviser/cement";
-import { base58btc as base58btc3 } from "multiformats/bases/base58";
-import { encode as encode3, decode as decode3 } from "@fireproof/vendor/cborg";
-function getFragSize(url) {
-  const fragSize = url.getParam("fragSize");
-  let ret = 0;
-  if (fragSize) {
-    ret = parseInt(fragSize);
+var FPEnvelopeType = /* @__PURE__ */ ((FPEnvelopeType2) => {
+  FPEnvelopeType2["CAR"] = "car";
+  FPEnvelopeType2["FILE"] = "file";
+  FPEnvelopeType2["META"] = "meta";
+  FPEnvelopeType2["WAL"] = "wal";
+  return FPEnvelopeType2;
+})(FPEnvelopeType || {});
+function Car2FPMsg(fpcar) {
+  return Result3.Ok({ type: "car" /* CAR */, payload: fpcar });
+}
+function File2FPMsg(fpfile) {
+  return Result3.Ok({ type: "file" /* FILE */, payload: fpfile });
+}
+
+// src/blockstore/store.ts
+import { EventBlock } from "@fireproof/vendor/@web3-storage/pail/clock";
+import { format } from "@fireproof/vendor/@ipld/dag-json";
+import pRetry from "p-retry";
+import pMap from "p-map";
+
+// src/blockstore/interceptor-gateway.ts
+import { Result as Result4 } from "@adviser/cement";
+var PassThroughGateway = class {
+  async buildUrl(sthis, url, key) {
+    const op = { url, key };
+    return Result4.Ok({ op });
   }
-  if (isNaN(ret) || ret <= 0) {
-    ret = 0;
+  async start(sthis, url) {
+    const op = { url };
+    return Result4.Ok({ op });
   }
-  return ret;
-}
-async function getFrags(url, innerGW, headerSize, logger) {
-  const fragSize = getFragSize(url);
-  if (!fragSize) {
-    const res = await innerGW.get(url);
-    if (res.isErr()) {
-      return [res];
-    }
-    const data = res.unwrap();
-    return [
-      Result3.Ok({
-        fid: new Uint8Array(0),
-        ofs: 0,
-        len: data.length,
-        data
-      })
-    ];
-  }
-  const firstRaw = await innerGW.get(url.build().setParam("ofs", "0").URI());
-  if (firstRaw.isErr()) {
-    return [firstRaw];
-  }
-  const firstFragment = decode3(firstRaw.unwrap());
-  const blockSize = firstFragment.data.length;
-  const ops = [Promise.resolve(Result3.Ok(firstFragment))];
-  const fidStr = base58btc3.encode(firstFragment.fid);
-  const fragUrl = url.build().setParam("fid", fidStr).setParam("len", firstFragment.len.toString()).setParam("headerSize", headerSize.toString());
-  for (let ofs = blockSize; ofs < firstFragment.len; ofs += blockSize) {
-    ops.push(
-      (async (furl, ofs2) => {
-        const raw2 = await innerGW.get(furl);
-        if (raw2.isErr()) {
-          return raw2;
-        }
-        const fragment = decode3(raw2.unwrap());
-        if (base58btc3.encode(fragment.fid) !== fidStr) {
-          return Result3.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
-        }
-        if (fragment.ofs !== ofs2) {
-          return Result3.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
-        }
-        return Result3.Ok(fragment);
-      })(fragUrl.setParam("ofs", ofs.toString()).URI(), ofs)
-    );
+  async close(sthis, url) {
+    const op = { url };
+    return Result4.Ok({ op });
   }
-  return Promise.all(ops);
-}
-var FragmentGateway = class {
-  constructor(sthis, innerGW) {
-    this.fidLength = 4;
-    this.headerSize = 32;
-    this.sthis = ensureSuperLog(sthis, "FragmentGateway");
-    this.logger = this.sthis.logger;
+  async delete(sthis, url) {
+    const op = { url };
+    return Result4.Ok({ op });
+  }
+  async destroy(sthis, url) {
+    const op = { url };
+    return Result4.Ok({ op });
+  }
+  async put(sthis, url, body) {
+    const op = { url, body };
+    return Result4.Ok({ op });
+  }
+  async get(sthis, url) {
+    const op = { url };
+    return Result4.Ok({ op });
+  }
+  async subscribe(sthis, url, callback) {
+    const op = { url, callback };
+    return Result4.Ok({ op });
+  }
+};
+var passThrougthGateway = new PassThroughGateway();
+var InterceptorGateway = class {
+  constructor(sthis, innerGW, interceptor) {
     this.innerGW = innerGW;
+    this.interceptor = interceptor || passThrougthGateway;
   }
-  slicer(url, body) {
-    const fragSize = getFragSize(url);
-    if (!fragSize) {
-      return [this.innerGW.put(url, body)];
-    }
-    const blocksize = fragSize - this.headerSize;
-    if (blocksize <= 0) {
-      throw this.logger.Error().Uint64("fragSize", fragSize).Uint64("headerSize", this.headerSize).Msg("Fragment size is too small").AsError();
-    }
-    const ops = [];
-    const fid = this.sthis.nextId(this.fidLength);
-    const fragUrl = url.build().setParam("fid", fid.str).setParam("len", body.length.toString()).setParam("headerSize", this.headerSize.toString());
-    for (let ofs = 0; ofs < body.length; ofs += blocksize) {
-      const block = encode3({
-        fid: fid.bin,
-        ofs,
-        len: body.length,
-        data: body.slice(ofs, ofs + blocksize)
-      });
-      if (block.length > fragSize) {
-        throw this.logger.Error().Uint64("block", block.length).Uint64("fragSize", fragSize).Msg("Block size to big").AsError();
-      }
-      ops.push(this.innerGW.put(fragUrl.setParam("ofs", ofs.toString()).URI(), block));
+  async buildUrl(sthis, baseUrl, key, loader) {
+    const rret = await this.interceptor.buildUrl(sthis, baseUrl, key, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
     }
-    return ops;
+    return this.innerGW.buildUrl(sthis, ret.op.url, ret.op.key, loader);
   }
-  buildUrl(baseUrl, key) {
-    return this.innerGW.buildUrl(baseUrl, key);
-  }
-  async destroy(iurl) {
-    return this.innerGW.destroy(iurl);
-  }
-  async start(url) {
-    this.headerSize = encode3({
-      fid: this.sthis.nextId(this.fidLength).bin,
-      ofs: 1024 * 1024,
-      // 32bit
-      len: 16 * 1024 * 1024,
-      // 32bit
-      data: new Uint8Array(1024)
-    }).length - 1024;
-    return this.innerGW.start(url);
-  }
-  async close(url) {
-    return this.innerGW.close(url);
-  }
-  async put(url, body) {
-    await Promise.all(this.slicer(url, body));
-    return Result3.Ok(void 0);
-  }
-  async get(url) {
-    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
-    let buffer = void 0;
-    for (const rfrag of rfrags) {
-      if (rfrag.isErr()) {
-        return Result3.Err(rfrag.Err());
-      }
-      const frag = rfrag.Ok();
-      buffer = buffer || new Uint8Array(frag.len);
-      buffer.set(frag.data, frag.ofs);
-    }
-    return Result3.Ok(buffer || new Uint8Array(0));
-  }
-  async subscribe(url, callback) {
-    if (this.innerGW.subscribe) {
-      return this.innerGW.subscribe(url, callback);
-    } else {
-      return Result3.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+  async destroy(sthis, iurl, loader) {
+    const rret = await this.interceptor.destroy(sthis, iurl, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
     }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.destroy(sthis, ret.op.url, loader);
   }
-  async delete(url) {
-    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
-    for (const rfrag of rfrags) {
-      if (rfrag.isErr()) {
-        return Result3.Err(rfrag.Err());
-      }
-      const frag = rfrag.Ok();
-      const fidStr = base58btc3.encode(frag.fid);
-      const fragUrl = url.build().setParam("fid", fidStr).setParam("len", frag.len.toString()).setParam("headerSize", this.headerSize.toString()).URI();
-      await this.innerGW.delete(fragUrl);
+  async start(sthis, url, loader) {
+    const rret = await this.interceptor.start(sthis, url, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
     }
-    return Result3.Ok(void 0);
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.start(sthis, ret.op.url, loader);
   }
-};
-
-// src/blockstore/meta-key-helper.ts
-import { format, parse } from "@fireproof/vendor/@ipld/dag-json";
-import { EventBlock, decodeEventBlock } from "@fireproof/vendor/@web3-storage/pail/clock";
-import { CID as CID2 } from "multiformats";
-import { base64pad } from "multiformats/bases/base64";
-import { Result as Result4 } from "@adviser/cement";
-async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
-  const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
-  if (!Array.isArray(crdtEntries)) {
-    sthis.logger.Debug().Str("crdtEntries", JSON.stringify(crdtEntries)).Msg("No data in CRDT entries");
-    return [];
-  }
-  if (!crdtEntries.length) {
-    sthis.logger.Debug().Any("byteHeads", byteHeads).Msg("No CRDT entries found");
-    return [];
-  }
-  const logger = ensureLogger(sthis, "decodeGatewayMetaBytesToDbMeta");
-  return Promise.all(
-    crdtEntries.map(async (crdtEntry) => {
-      const eventBlock = await decodeEventBlock(base64pad.decode(crdtEntry.data));
-      const dbMeta = parse(sthis.txt.decode(eventBlock.value.data.dbMeta));
-      logger.Debug().Any("crdtEntry", {
-        crdtEntry,
-        eventBlock,
-        dbMeta,
-        dbMetaStrings: dbMeta.cars.map((car) => car.toString())
-      }).Msg("CRDT entry");
-      return {
-        eventCid: eventBlock.cid,
-        parents: crdtEntry.parents,
-        dbMeta
-      };
-    })
-  );
-}
-async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
-  try {
-    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Setting crypto key from gateway meta payload");
-    const keyInfo = await decodeGatewayMetaBytesToDbMeta(sthis, data);
-    if (keyInfo.length) {
-      const dbMeta = keyInfo[0].dbMeta;
-      if (dbMeta.key) {
-        const kb = await getKeyBag(sthis);
-        const keyName = getStoreKeyName(uri);
-        const res = await kb.setNamedKey(keyName, dbMeta.key);
-        if (res.isErr()) {
-          sthis.logger.Debug().Str("keyName", keyName).Str("dbMeta.key", dbMeta.key).Msg("Failed to set named key");
-          throw res.Err();
-        }
-      }
-      sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
-      return Result4.Ok(dbMeta);
+  async close(sthis, url, loader) {
+    const rret = await this.interceptor.close(sthis, url, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
     }
-    sthis.logger.Debug().Any("data", data).Msg("No crypto in gateway meta payload");
-    return Result4.Ok(void 0);
-  } catch (error) {
-    sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
-    return Result4.Err(error);
+    return await this.innerGW.close(sthis, ret.op.url, loader);
   }
-}
-async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
-  try {
-    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Adding crypto key to gateway meta payload");
-    const keyName = getStoreKeyName(uri);
-    const kb = await getKeyBag(sthis);
-    const res = await kb.getNamedExtractableKey(keyName, true);
-    if (res.isErr()) {
-      sthis.logger.Error().Str("keyName", keyName).Msg("Failed to get named extractable key");
-      throw res.Err();
+  async put(sthis, url, fpEnv, loader) {
+    const rret = await this.interceptor.put(sthis, url, fpEnv, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
     }
-    const keyData = await res.Ok().extract();
-    const dbMetas = await decodeGatewayMetaBytesToDbMeta(sthis, body);
-    const { dbMeta, parents } = dbMetas[0];
-    const parentLinks = parents.map((p) => CID2.parse(p));
-    dbMeta.key = keyData.keyStr;
-    const events = await Promise.all([dbMeta].map((dbMeta2) => createDbMetaEventBlock(sthis, dbMeta2, parentLinks)));
-    const encoded = await encodeEventsWithParents(sthis, events, parentLinks);
-    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Added crypto key to gateway meta payload");
-    return Result4.Ok(encoded);
-  } catch (error) {
-    sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
-    return Result4.Err(error);
-  }
-}
-function getStoreKeyName(url) {
-  const storeKeyName = [url.getParam("localName") || url.getParam("name")];
-  const idx = url.getParam("index");
-  if (idx) {
-    storeKeyName.push(idx);
-  }
-  storeKeyName.push("data");
-  return `@${storeKeyName.join(":")}@`;
-}
-async function createDbMetaEventBlock(sthis, dbMeta, parents) {
-  const event = await EventBlock.create(
-    {
-      dbMeta: sthis.txt.encode(format(dbMeta))
-    },
-    parents
-  );
-  return event;
-}
-async function encodeEventsWithParents(sthis, events, parents) {
-  const crdtEntries = events.map((event) => {
-    const base64String = base64pad.encode(event.bytes);
-    return {
-      cid: event.cid.toString(),
-      data: base64String,
-      parents: parents.map((p) => p.toString())
-    };
-  });
-  return sthis.txt.encode(JSON.stringify(crdtEntries));
-}
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.put(sthis, ret.op.url, ret.op.body, loader);
+  }
+  async get(sthis, url, loader) {
+    const rret = await this.interceptor.get(sthis, url, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.get(sthis, ret.op.url, loader);
+  }
+  async subscribe(sthis, url, callback, loader) {
+    if (!this.innerGW.subscribe) {
+      return Result4.Err(sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+    }
+    const rret = await this.interceptor.subscribe(sthis, url, callback, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.subscribe(sthis, ret.op.url, ret.op.callback, loader);
+  }
+  async delete(sthis, url, loader) {
+    const rret = await this.interceptor.delete(sthis, url, loader);
+    if (rret.isErr()) {
+      return Result4.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.delete(sthis, url, loader);
+  }
+  async getPlain(sthis, url, key, loader) {
+    return this.innerGW.getPlain(sthis, url, key, loader);
+  }
+};
 
 // src/blockstore/store.ts
-import pRetry from "p-retry";
-import pMap from "p-map";
 function guardVersion(url) {
   if (!url.hasParam("version")) {
     return Result5.Err(`missing version: ${url.toString()}`);
@@ -1707,16 +2082,21 @@ function guardVersion(url) {
   return Result5.Ok(url);
 }
 var BaseStoreImpl = class {
-  constructor(name, url, opts, sthis, logger) {
+  // readonly loader: Loadable;
+  constructor(sthis, url, opts, logger) {
     this._onStarted = [];
     this._onClosed = [];
-    this.name = name;
     this._url = url;
-    this.keybag = opts.keybag;
-    this.sthis = sthis;
-    this.logger = logger.With().Ref("url", () => this._url.toString()).Str("name", name).Logger();
-    this.gateway = new FragmentGateway(this.sthis, opts.gateway);
+    this.opts = opts;
     this.loader = opts.loader;
+    this.sthis = sthis;
+    const name = this._url.getParam("name" /* NAME */);
+    if (!name) {
+      throw logger.Error().Url(this._url).Msg("missing name").AsError();
+    }
+    this.logger = logger.With().Str("this", this.sthis.nextId().str).Ref("url", () => this._url.toString()).Logger();
+    this.realGateway = opts.gateway;
+    this.gateway = new InterceptorGateway(this.sthis, opts.gateway, opts.gatewayInterceptor);
   }
   url() {
     return this._url;
@@ -1731,21 +2111,21 @@ var BaseStoreImpl = class {
     return;
   }
   async keyedCrypto() {
-    return keyedCryptoFactory(this._url, await this.keybag(), this.sthis);
+    return keyedCryptoFactory(this._url, await this.loader.keyBag(), this.sthis);
   }
   async start() {
     this.logger.Debug().Str("storeType", this.storeType).Msg("starting-gateway-pre");
-    this._url = this._url.build().setParam("store", this.storeType).URI();
-    const res = await this.gateway.start(this._url);
+    this._url = this._url.build().setParam("store" /* STORE */, this.storeType).URI();
+    const res = await this.gateway.start(this.sthis, this._url, this.loader);
     if (res.isErr()) {
       this.logger.Error().Result("gw-start", res).Msg("started-gateway");
       return res;
     }
     this._url = res.Ok();
-    const kb = await this.keybag();
+    const kb = await this.loader.keyBag();
     const skRes = await kb.ensureKeyFromUrl(this._url, () => {
-      const idx = this._url.getParam("index");
-      const storeKeyName = [this.name];
+      const idx = this._url.getParam("index" /* INDEX */);
+      const storeKeyName = [this.url().getParam("name" /* NAME */)];
       if (idx) {
         storeKeyName.push(idx);
       }
@@ -1775,10 +2155,23 @@ var BaseStoreImpl = class {
     return version;
   }
 };
+async function createDbMetaEvent(sthis, dbMeta, parents) {
+  const event = await EventBlock.create(
+    {
+      dbMeta: sthis.txt.encode(format(dbMeta))
+    },
+    parents
+  );
+  return {
+    eventCid: event.cid,
+    dbMeta,
+    parents
+  };
+}
 var MetaStoreImpl = class extends BaseStoreImpl {
   // remote: boolean;
-  constructor(sthis, name, url, opts) {
-    super(name, url, { ...opts }, sthis, ensureLogger(sthis, "MetaStoreImpl"));
+  constructor(sthis, url, opts) {
+    super(sthis, url, { ...opts }, ensureLogger(sthis, "MetaStoreImpl"));
     this.storeType = "meta";
     this.subscribers = /* @__PURE__ */ new Map();
     this.parents = [];
@@ -1788,14 +2181,18 @@ var MetaStoreImpl = class extends BaseStoreImpl {
     ) {
       this.onStarted(async () => {
         this.logger.Debug().Str("url", this.url().toString()).Msg("Subscribing to the gateway");
-        opts.gateway.subscribe?.(this.url(), async (message) => {
-          this.logger.Debug().Msg("Received message from gateway");
-          const dbMetas = await decodeGatewayMetaBytesToDbMeta(this.sthis, message);
-          await Promise.all(
-            dbMetas.map((dbMeta) => this.loader?.taskManager?.handleEvent(dbMeta.eventCid, dbMeta.parents, dbMeta.dbMeta))
-          );
-          this.updateParentsFromDbMetas(dbMetas);
-        });
+        opts.gateway.subscribe?.(
+          this.sthis,
+          this.url(),
+          async ({ payload: dbMetas }) => {
+            this.logger.Debug().Msg("Received message from gateway");
+            await Promise.all(
+              dbMetas.map((dbMeta) => this.loader.taskManager?.handleEvent(dbMeta.eventCid, dbMeta.parents, dbMeta.dbMeta))
+            );
+            this.updateParentsFromDbMetas(dbMetas);
+          },
+          this.loader
+        );
       });
     }
   }
@@ -1806,129 +2203,165 @@ var MetaStoreImpl = class extends BaseStoreImpl {
     const dbMetaParentsSet = new Set(dbMetaParents.map((p) => p.toString()));
     this.parents = Array.from(uniqueParentsMap.values()).filter((p) => !dbMetaParentsSet.has(p.toString()));
   }
-  async handleByteHeads(byteHeads) {
-    return await decodeGatewayMetaBytesToDbMeta(this.sthis, byteHeads);
-  }
+  // async handleByteHeads(byteHeads: Uint8Array) {
+  //   // return await decodeGatewayMetaBytesToDbMeta(this.sthis, byteHeads);
+  //   const rDbMeta = await fpDeserialize(this.sthis, byteHeads, this.url());
+  //   if (rDbMeta.isErr()) {
+  //     throw this.logger.Error().Err(rDbMeta).Msg("error deserializing").AsError();
+  //   }
+  //   return (rDbMeta.Ok() as FPEnvelopeMeta).payload;
+  // }
   async load() {
     const branch = "main";
-    const url = await this.gateway.buildUrl(this.url(), branch);
+    const url = await this.gateway.buildUrl(this.sthis, this.url(), branch, this.loader);
     if (url.isErr()) {
       throw this.logger.Error().Result("buildUrl", url).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
     }
-    const bytes = await this.gateway.get(url.Ok());
-    if (bytes.isErr()) {
-      if (isNotFoundError(bytes)) {
+    const rfpEnv = await this.gateway.get(this.sthis, url.Ok(), this.loader);
+    if (rfpEnv.isErr()) {
+      if (isNotFoundError(rfpEnv)) {
         return void 0;
       }
-      throw this.logger.Error().Url(url.Ok()).Result("bytes:", bytes).Msg("gateway get").AsError();
+      throw this.logger.Error().Url(url.Ok()).Err(rfpEnv).Msg("gateway get").AsError();
     }
-    const dbMetas = await this.handleByteHeads(bytes.Ok());
-    await this.loader?.handleDbMetasFromStore(dbMetas.map((m) => m.dbMeta));
+    const dbMetas = rfpEnv.Ok().payload;
+    await this.loader.handleDbMetasFromStore(dbMetas.map((m) => m.dbMeta));
     this.updateParentsFromDbMetas(dbMetas);
     return dbMetas.map((m) => m.dbMeta);
   }
   async save(meta, branch) {
     branch = branch || "main";
     this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
-    const event = await createDbMetaEventBlock(this.sthis, meta, this.parents);
-    const bytes = await encodeEventsWithParents(this.sthis, [event], this.parents);
-    const url = await this.gateway.buildUrl(this.url(), branch);
+    const url = await this.gateway.buildUrl(this.sthis, this.url(), branch, this.loader);
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
     }
-    this.parents = [event.cid];
-    const res = await this.gateway.put(url.Ok(), bytes);
+    const dbMetaEvent = await createDbMetaEvent(this.sthis, meta, this.parents);
+    const res = await this.gateway.put(
+      this.sthis,
+      url.Ok(),
+      {
+        type: "meta",
+        payload: [dbMetaEvent]
+      },
+      this.loader
+    );
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
     return res;
   }
   async close() {
-    await this.gateway.close(this.url());
+    await this.gateway.close(this.sthis, this.url(), this.loader);
     this._onClosed.forEach((fn) => fn());
     return Result5.Ok(void 0);
   }
   async destroy() {
-    return this.gateway.destroy(this.url());
+    this.logger.Debug().Msg("destroy");
+    return this.gateway.destroy(this.sthis, this.url(), this.loader);
   }
 };
 var DataStoreImpl = class extends BaseStoreImpl {
-  // readonly tag: string = "car-base";
-  constructor(sthis, name, url, opts) {
-    super(name, url, { ...opts }, sthis, ensureLogger(sthis, "DataStoreImpl"));
+  constructor(sthis, url, opts) {
+    super(sthis, url, { ...opts }, ensureLogger(sthis, "DataStoreImpl"));
     this.storeType = "data";
   }
   async load(cid) {
     this.logger.Debug().Any("cid", cid).Msg("loading");
-    const url = await this.gateway.buildUrl(this.url(), cid.toString());
+    const url = await this.gateway.buildUrl(this.sthis, this.url(), cid.toString(), this.loader);
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Str("cid", cid.toString()).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.get(url.Ok());
+    const res = await this.gateway.get(this.sthis, url.Ok(), this.loader);
     if (res.isErr()) {
       throw res.Err();
     }
-    return { cid, bytes: res.Ok() };
+    const fpenv = res.Ok();
+    switch (fpenv.type) {
+      case "car":
+        return { cid, bytes: fpenv.payload };
+      case "file":
+        return { cid, bytes: fpenv.payload };
+      default:
+        throw this.logger.Error().Msg("unexpected type").AsError();
+    }
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async save(car, opts) {
     this.logger.Debug().Any("cid", car.cid.toString()).Msg("saving");
-    const url = await this.gateway.buildUrl(this.url(), car.cid.toString());
+    const url = await this.gateway.buildUrl(this.sthis, this.url(), car.cid.toString(), this.loader);
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Ref("cid", car.cid).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.put(url.Ok(), car.bytes);
+    let fpMsg;
+    switch (url.Ok().getParam("store" /* STORE */)) {
+      case "data":
+        if (url.Ok().getParam("suffix" /* SUFFIX */)) {
+          fpMsg = Car2FPMsg(car.bytes);
+        } else {
+          fpMsg = File2FPMsg(car.bytes);
+        }
+        break;
+      default:
+        throw this.logger.Error().Str("store", url.Ok().getParam("store" /* STORE */)).Msg("unexpected store").AsError();
+    }
+    if (fpMsg.isErr()) {
+      throw this.logger.Error().Err(fpMsg).Msg("got error from FPMsg2Car").AsError();
+    }
+    const res = await this.gateway.put(this.sthis, url.Ok(), fpMsg.Ok(), this.loader);
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
     return res.Ok();
   }
   async remove(cid) {
-    const url = await this.gateway.buildUrl(this.url(), cid.toString());
+    const url = await this.gateway.buildUrl(this.sthis, this.url(), cid.toString(), this.loader);
     if (url.isErr()) {
       return url;
     }
-    return this.gateway.delete(url.Ok());
+    return this.gateway.delete(this.sthis, url.Ok(), this.loader);
   }
   async close() {
-    await this.gateway.close(this.url());
+    await this.gateway.close(this.sthis, this.url(), this.loader);
     this._onClosed.forEach((fn) => fn());
     return Result5.Ok(void 0);
   }
   destroy() {
-    return this.gateway.destroy(this.url());
+    this.logger.Debug().Msg("destroy");
+    return this.gateway.destroy(this.sthis, this.url(), this.loader);
   }
 };
 var WALStoreImpl = class extends BaseStoreImpl {
-  constructor(loader, url, opts) {
-    super(loader.name, url, { ...opts }, loader.sthis, ensureLogger(loader.sthis, "WALStoreImpl"));
+  constructor(sthis, url, opts) {
+    super(sthis, url, { ...opts }, ensureLogger(sthis, "WALStoreImpl"));
     this.storeType = "wal";
-    this._ready = new ResolveOnce3();
+    // readonly tag: string = "rwal-base";
+    // readonly loader: Loadable;
+    this._ready = new ResolveOnce4();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
-    this.loader = loader;
   }
   async ready() {
     return this._ready.once(async () => {
       const walState = await this.load().catch((e) => {
-        this.logger.Error().Any("error", e).Msg("error loading wal");
+        this.logger.Error().Err(e).Msg("error loading wal");
         return void 0;
       });
-      if (!walState) {
-        this.walState.operations = [];
-        this.walState.fileOperations = [];
-      } else {
-        this.walState.operations = walState.operations || [];
-        this.walState.fileOperations = walState.fileOperations || [];
+      this.walState.operations.splice(0, this.walState.operations.length);
+      this.walState.fileOperations.splice(0, this.walState.fileOperations.length);
+      if (walState) {
+        this.walState.operations.push(...walState.operations);
+        this.walState.fileOperations.push(...walState.fileOperations);
       }
     });
   }
   async enqueue(dbMeta, opts) {
     await this.ready();
     if (opts.compact) {
-      this.walState.operations = [];
-      this.walState.noLoaderOps = [dbMeta];
+      this.walState.operations.splice(0, this.walState.operations.length);
+      this.walState.noLoaderOps.splice(0, this.walState.noLoaderOps.length);
+      this.walState.noLoaderOps.push(dbMeta);
     } else if (opts.noLoader) {
       this.walState.noLoaderOps.push(dbMeta);
     } else {
@@ -1958,6 +2391,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     });
   }
   async _doProcess() {
+    if (!this.loader) return;
     if (!this.loader.remoteCarStore) return;
     const operations = [...this.walState.operations];
     const noLoaderOps = [...this.walState.noLoaderOps];
@@ -1975,6 +2409,9 @@ var WALStoreImpl = class extends BaseStoreImpl {
         noLoaderOps,
         async (dbMeta) => {
           await retryableUpload(async () => {
+            if (!this.loader) {
+              return;
+            }
             for (const cid of dbMeta.cars) {
               const car = await (await this.loader.carStore()).load(cid);
               if (!car) {
@@ -1985,7 +2422,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
                 await throwFalsy(this.loader.remoteCarStore).save(car);
               }
             }
-            this.walState.noLoaderOps = this.walState.noLoaderOps.filter((op) => op !== dbMeta);
+            inplaceFilter(this.walState.noLoaderOps, (op) => op !== dbMeta);
           }, `noLoaderOp with dbMeta.cars=${dbMeta.cars.toString()}`);
         },
         { concurrency: concurrencyLimit }
@@ -1994,6 +2431,9 @@ var WALStoreImpl = class extends BaseStoreImpl {
         operations,
         async (dbMeta) => {
           await retryableUpload(async () => {
+            if (!this.loader) {
+              return;
+            }
             for (const cid of dbMeta.cars) {
               const car = await (await this.loader.carStore()).load(cid);
               if (!car) {
@@ -2004,7 +2444,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
                 await throwFalsy(this.loader.remoteCarStore).save(car);
               }
             }
-            this.walState.operations = this.walState.operations.filter((op) => op !== dbMeta);
+            inplaceFilter(this.walState.operations, (op) => op !== dbMeta);
           }, `operation with dbMeta.cars=${dbMeta.cars.toString()}`);
         },
         { concurrency: concurrencyLimit }
@@ -2013,12 +2453,15 @@ var WALStoreImpl = class extends BaseStoreImpl {
         fileOperations,
         async ({ cid: fileCid, public: publicFile }) => {
           await retryableUpload(async () => {
+            if (!this.loader) {
+              return;
+            }
             const fileBlock = await (await this.loader.fileStore()).load(fileCid);
             if (!fileBlock) {
               throw this.logger.Error().Ref("cid", fileCid).Msg("missing file block").AsError();
             }
             await this.loader.remoteFileStore?.save(fileBlock, { public: publicFile });
-            this.walState.fileOperations = this.walState.fileOperations.filter((op) => op.cid !== fileCid);
+            inplaceFilter(this.walState.fileOperations, (op) => op.cid !== fileCid);
           }, `fileOperation with cid=${fileCid.toString()}`);
         },
         { concurrency: concurrencyLimit }
@@ -2026,6 +2469,9 @@ var WALStoreImpl = class extends BaseStoreImpl {
       if (operations.length) {
         const lastOp = operations[operations.length - 1];
         await retryableUpload(async () => {
+          if (!this.loader) {
+            return;
+          }
           await this.loader.remoteMetaStore?.save(lastOp);
         }, `remoteMetaStore save with dbMeta.cars=${lastOp.cars.toString()}`);
       }
@@ -2038,251 +2484,715 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
   async load() {
     this.logger.Debug().Msg("loading");
-    const filepath = await this.gateway.buildUrl(this.url(), "main");
+    const filepath = await this.gateway.buildUrl(this.sthis, this.url(), "main", this.loader);
     if (filepath.isErr()) {
       throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
     }
-    const bytes = await this.gateway.get(filepath.Ok());
+    const bytes = await this.gateway.get(this.sthis, filepath.Ok(), this.loader);
     if (bytes.isErr()) {
       if (isNotFoundError(bytes)) {
         return void 0;
       }
       throw this.logger.Error().Err(bytes.Err()).Msg("error get").AsError();
     }
-    try {
-      return bytes && parse2(this.sthis.txt.decode(bytes.Ok()));
-    } catch (e) {
-      throw this.logger.Error().Err(e).Msg("error parse").AsError();
+    if (bytes.Ok().type !== "wal") {
+      throw this.logger.Error().Str("type", bytes.Ok().type).Msg("unexpected type").AsError();
+    }
+    return bytes.Ok().payload;
+  }
+  async save(state) {
+    const filepath = await this.gateway.buildUrl(this.sthis, this.url(), "main", this.loader);
+    if (filepath.isErr()) {
+      throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
+    }
+    const res = await this.gateway.put(
+      this.sthis,
+      filepath.Ok(),
+      {
+        type: "wal",
+        payload: state
+      },
+      this.loader
+    );
+    if (res.isErr()) {
+      throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
+    }
+  }
+  async close() {
+    await this.gateway.close(this.sthis, this.url(), this.loader);
+    this._onClosed.forEach((fn) => fn());
+    return Result5.Ok(void 0);
+  }
+  destroy() {
+    this.logger.Debug().Msg("destroy");
+    return this.gateway.destroy(this.sthis, this.url(), this.loader);
+  }
+};
+
+// src/blockstore/register-store-protocol.ts
+import { BuildURI, runtimeFn as runtimeFn4 } from "@adviser/cement";
+
+// src/runtime/gateways/file/version.ts
+var FILESTORE_VERSION = "v0.19-file";
+
+// src/runtime/gateways/memory/gateway.ts
+import { Result as Result6 } from "@adviser/cement";
+
+// src/runtime/gateways/memory/version.ts
+var MEMORY_VERSION = "v0.19-memory";
+
+// src/runtime/gateways/memory/gateway.ts
+var MemoryGateway = class {
+  constructor(sthis, memorys) {
+    this.memorys = memorys;
+    this.sthis = sthis;
+  }
+  buildUrl(baseUrl, key) {
+    return Promise.resolve(Result6.Ok(baseUrl.build().setParam("key" /* KEY */, key).URI()));
+  }
+  start(baseUrl) {
+    return Promise.resolve(Result6.Ok(baseUrl.build().setParam("version" /* VERSION */, MEMORY_VERSION).URI()));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  close(baseUrl) {
+    return Promise.resolve(Result6.Ok(void 0));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  destroy(baseUrl) {
+    this.memorys.clear();
+    return Promise.resolve(Result6.Ok(void 0));
+  }
+  async put(url, bytes) {
+    this.memorys.set(url.toString(), bytes);
+    return Result6.Ok(void 0);
+  }
+  // get could return a NotFoundError if the key is not found
+  get(url) {
+    const x = this.memorys.get(url.toString());
+    if (!x) {
+      return Promise.resolve(Result6.Err(new NotFoundError("not found")));
+    }
+    return Promise.resolve(Result6.Ok(x));
+  }
+  delete(url) {
+    this.memorys.delete(url.toString());
+    return Promise.resolve(Result6.Ok(void 0));
+  }
+  async getPlain(url, key) {
+    const x = this.memorys.get(url.build().setParam("key" /* KEY */, key).toString());
+    if (!x) {
+      return Result6.Err(new NotFoundError("not found"));
     }
+    return Result6.Ok(x);
+  }
+};
+
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  FILESTORE_VERSION: () => FILESTORE_VERSION,
+  INDEXDB_VERSION: () => INDEXDB_VERSION,
+  KeyBag: () => KeyBag,
+  defaultKeyBagOpts: () => defaultKeyBagOpts,
+  defaultKeyBagUrl: () => defaultKeyBagUrl,
+  files: () => files_exports,
+  getFileName: () => getFileName,
+  getKeyBag: () => getKeyBag,
+  getPath: () => getPath,
+  gw: () => gateways_exports,
+  kb: () => key_bag_exports,
+  kc: () => keyed_crypto_exports,
+  mf: () => wait_pr_multiformats_exports,
+  registerKeyBagProviderFactory: () => registerKeyBagProviderFactory,
+  runtimeFn: () => runtimeFn3
+});
+
+// src/runtime/gateways/file/utils.ts
+import { getStore as getStore2 } from "@fireproof/core";
+function getPath(url, sthis) {
+  const basePath = url.pathname;
+  const name = url.getParam("name");
+  if (name) {
+    return sthis.pathOps.join(basePath, name);
+  }
+  return sthis.pathOps.join(basePath);
+}
+function getFileName(url, sthis) {
+  const key = url.getParam("key");
+  if (!key) throw sthis.logger.Error().Url(url).Msg(`key not found`).AsError();
+  const res = getStore2(url, sthis, (...a) => a.join("-"));
+  switch (res.store) {
+    case "data":
+      return sthis.pathOps.join(res.name, key + ".car");
+    case "wal":
+    case "meta":
+      return sthis.pathOps.join(res.name, key + ".json");
+    default:
+      throw sthis.logger.Error().Url(url).Msg(`unsupported store type`).AsError();
+  }
+}
+
+// src/runtime/wait-pr-multiformats/index.ts
+var wait_pr_multiformats_exports = {};
+__export(wait_pr_multiformats_exports, {
+  block: () => block_exports,
+  codec: () => codec_interface_exports
+});
+
+// src/runtime/wait-pr-multiformats/codec-interface.ts
+var codec_interface_exports = {};
+
+// src/runtime/index.ts
+import { runtimeFn as runtimeFn3 } from "@adviser/cement";
+
+// src/runtime/gateways/index.ts
+var gateways_exports = {};
+__export(gateways_exports, {
+  file: () => file_exports,
+  fpDeserialize: () => fpDeserialize,
+  fpSerialize: () => fpSerialize
+});
+
+// src/runtime/gateways/fp-envelope-serialize.ts
+import { exception2Result as exception2Result2, Result as Result7 } from "@adviser/cement";
+import { decodeEventBlock, EventBlock as EventBlock2 } from "@fireproof/vendor/@web3-storage/pail/clock";
+import { base64pad } from "multiformats/bases/base64";
+import { CID as CID2 } from "multiformats";
+import { fromJSON } from "multiformats/link";
+import { format as format2, parse } from "@fireproof/vendor/@ipld/dag-json";
+async function dbMetaEvent2Serialized(sthis, dbEvents) {
+  return await Promise.all(
+    dbEvents.map(async (dbEvent) => {
+      const event = await EventBlock2.create(
+        {
+          dbMeta: sthis.txt.encode(format2(dbEvent.dbMeta))
+        },
+        dbEvent.parents
+      );
+      return {
+        cid: event.cid.toString(),
+        parents: dbEvent.parents.map((i) => i.toString()),
+        data: base64pad.encode(event.bytes)
+      };
+    })
+  );
+}
+function WALState2Serialized(sthis, wal) {
+  const serializedWAL = {
+    fileOperations: wal.fileOperations.map((fop) => ({
+      cid: fop.cid.toString(),
+      public: fop.public
+    })),
+    noLoaderOps: wal.noLoaderOps.map((nop) => ({
+      cars: nop.cars.map((i) => i.toString())
+    })),
+    operations: wal.operations.map((op) => ({
+      cars: op.cars.map((i) => i.toString())
+    }))
+  };
+  return serializedWAL;
+}
+var defaultEncoder = {
+  car: async (sthis, payload) => Result7.Ok(payload),
+  file: async (sthis, payload) => Result7.Ok(payload),
+  meta: async (sthis, payload) => Result7.Ok(sthis.txt.encode(JSON.stringify(payload))),
+  wal: async (sthis, payload) => Result7.Ok(sthis.txt.encode(JSON.stringify(payload)))
+};
+async function fpSerialize(sthis, env, pencoder) {
+  const encoder = {
+    ...defaultEncoder,
+    ...pencoder
+  };
+  switch (env.type) {
+    case "file" /* FILE */:
+      return encoder.file(sthis, env.payload);
+    case "car" /* CAR */:
+      return encoder.car(sthis, env.payload);
+    case "wal" /* WAL */:
+      return encoder.wal(sthis, WALState2Serialized(sthis, env.payload));
+    case "meta" /* META */:
+      return encoder.meta(sthis, await dbMetaEvent2Serialized(sthis, env.payload));
+    default:
+      throw sthis.logger.Error().Str("type", env.type).Msg("unsupported store").AsError();
+  }
+}
+async function decode2DbMetaEvents(sthis, rserializedMeta) {
+  if (rserializedMeta.isErr()) {
+    return Result7.Err(rserializedMeta.Err());
+  }
+  const serializedMeta = rserializedMeta.unwrap();
+  if (!Array.isArray(serializedMeta)) {
+    return sthis.logger.Debug().Any("metaEntries", serializedMeta).Msg("No data in MetaEntries").ResultError();
+  }
+  if (!serializedMeta.length) {
+    return sthis.logger.Debug().Msg("No MetaEntries found").ResultError();
+  }
+  return Result7.Ok(
+    await Promise.all(
+      serializedMeta.map(async (metaEntry) => {
+        const eventBlock = await decodeEventBlock(base64pad.decode(metaEntry.data));
+        const dbMeta = parse(sthis.txt.decode(eventBlock.value.data.dbMeta));
+        return {
+          eventCid: eventBlock.cid,
+          parents: metaEntry.parents.map((i) => CID2.parse(i)),
+          dbMeta
+        };
+      })
+    )
+  );
+}
+function toCid(sthis, link) {
+  if (typeof link === "string") {
+    return CID2.parse(link);
+  }
+  return fromJSON(link);
+}
+async function decode2WalState(sthis, rserializedWAL) {
+  if (rserializedWAL.isErr()) {
+    return Result7.Err(rserializedWAL.Err());
+  }
+  const serializedWAL = rserializedWAL.unwrap();
+  return Result7.Ok({
+    fileOperations: (serializedWAL.fileOperations || []).map((fop) => ({
+      cid: toCid(sthis, fop.cid),
+      public: !!fop.public
+    })),
+    noLoaderOps: (serializedWAL.noLoaderOps || []).map((nop) => ({
+      cars: (nop.cars || []).map((i) => toCid(sthis, i))
+    })),
+    operations: (serializedWAL.operations || []).map((op) => ({
+      cars: (op.cars || []).map((i) => toCid(sthis, i))
+    }))
+  });
+}
+var defaultDecoder = {
+  car: async (sthis, payload) => Result7.Ok(payload),
+  file: async (sthis, payload) => Result7.Ok(payload),
+  meta: async (sthis, payload) => exception2Result2(() => JSON.parse(sthis.txt.decode(payload))),
+  wal: async (sthis, payload) => exception2Result2(() => JSON.parse(sthis.txt.decode(payload)))
+};
+function makeFPEnvelope(type, payload) {
+  if (payload.isErr()) {
+    return Result7.Err(payload.Err());
+  }
+  return Result7.Ok({
+    type,
+    payload: payload.unwrap()
+  });
+}
+async function fpDeserialize(sthis, url, intoRaw, pdecoder) {
+  const rraw = await coercePromiseIntoUint8(intoRaw);
+  if (rraw.isErr()) {
+    return Result7.Err(rraw.Err());
+  }
+  const raw2 = rraw.unwrap();
+  const decoder = {
+    ...defaultDecoder,
+    ...pdecoder
+  };
+  switch (url.getParam("store" /* STORE */)) {
+    case "data":
+      if (url.getParam("suffix" /* SUFFIX */) === ".car") {
+        return makeFPEnvelope("car" /* CAR */, await decoder.car(sthis, raw2));
+      }
+      return makeFPEnvelope("file" /* FILE */, await decoder.file(sthis, raw2));
+    case "wal":
+      return makeFPEnvelope("wal" /* WAL */, await decode2WalState(sthis, await decoder.wal(sthis, raw2)));
+    case "meta":
+      return makeFPEnvelope("meta" /* META */, await decode2DbMetaEvents(sthis, await decoder.meta(sthis, raw2)));
+    default:
+      return sthis.logger.Error().Str("store", url.getParam("store" /* STORE */)).Msg("unsupported store").ResultError();
+  }
+}
+
+// src/runtime/gateways/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  KeyBagProviderFile: () => KeyBagProviderFile,
+  sysFileSystemFactory: () => sysFileSystemFactory
+});
+
+// src/runtime/gateways/indexdb/version.ts
+var INDEXDB_VERSION = "v0.19-indexdb";
+
+// src/runtime/gateways/file/gateway-impl.ts
+import { exception2Result as exception2Result3, KeyedResolvOnce as KeyedResolvOnce2, Result as Result8 } from "@adviser/cement";
+var versionFiles = new KeyedResolvOnce2();
+var FileGateway = class {
+  constructor(sthis, fs) {
+    this.fs = fs;
+  }
+  async getVersionFromFile(path, sthis) {
+    return versionFiles.get(path).once(async () => {
+      await this.fs.mkdir(path, { recursive: true });
+      const vFile = sthis.pathOps.join(path, "version");
+      const vFileStat = await this.fs.stat(vFile).catch(() => void 0);
+      if (!vFileStat) {
+        await this.fs.writefile(sthis.pathOps.join(path, "version"), FILESTORE_VERSION);
+        return FILESTORE_VERSION;
+      } else if (!vFileStat.isFile()) {
+        throw sthis.logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
+      }
+      const v = await this.fs.readfile(vFile);
+      const vStr = sthis.txt.decode(v);
+      if (vStr !== FILESTORE_VERSION) {
+        sthis.logger.Warn().Str("file", vFile).Str("from", vStr).Str("expected", FILESTORE_VERSION).Msg(`version mismatch`);
+      }
+      return vStr;
+    });
+  }
+  start(baseURL, sthis) {
+    return exception2Result3(async () => {
+      await this.fs.start();
+      const url = baseURL.build();
+      url.defParam("version" /* VERSION */, FILESTORE_VERSION);
+      const dbUrl = await this.buildUrl(url.URI(), "dummy");
+      const dbdirFile = this.getFilePath(dbUrl.Ok(), sthis);
+      await this.fs.mkdir(sthis.pathOps.dirname(dbdirFile), { recursive: true });
+      const dbroot = sthis.pathOps.dirname(dbdirFile);
+      sthis.logger.Debug().Url(url.URI()).Str("dbroot", dbroot).Msg("start");
+      url.setParam("version" /* VERSION */, await this.getVersionFromFile(dbroot, sthis));
+      return url.URI();
+    });
+  }
+  async buildUrl(baseUrl, key) {
+    return Result8.Ok(baseUrl.build().setParam("key" /* KEY */, key).URI());
+  }
+  async close() {
+    return Result8.Ok(void 0);
+  }
+  getFilePath(url, sthis) {
+    const key = url.getParam("key" /* KEY */);
+    if (!key) throw sthis.logger.Error().Url(url).Msg(`key not found`).AsError();
+    return sthis.pathOps.join(getPath(url, sthis), getFileName(url, sthis));
+  }
+  async put(url, bytes, sthis) {
+    return exception2Result3(async () => {
+      const file = await this.getFilePath(url, sthis);
+      sthis.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
+      await this.fs.writefile(file, bytes);
+    });
+  }
+  async get(url, sthis) {
+    return exceptionWrapper(async () => {
+      const file = this.getFilePath(url, sthis);
+      try {
+        sthis.logger.Debug().Url(url).Str("file", file).Msg("get");
+        const res = await this.fs.readfile(file);
+        return Result8.Ok(res);
+      } catch (e) {
+        if (isNotFoundError(e)) {
+          return Result8.Err(new NotFoundError(`file not found: ${file}`));
+        }
+        return Result8.Err(e);
+      }
+    });
   }
-  async save(state) {
-    const filepath = await this.gateway.buildUrl(this.url(), "main");
-    if (filepath.isErr()) {
-      throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
-    }
-    let encoded;
+  async delete(url, sthis) {
+    return exception2Result3(async () => {
+      await this.fs.unlink(this.getFilePath(url, sthis));
+    });
+  }
+  async destroy(baseURL, sthis) {
+    const url = await this.buildUrl(baseURL, "x");
+    if (url.isErr()) return url;
+    const filepath = sthis.pathOps.dirname(this.getFilePath(url.Ok(), sthis));
+    let files = [];
     try {
-      encoded = format2(state);
+      files = await this.fs.readdir(filepath);
     } catch (e) {
-      throw this.logger.Error().Err(e).Any("state", state).Msg("error format").AsError();
+      if (!isNotFoundError(e)) {
+        throw sthis.logger.Error().Err(e).Str("dir", filepath).Msg("destroy:readdir").AsError();
+      }
     }
-    const res = await this.gateway.put(filepath.Ok(), this.sthis.txt.encode(encoded));
-    if (res.isErr()) {
-      throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
+    for (const file of files) {
+      const pathed = sthis.pathOps.join(filepath, file);
+      try {
+        await this.fs.unlink(pathed);
+      } catch (e) {
+        if (!isNotFoundError(e)) {
+          throw sthis.logger.Error().Err(e).Str("file", pathed).Msg("destroy:unlink").AsError();
+        }
+      }
     }
+    return Result8.Ok(void 0);
   }
-  async close() {
-    await this.gateway.close(this.url());
-    this._onClosed.forEach((fn) => fn());
-    return Result5.Ok(void 0);
-  }
-  destroy() {
-    return this.gateway.destroy(this.url());
+  async getPlain(iurl, key, sthis) {
+    const url = iurl.build().setParam("key" /* KEY */, key).URI();
+    const dbFile = sthis.pathOps.join(getPath(url, sthis), getFileName(url, sthis));
+    sthis.logger.Debug().Url(url).Str("dbFile", dbFile).Msg("get");
+    const buffer = await this.fs.readfile(dbFile);
+    sthis.logger.Debug().Url(url).Str("dbFile", dbFile).Len(buffer).Msg("got");
+    return Result8.Ok(buffer);
   }
 };
 
-// src/blockstore/store-factory.ts
-function ensureIsIndex(url, isIndex) {
-  if (isIndex) {
-    return url.build().setParam("index", isIndex).URI();
+// src/runtime/gateways/def-serde-gateway.ts
+import { Result as Result9 } from "@adviser/cement";
+var DefSerdeGateway = class {
+  constructor(gw) {
+    this.gw = gw;
   }
-  return url.build().delParam("index").URI();
-}
-function ensureName(name, url) {
-  if (!url.hasParam("name")) {
-    return url.build().setParam("name", name).URI();
+  start(sthis, baseURL) {
+    return this.gw.start(baseURL, sthis);
   }
-  return url;
-}
+  async buildUrl(sthis, baseUrl, key) {
+    return this.gw.buildUrl(baseUrl, key, sthis);
+  }
+  async close(sthis, uri) {
+    return this.gw.close(uri, sthis);
+  }
+  async put(sthis, url, env) {
+    const rUint8 = await fpSerialize(sthis, env);
+    if (rUint8.isErr()) return rUint8;
+    return this.gw.put(url, rUint8.Ok(), sthis);
+  }
+  async get(sthis, url) {
+    const res = await this.gw.get(url, sthis);
+    if (res.isErr()) return Result9.Err(res.Err());
+    return fpDeserialize(sthis, url, res);
+  }
+  async delete(sthis, url) {
+    return this.gw.delete(url, sthis);
+  }
+  async destroy(sthis, baseURL) {
+    return this.gw.destroy(baseURL, sthis);
+  }
+  async getPlain(sthis, iurl, key) {
+    return this.gw.getPlain(iurl, key, sthis);
+  }
+};
+
+// src/blockstore/register-store-protocol.ts
 var storeFactory = /* @__PURE__ */ new Map();
-function buildURL(optURL, loader) {
-  const storeOpts = loader.ebOpts.store;
-  const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
-  let obuUrl;
-  if (obuItem && obuItem.overrideBaseURL) {
-    obuUrl = URI5.from(obuItem.overrideBaseURL);
-  }
-  const ret = ensureIsIndex(
-    URI5.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
-    storeOpts.isIndex
-  );
-  return ret;
-}
-var onceGateway = new KeyedResolvOnce2();
-async function getGatewayFromURL(url, sthis) {
-  return onceGateway.get(url.toString()).once(async () => {
-    const item = storeFactory.get(url.protocol);
-    if (item) {
-      const ret = {
-        gateway: await item.gateway(sthis),
-        test: await item.test(sthis)
-      };
-      const res = await ret.gateway.start(url);
-      if (res.isErr()) {
-        sthis.logger.Error().Result("start", res).Msg("start failed");
-        return void 0;
-      }
-      return ret;
+function getDefaultURI(sthis, protocol) {
+  if (protocol) {
+    if (!protocol.endsWith(":")) {
+      protocol += ":";
     }
-    sthis.logger.Warn().Url(url).Msg("unsupported protocol");
-    return void 0;
-  });
+    const gfi = storeFactory.get(protocol);
+    if (gfi) {
+      return gfi.defaultURI(sthis);
+    }
+  }
+  const found = Array.from(storeFactory.values()).find((item) => item.isDefault);
+  if (!found) {
+    throw sthis.logger.Error().Msg("no default found").AsError();
+  }
+  return found.defaultURI(sthis);
 }
 function registerStoreProtocol(item) {
   let protocol = item.protocol;
   if (!protocol.endsWith(":")) {
     protocol += ":";
   }
-  if (storeFactory.has(protocol)) {
-    if (!item.overrideBaseURL && storeFactory.get(protocol) !== item) {
-      throw new Error(`we need a logger here`);
-      return () => {
-      };
-    }
+  if (!item.serdegateway && !item.gateway) {
+    throw new Error(`registerStoreProtocol needs a gateway or serdegateway`);
   }
-  if (item.overrideBaseURL) {
+  let serdegateway;
+  if (item.gateway) {
+    serdegateway = async (sthis) => {
+      const m = await item.gateway(sthis);
+      return new DefSerdeGateway(m);
+    };
+  } else {
+    serdegateway = item.serdegateway;
+  }
+  if (item.isDefault) {
     Array.from(storeFactory.values()).forEach((items) => {
-      items.overrideBaseURL = void 0;
+      items.isDefault = false;
     });
   }
-  storeFactory.set(protocol, item);
+  storeFactory.set(protocol, {
+    ...item,
+    serdegateway
+  });
   return () => {
     storeFactory.delete(protocol);
   };
 }
-var onceDataStoreFactory = new KeyedResolvOnce2();
-async function dataStoreFactory(loader) {
-  const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.data, loader)).build().setParam("store", "data").URI();
-  const sthis = ensureSuperLog(loader.sthis, "dataStoreFactory", { url: url.toString() });
-  return onceDataStoreFactory.get(url.toString()).once(async () => {
-    const gateway = await getGatewayFromURL(url, sthis);
-    if (!gateway) {
-      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
+function getGatewayFactoryItem(protocol) {
+  return storeFactory.get(protocol);
+}
+function defaultGatewayFactoryItem() {
+  const found = Array.from(storeFactory.values()).find((item) => item.isDefault);
+  if (!found) {
+    throw new Error("no default found");
+  }
+  return found;
+}
+function defaultURI(sthis) {
+  const rt = runtimeFn4();
+  return BuildURI.from("file://").pathname(`${sthis.env.get("HOME")}/.fireproof/${FILESTORE_VERSION.replace(/-.*$/, "")}`).setParam("version" /* VERSION */, FILESTORE_VERSION).setParam("urlGen" /* URL_GEN */, "default").setParam("runtime" /* RUNTIME */, rt.isNodeIsh ? "node" : rt.isDeno ? "deno" : "unknown").URI();
+}
+if (runtimeFn4().isNodeIsh || runtimeFn4().isDeno) {
+  registerStoreProtocol({
+    protocol: "file:",
+    isDefault: true,
+    defaultURI,
+    gateway: async (sthis) => {
+      return new FileGateway(sthis, await sysFileSystemFactory(defaultURI(sthis)));
     }
-    const store = new DataStoreImpl(sthis, loader.name, url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, {
-        ...loader.ebOpts.keyBag
-      })
-    });
-    return store;
   });
 }
-var onceMetaStoreFactory = new KeyedResolvOnce2();
-async function metaStoreFactory(loader) {
-  const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.meta, loader)).build().setParam("store", "meta").URI();
-  const sthis = ensureSuperLog(loader.sthis, "metaStoreFactory", { url: () => url.toString() });
-  return onceMetaStoreFactory.get(url.toString()).once(async () => {
-    sthis.logger.Debug().Str("protocol", url.protocol).Msg("pre-protocol switch");
-    const gateway = await getGatewayFromURL(url, sthis);
-    if (!gateway) {
-      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-    }
-    const store = new MetaStoreImpl(loader.sthis, loader.name, url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, {
-        ...loader.ebOpts.keyBag
-      })
-    });
-    return store;
+if (runtimeFn4().isBrowser) {
+  registerStoreProtocol({
+    protocol: "indexdb:",
+    isDefault: true,
+    defaultURI: () => {
+      return BuildURI.from("indexdb://").pathname("fp").setParam("version" /* VERSION */, INDEXDB_VERSION).setParam("runtime" /* RUNTIME */, "browser").URI();
+    },
+    gateway: async () => {
+      const { GatewayImpl } = await import("@fireproof/core/web");
+      return new GatewayImpl();
+    }
   });
 }
-var onceRemoteWalFactory = new KeyedResolvOnce2();
-async function remoteWalFactory(loader) {
-  const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.wal, loader)).build().setParam("store", "wal").URI();
-  const sthis = ensureSuperLog(loader.sthis, "remoteWalFactory", { url: url.toString() });
-  return onceRemoteWalFactory.get(url.toString()).once(async () => {
-    const gateway = await getGatewayFromURL(url, sthis);
-    if (!gateway) {
-      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-    }
-    sthis.logger.Debug().Str("prepared", url.toString()).Msg("produced");
-    const store = new WALStoreImpl(loader, url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, {
-        ...loader.ebOpts.keyBag
-      })
-    });
-    return store;
+var memory = /* @__PURE__ */ new Map();
+registerStoreProtocol({
+  protocol: "memory:",
+  isDefault: false,
+  defaultURI: () => {
+    return BuildURI.from("memory://").pathname("ram").URI();
+  },
+  gateway: async (sthis) => {
+    return new MemoryGateway(sthis, memory);
+  }
+});
+
+// src/blockstore/store-factory.ts
+var onceGateway = new KeyedResolvOnce3();
+var gatewayInstances = new KeyedResolvOnce3();
+async function getStartedGateway(sthis, url) {
+  return onceGateway.get(url.toString()).once(async () => {
+    const item = getGatewayFactoryItem(url.protocol);
+    if (item) {
+      const ret = {
+        url,
+        ...await gatewayInstances.get(url.protocol).once(async () => ({})),
+        gateway: await item.serdegateway(sthis)
+      };
+      const res = await ret.gateway.start(sthis, url);
+      if (res.isErr()) {
+        return Result10.Err(sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
+      }
+      ret.url = res.Ok();
+      return Result10.Ok(ret);
+    }
+    return Result10.Err(sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
   });
 }
-async function testStoreFactory(url, sthis) {
-  sthis = ensureSuperLog(sthis, "testStoreFactory");
-  const gateway = await getGatewayFromURL(url, sthis);
-  if (!gateway) {
-    throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-  }
-  return gateway.test;
+async function dataStoreFactory(sfi) {
+  const storeUrl = sfi.url.build().setParam("store" /* STORE */, "data").URI();
+  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  if (rgateway.isErr()) {
+    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+  }
+  const gateway = rgateway.Ok();
+  const store = new DataStoreImpl(sfi.sthis, gateway.url, {
+    gateway: gateway.gateway,
+    gatewayInterceptor: sfi.gatewayInterceptor,
+    loader: sfi.loader
+  });
+  return store;
+}
+async function metaStoreFactory(sfi) {
+  const storeUrl = sfi.url.build().setParam("store" /* STORE */, "meta").URI();
+  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  if (rgateway.isErr()) {
+    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+  }
+  const gateway = rgateway.Ok();
+  const store = new MetaStoreImpl(sfi.sthis, gateway.url, {
+    gateway: gateway.gateway,
+    gatewayInterceptor: sfi.gatewayInterceptor,
+    loader: sfi.loader
+  });
+  return store;
+}
+async function WALStoreFactory(sfi) {
+  const storeUrl = sfi.url.build().setParam("store" /* STORE */, "wal").URI();
+  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  if (rgateway.isErr()) {
+    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+  }
+  const gateway = rgateway.Ok();
+  const store = new WALStoreImpl(sfi.sthis, gateway.url, {
+    gateway: gateway.gateway,
+    gatewayInterceptor: sfi.gatewayInterceptor,
+    loader: sfi.loader
+  });
+  return store;
 }
-async function ensureStart(store, logger) {
+async function ensureStart(store) {
   const ret = await store.start();
   if (ret.isErr()) {
-    throw logger.Error().Result("start", ret).Msg("start failed").AsError();
+    throw store.logger.Error().Result("start", ret).Msg("start failed").AsError();
   }
-  logger.Debug().Url(ret.Ok(), "prepared").Msg("produced");
+  store.logger.Debug().Url(ret.Ok(), "prepared").Msg("produced");
   return store;
 }
-function toStoreRuntime(opts, sthis) {
-  const logger = ensureLogger(sthis, "toStoreRuntime", {});
+function ensureStoreEnDeFile(ende) {
+  ende = ende || {};
   return {
-    makeMetaStore: async (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeMetaStore).Msg("makeMetaStore");
-      return ensureStart(await (loader.ebOpts.store.makeMetaStore || metaStoreFactory)(loader), logger);
-    },
-    makeDataStore: async (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeDataStore).Msg("makeDataStore");
-      return ensureStart(await (loader.ebOpts.store.makeDataStore || dataStoreFactory)(loader), logger);
-    },
-    makeWALStore: async (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeWALStore).Msg("makeRemoteWAL");
-      return ensureStart(await (loader.ebOpts.store.makeWALStore || remoteWalFactory)(loader), logger);
-    },
-    encodeFile: opts.encodeFile || encodeFile,
-    decodeFile: opts.decodeFile || decodeFile
+    encodeFile: ende.encodeFile || encodeFile,
+    decodeFile: ende.decodeFile || decodeFile
+  };
+}
+function toStoreRuntime(sthis, endeOpts = {}) {
+  return {
+    makeMetaStore: async (sfi) => ensureStart(await metaStoreFactory(sfi)),
+    // async (loader: Loadable) => {
+    //   logger
+    //     .Debug()
+    //     .Str("fromOpts", "" + !!endeOpts.func?.makeMetaStore)
+    //     .Msg("makeMetaStore");
+    //   return ensureStart(await (endeOpts.func?.makeMetaStore || metaStoreFactory)(loader), logger);
+    // },
+    makeDataStore: async (sfi) => ensureStart(await dataStoreFactory(sfi)),
+    // async (loader: Loadable) => {
+    //   logger
+    //     .Debug()
+    //     .Str("fromOpts", "" + !!endeOpts.func?.makeDataStore)
+    //     .Msg("makeDataStore");
+    //   return ensureStart(await (endeOpts.func?.makeDataStore || dataStoreFactory)(loader), logger);
+    // },
+    makeWALStore: async (sfi) => ensureStart(await WALStoreFactory(sfi)),
+    // async (loader: Loadable) => {
+    //   logger
+    //     .Debug()
+    //     .Str("fromOpts", "" + !!endeOpts.func?.makeWALStore)
+    //     .Msg("makeRemoteWAL");
+    //   return ensureStart(await (endeOpts.func?.makeWALStore || remoteWalFactory)(loader), logger);
+    // },
+    ...ensureStoreEnDeFile(endeOpts)
   };
 }
-registerStoreProtocol({
-  protocol: "file:",
-  gateway: async (sthis) => {
-    const { FileGateway } = await import("./gateway-VVS4QWDA.js");
-    return new FileGateway(sthis);
-  },
-  test: async (sthis) => {
-    const { FileTestStore } = await import("./gateway-VVS4QWDA.js");
-    return new FileTestStore(sthis);
-  }
-});
-registerStoreProtocol({
-  protocol: "indexdb:",
-  gateway: async (sthis) => {
-    const { IndexDBGateway } = await import("./gateway-C62S56GY.js");
-    return new IndexDBGateway(sthis);
-  },
-  test: async (sthis) => {
-    const { IndexDBTestStore } = await import("./gateway-C62S56GY.js");
-    return new IndexDBTestStore(sthis);
-  }
-});
 
 // src/blockstore/store-remote.ts
-async function RemoteDataStore(sthis, name, url, opts) {
-  const ds = new DataStoreImpl(sthis, name, url, opts);
+async function RemoteDataStore(sthis, url, opts) {
+  const ds = new DataStoreImpl(sthis, url, opts);
   await ds.start();
   return ds;
 }
-async function RemoteMetaStore(sthis, name, url, opts) {
-  const ms = new MetaStoreImpl(
-    sthis,
-    name,
-    url,
-    opts
-    /* , true*/
-  );
+async function RemoteMetaStore(sthis, url, opts) {
+  const ms = new MetaStoreImpl(sthis, url, opts);
   await ms.start();
   return ms;
 }
 
 // src/blockstore/connection-base.ts
+function coerceLoader(ref) {
+  const refl = ref;
+  if (refl.loader) {
+    return refl.loader;
+  }
+  const refb = ref;
+  if (refb.blockstore) {
+    return coerceLoader(refb.blockstore);
+  }
+  return void 0;
+}
 var ConnectionBase = class {
   constructor(url, logger) {
     this.loaded = Promise.resolve();
@@ -2293,23 +3203,26 @@ var ConnectionBase = class {
     await throwFalsy(throwFalsy(this.loader).remoteMetaStore).load();
     await (await throwFalsy(this.loader).WALStore()).process();
   }
-  async connect_X({ loader }) {
-    if (!loader) throw this.logger.Error().Msg("loader is required").AsError();
-    await this.connectMeta_X({ loader });
-    await this.connectStorage_X({ loader });
+  async connect(refl) {
+    await this.connectMeta(refl);
+    await this.connectStorage(refl);
   }
-  async connectMeta_X({ loader }) {
-    if (!loader) throw this.logger.Error().Msg("connectMeta_X: loader is required").AsError();
+  async connectMeta(refl) {
+    const loader = coerceLoader(refl);
+    if (!loader) throw this.logger.Error().Msg("connectMeta: loader is required").AsError();
     this.loader = loader;
     await this.onConnect();
-    const metaUrl = this.url.build().defParam("store", "meta").URI();
-    const gateway = await getGatewayFromURL(metaUrl, this.loader.sthis);
-    if (!gateway) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: gateway is required").AsError();
-    const dbName = metaUrl.getParam("name");
-    if (!dbName) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: name is required").AsError();
-    const remote = await RemoteMetaStore(loader.sthis, dbName, metaUrl, {
+    const metaUrl = this.url.build().defParam("store" /* STORE */, "meta").URI();
+    const rgateway = await getStartedGateway(loader.sthis, metaUrl);
+    if (rgateway.isErr())
+      throw this.logger.Error().Result("err", rgateway).Url(metaUrl).Msg("connectMeta: gateway is required").AsError();
+    const dbName = metaUrl.getParam("name" /* NAME */);
+    if (!dbName) {
+      throw this.logger.Error().Url(metaUrl).Msg("connectMeta: dbName is required").AsError();
+    }
+    const gateway = rgateway.Ok();
+    const remote = await RemoteMetaStore(loader.sthis, metaUrl, {
       gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, loader.ebOpts.keyBag),
       loader
     });
     this.loader.remoteMetaStore = remote;
@@ -2319,17 +3232,19 @@ var ConnectionBase = class {
       });
     });
   }
-  async connectStorage_X({ loader }) {
+  async connectStorage(refl) {
+    const loader = coerceLoader(refl);
     if (!loader) throw this.logger.Error().Msg("connectStorage_X: loader is required").AsError();
     this.loader = loader;
-    const dataUrl = this.url.build().defParam("store", "data").URI();
-    const gateway = await getGatewayFromURL(dataUrl, this.loader.sthis);
-    if (!gateway) throw this.logger.Error().Url(dataUrl).Msg("connectStorage_X: gateway is required").AsError();
-    const name = dataUrl.getParam("name");
+    const dataUrl = this.url.build().defParam("store" /* STORE */, "data").URI();
+    const rgateway = await getStartedGateway(loader.sthis, dataUrl);
+    if (rgateway.isErr())
+      throw this.logger.Error().Result("err", rgateway).Url(dataUrl).Msg("connectStorage_X: gateway is required").AsError();
+    const name = dataUrl.getParam("name" /* NAME */);
     if (!name) throw this.logger.Error().Url(dataUrl).Msg("connectStorage_X: name is required").AsError;
-    loader.remoteCarStore = await RemoteDataStore(loader.sthis, name, this.url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, this.loader?.ebOpts.keyBag)
+    loader.remoteCarStore = await RemoteDataStore(loader.sthis, this.url, {
+      gateway: rgateway.Ok().gateway,
+      loader
     });
     loader.remoteFileStore = loader.remoteCarStore;
   }
@@ -2341,9 +3256,9 @@ var ConnectionBase = class {
   //   //   await this.compact()
   //   // }
   //   const currents = await this.loader?.metaStore?.load()
-  //   if (!currents) throw new Error("Can't sync empty database: save data first")
+  //   if (!currents) throw new Error("Can't sync empty ledger: save data first")
   //   if (currents.length > 1)
-  //     throw new Error("Can't sync database with split heads: make an update first")
+  //     throw new Error("Can't sync ledger with split heads: make an update first")
   //   const current = currents[0]
   //   const params = {
   //     car: current.car.toString()
@@ -2369,6 +3284,12 @@ var ConnectionBase = class {
 };
 
 // src/crdt-helpers.ts
+import { parse as parse2 } from "multiformats/link";
+import { sha256 as hasher5 } from "multiformats/hashes/sha2";
+import * as codec from "@fireproof/vendor/@ipld/dag-cbor";
+import { put, get, entries, root } from "@fireproof/vendor/@web3-storage/pail/crdt";
+import { EventFetcher, vis } from "@fireproof/vendor/@web3-storage/pail/clock";
+import * as Batch from "@fireproof/vendor/@web3-storage/pail/crdt/batch";
 function time(tag) {
 }
 function timeEnd(tag) {
@@ -2436,7 +3357,7 @@ async function processFiles(store, blocks, doc, logger) {
 }
 async function processFileset(logger, store, blocks, files) {
   const dbBlockstore = blocks.parent;
-  if (!dbBlockstore.loader) throw logger.Error().Msg("Missing loader, database name is required").AsError();
+  if (!dbBlockstore.loader) throw logger.Error().Msg("Missing loader, ledger name is required").AsError();
   const t = new CarTransaction(dbBlockstore);
   const didPut = [];
   for (const filename in files) {
@@ -2468,7 +3389,7 @@ async function processFileset(logger, store, blocks, files) {
   }
 }
 async function getValueFromCrdt(blocks, head, key, logger) {
-  if (!head.length) throw logger.Debug().Msg("Getting from an empty database").AsError();
+  if (!head.length) throw logger.Debug().Msg("Getting from an empty ledger").AsError();
   const link = await get(blocks, head, key);
   if (!link) throw logger.Error().Str("key", key).Msg(`Missing key`).AsError();
   return await getValueFromLink(blocks, link, logger);
@@ -2626,7 +3547,7 @@ async function doCompact(blockLog, head, logger) {
   isCompacting = false;
 }
 async function getBlock(blocks, cidString) {
-  const block = await blocks.get(parse3(cidString));
+  const block = await blocks.get(parse2(cidString));
   if (!block) throw new Error(`Missing block ${cidString}`);
   const { cid, value } = await decode({ bytes: block.bytes, codec, hasher: hasher5 });
   return new Block({ cid, value, bytes: block.bytes });
@@ -2686,7 +3607,8 @@ function makeProllyGetBlock(blocks) {
     return create({ cid, bytes, hasher: hasher6, codec: codec2 });
   };
 }
-async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
+async function bulkIndex(logger, tblocks, inIndex, indexEntries, opts) {
+  logger.Debug().Msg("enter bulkIndex");
   if (!indexEntries.length) return inIndex;
   if (!inIndex.root) {
     if (!inIndex.cid) {
@@ -2703,18 +3625,22 @@ async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
         returnNode = node;
       }
       if (!returnNode || !returnRootBlock) throw new Error("failed to create index");
+      logger.Debug().Msg("exit !root bulkIndex");
       return { root: returnNode, cid: returnRootBlock.cid };
     } else {
       inIndex.root = await DbIndex.load({ cid: inIndex.cid, get: makeProllyGetBlock(tblocks), ...opts });
     }
   }
+  logger.Debug().Msg("pre bulk bulkIndex");
   const { root: root3, blocks: newBlocks } = await inIndex.root.bulk(indexEntries);
   if (root3) {
+    logger.Debug().Msg("pre root put bulkIndex");
     for await (const block of newBlocks) {
       await tblocks.put(block.cid, block.bytes);
     }
     return { root: root3, cid: (await root3.block).cid };
   } else {
+    logger.Debug().Msg("pre !root bulkIndex");
     return { root: void 0, cid: void 0 };
   }
 }
@@ -2754,17 +3680,17 @@ function encodeKey(key) {
 }
 
 // src/indexer.ts
-function index(sthis, { _crdt }, name, mapFn, meta) {
-  if (mapFn && meta) throw _crdt.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
-  if (mapFn && mapFn.constructor.name !== "Function") throw _crdt.logger.Error().Msg("mapFn must be a function").AsError();
-  if (_crdt.indexers.has(name)) {
-    const idx = _crdt.indexers.get(name);
+function index(refDb, name, mapFn, meta) {
+  if (mapFn && meta) throw refDb.crdt.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
+  if (mapFn && mapFn.constructor.name !== "Function") throw refDb.crdt.logger.Error().Msg("mapFn must be a function").AsError();
+  if (refDb.crdt.indexers.has(name)) {
+    const idx = refDb.crdt.indexers.get(name);
     idx.applyMapFn(name, mapFn, meta);
   } else {
-    const idx = new Index(sthis, _crdt, name, mapFn, meta);
-    _crdt.indexers.set(name, idx);
+    const idx = new Index(refDb.crdt.sthis, refDb.crdt, name, mapFn, meta);
+    refDb.crdt.indexers.set(name, idx);
   }
-  return _crdt.indexers.get(name);
+  return refDb.crdt.indexers.get(name);
 }
 var Index = class {
   constructor(sthis, crdt, name, mapFn, meta) {
@@ -2783,18 +3709,9 @@ var Index = class {
     return Promise.all([this.blockstore.ready(), this.crdt.ready()]).then(() => {
     });
   }
-  close() {
-    return Promise.all([this.blockstore.close(), this.crdt.close()]).then(() => {
-    });
-  }
-  destroy() {
-    return Promise.all([this.blockstore.destroy(), this.crdt.destroy()]).then(() => {
-    });
-  }
   applyMapFn(name, mapFn, meta) {
     if (mapFn && meta) throw this.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
     if (this.name && this.name !== name) throw this.logger.Error().Msg("cannot change name").AsError();
-    this.name = name;
     try {
       if (meta) {
         if (this.indexHead && this.indexHead.map((c) => c.toString()).join() !== meta.head.map((c) => c.toString()).join()) {
@@ -2842,9 +3759,13 @@ var Index = class {
     }
   }
   async query(opts = {}) {
+    this.logger.Debug().Msg("enter query");
     await this.ready();
+    this.logger.Debug().Msg("post ready query");
     await this._updateIndex();
+    this.logger.Debug().Msg("post _updateIndex query");
     await this._hydrateIndex();
+    this.logger.Debug().Msg("post _hydrateIndex query");
     if (!this.byKey.root) {
       return await applyQuery(this.crdt, { result: [] }, opts);
     }
@@ -2900,13 +3821,16 @@ var Index = class {
   }
   async _updateIndex() {
     await this.ready();
+    this.logger.Debug().Msg("enter _updateIndex");
     if (this.initError) throw this.initError;
     if (!this.mapFn) throw this.logger.Error().Msg("No map function defined").AsError();
     let result, head;
     if (!this.indexHead || this.indexHead.length === 0) {
       ({ result, head } = await this.crdt.allDocs());
+      this.logger.Debug().Msg("enter crdt.allDocs");
     } else {
       ({ result, head } = await this.crdt.changes(this.indexHead));
+      this.logger.Debug().Msg("enter crdt.changes");
     }
     if (result.length === 0) {
       this.indexHead = head;
@@ -2939,9 +3863,22 @@ var Index = class {
     if (result.length === 0) {
       return indexerMeta;
     }
+    this.logger.Debug().Msg("pre this.blockstore.transaction");
     const { meta } = await this.blockstore.transaction(async (tblocks) => {
-      this.byId = await bulkIndex(tblocks, this.byId, removeIdIndexEntries.concat(byIdIndexEntries), byIdOpts);
-      this.byKey = await bulkIndex(tblocks, this.byKey, staleKeyIndexEntries.concat(indexEntries), byKeyOpts);
+      this.byId = await bulkIndex(
+        this.logger,
+        tblocks,
+        this.byId,
+        removeIdIndexEntries.concat(byIdIndexEntries),
+        byIdOpts
+      );
+      this.byKey = await bulkIndex(
+        this.logger,
+        tblocks,
+        this.byKey,
+        staleKeyIndexEntries.concat(indexEntries),
+        byKeyOpts
+      );
       this.indexHead = head;
       if (this.byId.cid && this.byKey.cid) {
         const idxMeta = {
@@ -2953,8 +3890,10 @@ var Index = class {
         };
         indexerMeta.indexes?.set(this.name, idxMeta);
       }
+      this.logger.Debug().Any("indexerMeta", new Array(indexerMeta.indexes?.entries())).Msg("exit this.blockstore.transaction fn");
       return indexerMeta;
     });
+    this.logger.Debug().Msg("post this.blockstore.transaction");
     return meta;
   }
 };
@@ -2962,7 +3901,7 @@ var Index = class {
 // src/crdt-clock.ts
 import { advance } from "@fireproof/vendor/@web3-storage/pail/clock";
 import { root as root2 } from "@fireproof/vendor/@web3-storage/pail/crdt";
-import { ResolveOnce as ResolveOnce4 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce5 } from "@adviser/cement";
 
 // src/apply-head-queue.ts
 function applyHeadQueue(worker, logger) {
@@ -3019,7 +3958,7 @@ var CRDTClock = class {
     this.zoomers = /* @__PURE__ */ new Set();
     this.watchers = /* @__PURE__ */ new Set();
     this.emptyWatchers = /* @__PURE__ */ new Set();
-    this._ready = new ResolveOnce4();
+    this._ready = new ResolveOnce5();
     this.blockstore = blockstore;
     this.logger = ensureLogger(blockstore.sthis, "CRDTClock");
     this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
@@ -3130,15 +4069,13 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 
 // src/crdt.ts
 var CRDT = class {
-  constructor(sthis, name, opts = {}) {
+  constructor(sthis, opts) {
     this.indexers = /* @__PURE__ */ new Map();
-    this.onceReady = new ResolveOnce5();
+    this.onceReady = new ResolveOnce6();
     this.sthis = sthis;
-    this.name = name;
     this.logger = ensureLogger(sthis, "CRDT");
     this.opts = opts;
-    this.blockstore = blockstoreFactory(sthis, {
-      name,
+    this.blockstore = new EncryptedBlockstore(sthis, {
       applyMeta: async (meta) => {
         const crdtMeta = meta;
         if (!crdtMeta.head) throw this.logger.Error().Msg("missing head").AsError();
@@ -3148,23 +4085,29 @@ var CRDT = class {
         await doCompact(blocks, this.clock.head, this.logger);
         return { head: this.clock.head };
       },
-      autoCompact: this.opts.autoCompact || 100,
-      store: { ...this.opts.store, isIndex: void 0 },
-      public: this.opts.public,
-      meta: this.opts.meta,
-      threshold: this.opts.threshold
+      gatewayInterceptor: opts.gatewayInterceptor,
+      // autoCompact: this.opts.autoCompact || 100,
+      storeRuntime: toStoreRuntime(this.sthis, this.opts.storeEnDe),
+      storeUrls: this.opts.storeUrls.data,
+      keyBag: this.opts.keyBag,
+      // public: this.opts.public,
+      meta: this.opts.meta
+      // threshold: this.opts.threshold,
     });
-    this.indexBlockstore = blockstoreFactory(sthis, {
-      name,
+    this.indexBlockstore = new EncryptedBlockstore(sthis, {
+      // name: opts.name,
       applyMeta: async (meta) => {
         const idxCarMeta = meta;
         if (!idxCarMeta.indexes) throw this.logger.Error().Msg("missing indexes").AsError();
-        for (const [name2, idx] of Object.entries(idxCarMeta.indexes)) {
-          index(this.sthis, { _crdt: this }, name2, void 0, idx);
+        for (const [name, idx] of Object.entries(idxCarMeta.indexes)) {
+          index({ crdt: this }, name, void 0, idx);
         }
       },
-      store: { ...this.opts.store, isIndex: this.opts.store?.isIndex || "idx" },
-      public: this.opts.public
+      gatewayInterceptor: opts.gatewayInterceptor,
+      storeRuntime: toStoreRuntime(this.sthis, this.opts.storeEnDe),
+      storeUrls: this.opts.storeUrls.idx,
+      keyBag: this.opts.keyBag
+      // public: this.opts.public,
     });
     this.clock = new CRDTClock(this.blockstore);
     this.clock.onZoom(() => {
@@ -3245,75 +4188,169 @@ var CRDT = class {
   }
 };
 
-// src/database.ts
-var Database = class {
-  constructor(name, opts) {
-    this.opts = {};
+// src/ledger.ts
+var ledgers = new KeyedResolvOnce4();
+function keyConfigOpts(sthis, name, opts) {
+  return JSON.stringify(
+    toSortedArray({
+      name,
+      stores: toSortedArray(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, name, opts?.storeUrls))))
+    })
+  );
+}
+function isLedger(db) {
+  return db instanceof LedgerImpl || db instanceof LedgerShell;
+}
+function LedgerFactory(name, opts) {
+  const sthis = ensureSuperThis(opts);
+  return new LedgerShell(
+    ledgers.get(keyConfigOpts(sthis, name, opts)).once((key) => {
+      const db = new LedgerImpl(sthis, {
+        name,
+        meta: opts?.meta,
+        keyBag: defaultKeyBagOpts(sthis, opts?.keyBag),
+        storeUrls: toStoreURIRuntime(sthis, name, opts?.storeUrls),
+        gatewayInterceptor: opts?.gatewayInterceptor,
+        writeQueue: defaultWriteQueueOpts(opts?.writeQueue),
+        storeEnDe: {
+          encodeFile,
+          decodeFile,
+          ...opts?.storeEnDe
+        }
+      });
+      db.onClosed(() => {
+        ledgers.unget(key);
+      });
+      return db;
+    })
+  );
+}
+var LedgerShell = class {
+  constructor(ref) {
+    this.ref = ref;
+    ref.addShell(this);
+  }
+  get id() {
+    return this.ref.id;
+  }
+  get logger() {
+    return this.ref.logger;
+  }
+  get sthis() {
+    return this.ref.sthis;
+  }
+  get crdt() {
+    return this.ref.crdt;
+  }
+  get name() {
+    return this.ref.name;
+  }
+  onClosed(fn) {
+    return this.ref.onClosed(fn);
+  }
+  close() {
+    return this.ref.shellClose(this);
+  }
+  destroy() {
+    return this.ref.destroy();
+  }
+  ready() {
+    return this.ref.ready();
+  }
+  get(id) {
+    return this.ref.get(id);
+  }
+  put(doc) {
+    return this.ref.put(doc);
+  }
+  bulk(docs) {
+    return this.ref.bulk(docs);
+  }
+  del(id) {
+    return this.ref.del(id);
+  }
+  changes(since, opts) {
+    return this.ref.changes(since, opts);
+  }
+  allDocs(opts) {
+    return this.ref.allDocs(opts);
+  }
+  allDocuments() {
+    return this.ref.allDocuments();
+  }
+  subscribe(listener, updates) {
+    return this.ref.subscribe(listener, updates);
+  }
+  query(field, opts) {
+    return this.ref.query(field, opts);
+  }
+  compact() {
+    return this.ref.compact();
+  }
+};
+var LedgerImpl = class {
+  constructor(sthis, opts) {
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new ResolveOnce6();
-    this.name = name;
-    this.opts = opts || this.opts;
-    this.sthis = ensureSuperThis(this.opts);
-    this.logger = ensureLogger(this.sthis, "Database");
-    this._crdt = new CRDT(this.sthis, name, this.opts);
-    this.blockstore = this._crdt.blockstore;
-    this._writeQueue = writeQueue(async (updates) => {
-      return await this._crdt.bulk(updates);
-    });
-    this._crdt.clock.onTock(() => {
-      this._no_update_notify();
-    });
+    // readonly blockstore: BaseBlockstore;
+    this.shells = /* @__PURE__ */ new Set();
+    this._onClosedFns = /* @__PURE__ */ new Set();
+    this._ready = new ResolveOnce7();
+    this.opts = opts;
+    this.sthis = sthis;
+    this.id = sthis.timeOrderedNextId().str;
+    this.logger = ensureLogger(this.sthis, "Ledger");
+    this.crdt = new CRDT(this.sthis, this.opts);
+    this._writeQueue = writeQueue(this.sthis, async (updates) => this.crdt.bulk(updates), this.opts.writeQueue);
+    this.crdt.clock.onTock(() => this._no_update_notify());
   }
-  static {
-    this.databases = /* @__PURE__ */ new Map();
+  addShell(shell) {
+    this.shells.add(shell);
+  }
+  onClosed(fn) {
+    this._onClosedFns.add(fn);
   }
-  /**
-   * Close the database and release resources
-   */
   async close() {
-    await this.ready();
-    await this._crdt.close();
-    await this.blockstore.close();
+    throw this.logger.Error().Str("db", this.name).Msg(`use shellClose`).AsError();
+  }
+  async shellClose(db) {
+    if (!this.shells.has(db)) {
+      throw this.logger.Error().Str("db", this.name).Msg(`LedgerShell mismatch`).AsError();
+    }
+    this.shells.delete(db);
+    if (this.shells.size === 0) {
+      await this.ready();
+      await this.crdt.close();
+      await this._writeQueue.close();
+      this._onClosedFns.forEach((fn) => fn());
+    }
   }
-  /**
-   * Destroy the database and release all resources
-   */
   async destroy() {
     await this.ready();
-    await this._crdt.destroy();
-    await this.blockstore.destroy();
+    await this.crdt.destroy();
   }
   async ready() {
-    return this._ready.once(async () => {
+    const ret = await this._ready.once(async () => {
       await this.sthis.start();
-      await this._crdt.ready();
-      await this.blockstore.ready();
+      await this.crdt.ready();
     });
+    return ret;
+  }
+  get name() {
+    return this.opts.storeUrls.data.data.getParam("name" /* NAME */) || "default";
   }
-  /**
-   * Get a document from the database
-   * @param id - the document id
-   * @returns the document with the _id
-   * @throws NotFoundError if the document is not found
-   */
   async get(id) {
     if (!id) throw this.logger.Error().Str("db", this.name).Msg(`Doc id is required`).AsError();
     await this.ready();
     this.logger.Debug().Str("id", id).Msg("get");
-    const got = await this._crdt.get(id).catch((e) => {
+    const got = await this.crdt.get(id).catch((e) => {
       throw new NotFoundError(`Not found: ${id} - ${e.message}`);
     });
     if (!got) throw new NotFoundError(`Not found: ${id}`);
     const { doc } = got;
     return { ...doc, _id: id };
   }
-  /**
-   * Put a document from the database
-   * @param doc - the document to put
-   * @returns add DocResponse with the id and clock
-   */
   async put(doc) {
     await this.ready();
     this.logger.Debug().Str("id", doc._id).Msg("put");
@@ -3328,11 +4365,21 @@ var Database = class {
     });
     return { id: docId, clock: result?.head, name: this.name };
   }
-  /**
-   * delete a document from the database
-   * @param id Document id
-   * @returns DocResponse with the id and clock
-   */
+  async bulk(docs) {
+    await this.ready();
+    const updates = docs.map((doc) => {
+      const id = doc._id || this.sthis.timeOrderedNextId().str;
+      return {
+        id,
+        value: {
+          ...doc,
+          _id: id
+        }
+      };
+    });
+    const result = await this._writeQueue.bulk(updates);
+    return { ids: updates.map((u) => u.id), clock: result.head, name: this.name };
+  }
   async del(id) {
     await this.ready();
     this.logger.Debug().Str("id", id).Msg("del");
@@ -3342,7 +4389,7 @@ var Database = class {
   async changes(since = [], opts = {}) {
     await this.ready();
     this.logger.Debug().Any("since", since).Any("opts", opts).Msg("changes");
-    const { result, head } = await this._crdt.changes(since, opts);
+    const { result, head } = await this.crdt.changes(since, opts);
     const rows = result.map(({ id: key, value, del, clock }) => ({
       key,
       value: del ? { _id: key, _deleted: true } : { _id: key, ...value },
@@ -3353,7 +4400,7 @@ var Database = class {
   async allDocs(opts = {}) {
     await this.ready();
     this.logger.Debug().Msg("allDocs");
-    const { result, head } = await this._crdt.allDocs();
+    const { result, head } = await this.crdt.allDocs();
     const rows = result.map(({ id: key, value, del }) => ({
       key,
       value: del ? { _id: key, _deleted: true } : { _id: key, ...value }
@@ -3368,7 +4415,7 @@ var Database = class {
     if (updates) {
       if (!this._listening) {
         this._listening = true;
-        this._crdt.clock.onTick((updates2) => {
+        this.crdt.clock.onTick((updates2) => {
           void this._notify(updates2);
         });
       }
@@ -3387,13 +4434,13 @@ var Database = class {
   async query(field, opts = {}) {
     await this.ready();
     this.logger.Debug().Any("field", field).Any("opts", opts).Msg("query");
-    const _crdt = this._crdt;
-    const idx = typeof field === "string" ? index(this.sthis, { _crdt }, field) : index(this.sthis, { _crdt }, makeName(field.toString()), field);
+    const _crdt = this.crdt;
+    const idx = typeof field === "string" ? index({ crdt: _crdt }, field) : index({ crdt: _crdt }, makeName(field.toString()), field);
     return await idx.query(opts);
   }
   async compact() {
     await this.ready();
-    await this._crdt.compact();
+    await this.crdt.compact();
   }
   async _notify(updates) {
     await this.ready();
@@ -3417,23 +4464,62 @@ var Database = class {
     }
   }
 };
-function toSortedArray(set) {
-  if (!set) return [];
-  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => ({ [k]: v }));
+function defaultURI2(sthis, curi, uri, store, ctx) {
+  ctx = ctx || {};
+  const ret = (curi ? URI12.from(curi) : uri).build().setParam("store" /* STORE */, store);
+  if (!ret.hasParam("name" /* NAME */)) {
+    const name = sthis.pathOps.basename(ret.URI().pathname);
+    if (!name) {
+      throw sthis.logger.Error().Url(ret).Any("ctx", ctx).Msg("Ledger name is required").AsError();
+    }
+    ret.setParam("name" /* NAME */, name);
+  }
+  if (ctx.idx) {
+    ret.defParam("index" /* INDEX */, "idx");
+    ret.defParam("storekey" /* STORE_KEY */, `@${ret.getParam("name" /* NAME */)}-${store}-idx@`);
+  } else {
+    ret.defParam("storekey" /* STORE_KEY */, `@${ret.getParam("name" /* NAME */)}-${store}@`);
+  }
+  if (store === "data") {
+    if (ctx.file) {
+    } else {
+      ret.defParam("suffix" /* SUFFIX */, ".car");
+    }
+  }
+  return ret.URI();
 }
-function fireproof(name, opts) {
-  const key = JSON.stringify(
-    toSortedArray({
-      name,
-      stores: toSortedArray(opts?.store?.stores)
-    })
-  );
-  let db = Database.databases.get(key);
-  if (!db) {
-    db = new Database(name, opts);
-    Database.databases.set(key, db);
+function toStoreURIRuntime(sthis, name, sopts) {
+  sopts = sopts || {};
+  if (!sopts.base) {
+    const fp_env = sthis.env.get("FP_STORAGE_URL");
+    if (fp_env) {
+      sopts = { ...sopts, base: BuildURI2.from(fp_env).setParam("urlGen" /* URL_GEN */, "fromEnv") };
+    } else {
+      sopts = { ...sopts, base: getDefaultURI(sthis).build().setParam("urlGen" /* URL_GEN */, "default") };
+    }
   }
-  return db;
+  const bbase = BuildURI2.from(sopts.base);
+  if (name) {
+    bbase.setParam("name" /* NAME */, name);
+  }
+  const base = bbase.URI();
+  return {
+    idx: {
+      data: defaultURI2(sthis, sopts.idx?.data, base, "data", { idx: true }),
+      file: defaultURI2(sthis, sopts.idx?.data, base, "data", { file: true, idx: true }),
+      meta: defaultURI2(sthis, sopts.idx?.meta, base, "meta", { idx: true }),
+      wal: defaultURI2(sthis, sopts.idx?.wal, base, "wal", { idx: true })
+    },
+    data: {
+      data: defaultURI2(sthis, sopts.data?.data, base, "data"),
+      file: defaultURI2(sthis, sopts.data?.data, base, "data", { file: true }),
+      meta: defaultURI2(sthis, sopts.data?.meta, base, "meta"),
+      wal: defaultURI2(sthis, sopts.data?.wal, base, "wal")
+    }
+  };
+}
+function fireproof(name, opts) {
+  return LedgerFactory(name, opts);
 }
 function makeName(fnString) {
   const regex = /\(([^,()]+,\s*[^,()]+|\[[^\]]+\],\s*[^,()]+)\)/g;
@@ -3452,52 +4538,24 @@ function makeName(fnString) {
   }
 }
 
-// src/runtime/index.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  FILESTORE_VERSION: () => FILESTORE_VERSION,
-  INDEXDB_VERSION: () => INDEXDB_VERSION,
-  files: () => files_exports,
-  getFileName: () => getFileName,
-  getFileSystem: () => getFileSystem,
-  getPath: () => getPath,
-  kb: () => key_bag_exports,
-  kc: () => keyed_crypto_exports,
-  mf: () => wait_pr_multiformats_exports,
-  runtimeFn: () => runtimeFn2
-});
-
-// src/runtime/wait-pr-multiformats/index.ts
-var wait_pr_multiformats_exports = {};
-__export(wait_pr_multiformats_exports, {
-  block: () => block_exports,
-  codec: () => codec_interface_exports
-});
-
-// src/runtime/wait-pr-multiformats/codec-interface.ts
-var codec_interface_exports = {};
-
-// src/runtime/index.ts
-import { runtimeFn as runtimeFn2 } from "@adviser/cement";
-
-// src/runtime/gateways/indexdb/version.ts
-var INDEXDB_VERSION = "v0.19-indexdb";
-
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.121-dev": "xxxx"
+  "0.20.0-dev-preview-05": "xxxx"
 })[0];
 export {
   CRDT,
-  Database,
   Index,
+  LedgerFactory,
+  LedgerShell,
   NotFoundError,
   PACKAGE_VERSION,
-  Result,
+  PARAM,
   UInt8ArrayEqual,
   blockstore_exports as blockstore,
   blockstore_exports as bs,
-  dataDir,
+  coerceIntoUint8,
+  coercePromiseIntoUint8,
+  defaultWriteQueueOpts,
   ensureLogger,
   ensureSuperLog,
   ensureSuperThis,
@@ -3508,11 +4566,16 @@ export {
   getName,
   getStore,
   index,
+  inplaceFilter,
   isFalsy,
+  isLedger,
   isNotFoundError,
+  keyConfigOpts,
   onSuperThis,
   runtime_exports as rt,
   runtime_exports as runtime,
-  throwFalsy
+  throwFalsy,
+  toSortedArray,
+  toStoreURIRuntime
 };
 //# sourceMappingURL=index.js.map