@fireproof/core 0.19.121-dev → 0.19.121

package/index.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,977 +27,561 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/utils.ts
-function globalLogger() {
-  return _globalLogger.once(() => new import_cement.LoggerImpl());
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CRDT: () => CRDT,
+  Database: () => Database,
+  Index: () => Index,
+  NotFoundError: () => NotFoundError,
+  PACKAGE_VERSION: () => PACKAGE_VERSION,
+  Result: () => import_cement.Result,
+  UInt8ArrayEqual: () => UInt8ArrayEqual,
+  blockstore: () => blockstore_exports,
+  bs: () => blockstore_exports,
+  dataDir: () => dataDir,
+  ensureLogger: () => ensureLogger,
+  ensureSuperLog: () => ensureSuperLog,
+  ensureSuperThis: () => ensureSuperThis,
+  exceptionWrapper: () => exceptionWrapper,
+  falsyToUndef: () => falsyToUndef,
+  fireproof: () => fireproof,
+  getKey: () => getKey,
+  getName: () => getName,
+  getStore: () => getStore,
+  index: () => index,
+  isFalsy: () => isFalsy,
+  isNotFoundError: () => isNotFoundError,
+  onSuperThis: () => onSuperThis,
+  rt: () => runtime_exports,
+  runtime: () => runtime_exports,
+  throwFalsy: () => throwFalsy
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/database.ts
+var import_cement12 = require("@adviser/cement");
+
+// 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) {
+      const promises = updates.map(async (update, index2) => {
+        try {
+          const result = await worker([update]);
+          tasksToProcess[index2].resolve(result);
+        } catch (error) {
+          tasksToProcess[index2].reject(error);
+        }
+      });
+      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));
+      }
+    }
+    isProcessing = false;
+    void process();
+  }
+  return {
+    push(task) {
+      return new Promise((resolve, reject) => {
+        queue.push({ task, resolve, reject });
+        void process();
+      });
+    }
+  };
 }
-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;
+
+// src/crdt.ts
+var import_cement11 = require("@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
+});
+var import_multiformats = require("multiformats");
+var import_block = require("multiformats/block");
+var Block = import_block.Block;
+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 = import_multiformats.CID.create(1, codec3.code, hash);
+  return new import_block.Block({ value, bytes, cid });
 }
-function onSuperThis(fn) {
-  const key = `onSuperThis-${Math.random().toString(36).slice(2)}`;
-  _onSuperThis.set(key, fn);
-  return () => {
-    _onSuperThis.delete(key);
-  };
+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 = import_multiformats.CID.create(1, codec3.code, hash);
+  return new import_block.Block({ value, bytes, cid });
 }
-function ensureSuperThis(osthis) {
-  const env = (0, import_cement.envFactory)({
-    symbol: osthis?.env?.symbol || "FP_ENV",
-    presetEnv: osthis?.env?.presetEnv || presetEnv()
-  });
-  const ret = new SuperThisImpl({
-    logger: osthis?.logger || globalLogger(),
-    env,
-    crypto: osthis?.crypto || (0, import_cement.toCryptoRuntime)(),
-    ctx: osthis?.ctx || {},
-    pathOps,
-    txt: osthis?.txt || txtOps
+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 (!import_multiformats.bytes.equals(cid.multihash.bytes, hash.bytes)) {
+    throw new Error("CID hash does not match bytes");
+  }
+  return createUnsafe({
+    bytes,
+    cid,
+    value,
+    codec: codec3
   });
-  _onSuperThis.forEach((fn) => fn(ret));
-  return ret;
 }
-function ensureSuperLog(sthis, componentName, ctx) {
-  return sthis.clone({
-    logger: ensureLogger(sthis, componentName, ctx)
+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
   });
 }
-function ensureLogger(sthis, componentName, ctx) {
-  let logger;
-  if ((0, import_cement.IsLogger)(sthis)) {
-    logger = sthis;
-  } else if (sthis && (0, import_cement.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 ("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 ((0, import_cement.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 import_cement.JSONFormatter(logger.TxtEnDe(), 2));
-                break;
-              case "yaml":
-                logger.SetFormatter(new import_cement.YAMLFormatter(logger.TxtEnDe(), 2));
-                break;
-              case "json":
-              default:
-                logger.SetFormatter(new import_cement.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();
-  return out;
+
+// src/crdt-helpers.ts
+var import_link = require("multiformats/link");
+var import_sha25 = require("multiformats/hashes/sha2");
+var codec = __toESM(require("@fireproof/vendor/@ipld/dag-cbor"), 1);
+var import_crdt = require("@fireproof/vendor/@web3-storage/pail/crdt");
+var import_clock2 = require("@fireproof/vendor/@web3-storage/pail/clock");
+var Batch = __toESM(require("@fireproof/vendor/@web3-storage/pail/crdt/batch"), 1);
+
+// src/blockstore/index.ts
+var blockstore_exports = {};
+__export(blockstore_exports, {
+  BaseBlockstore: () => BaseBlockstore,
+  CarTransaction: () => CarTransaction,
+  CompactionFetcher: () => CompactionFetcher,
+  ConnectionBase: () => ConnectionBase,
+  EncryptedBlockstore: () => EncryptedBlockstore,
+  FragmentGateway: () => FragmentGateway,
+  Loader: () => Loader,
+  addCryptoKeyToGatewayMetaPayload: () => addCryptoKeyToGatewayMetaPayload,
+  ensureStart: () => ensureStart,
+  getGatewayFromURL: () => getGatewayFromURL,
+  parseCarFile: () => parseCarFile,
+  registerStoreProtocol: () => registerStoreProtocol,
+  setCryptoKeyFromGatewayMetaPayload: () => setCryptoKeyFromGatewayMetaPayload,
+  testStoreFactory: () => testStoreFactory,
+  toCIDBlock: () => toCIDBlock,
+  toStoreRuntime: () => toStoreRuntime
+});
+
+// src/blockstore/types.ts
+function toCIDBlock(block) {
+  return block;
 }
-function getStore(url, sthis, joiner) {
-  const store = url.getParam("store");
-  switch (store) {
-    case "data":
-    case "wal":
-    case "meta":
-      break;
-    default:
-      throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
-  }
-  let name = store;
-  if (url.hasParam("index")) {
-    name = joiner(url.getParam("index") || "idx", name);
-  }
-  return { store, name };
+
+// src/blockstore/store-factory.ts
+var import_cement9 = require("@adviser/cement");
+
+// src/runtime/files.ts
+var files_exports = {};
+__export(files_exports, {
+  decodeFile: () => decodeFile,
+  encodeFile: () => encodeFile
+});
+var UnixFS = __toESM(require("@ipld/unixfs"), 1);
+var raw = __toESM(require("multiformats/codecs/raw"), 1);
+var import_fixed = require("@ipld/unixfs/file/chunker/fixed");
+var import_balanced = require("@ipld/unixfs/file/layout/balanced");
+var import_ipfs_unixfs_exporter = require("@fireproof/vendor/ipfs-unixfs-exporter");
+var queuingStrategy = UnixFS.withCapacity();
+var settings = UnixFS.configure({
+  fileChunkEncoder: raw,
+  smallFileEncoder: raw,
+  chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
+  fileLayout: (0, import_balanced.withWidth)(1024)
+});
+async function collect(collectable) {
+  const chunks = [];
+  await collectable.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        chunks.push(chunk);
+      }
+    })
+  );
+  return chunks;
 }
-function getKey(url, logger) {
-  const result = url.getParam("key");
-  if (!result) throw logger.Error().Str("url", url.toString()).Msg(`key not found`).AsError();
-  return result;
+async function encodeFile(blob) {
+  const readable = createFileEncoderStream(blob);
+  const blocks = await collect(readable);
+  return { cid: blocks.at(-1).cid, blocks };
 }
-function getName(sthis, url) {
-  let result = url.getParam("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();
-    }
+async function decodeFile(blocks, cid, meta) {
+  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
+  const chunks = [];
+  for await (const chunk of entry.content()) {
+    chunks.push(chunk);
   }
-  return result;
+  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
 }
-async function exceptionWrapper(fn) {
-  return fn().catch((e) => import_cement.Result.Err(e));
+function createFileEncoderStream(blob) {
+  const { readable, writable } = new TransformStream({}, queuingStrategy);
+  const unixfsWriter = UnixFS.createWriter({ writable, settings });
+  const fileBuilder = new UnixFSFileBuilder("", blob);
+  void (async () => {
+    await fileBuilder.finalize(unixfsWriter);
+    await unixfsWriter.close();
+  })();
+  return readable;
 }
-function isNotFoundError(e) {
-  if (import_cement.Result.Is(e)) {
-    if (e.isOk()) return false;
-    e = e.Err();
+var UnixFSFileBuilder = class {
+  #file;
+  constructor(name, file) {
+    this.name = name;
+    this.#file = file;
   }
-  if (e.code === "ENOENT") return true;
-  return false;
-}
-function dataDir(sthis, name, base) {
-  if (!base) {
-    if (!(0, import_cement.runtimeFn)().isBrowser) {
-      const home = sthis.env.get("HOME") || "./";
-      base = sthis.env.get("FP_STORAGE_URL") || `file://${sthis.pathOps.join(home, ".fireproof")}`;
-    } else {
-      base = sthis.env.get("FP_STORAGE_URL") || `indexdb://fp`;
-    }
+  async finalize(writer) {
+    const unixfsFileWriter = UnixFS.createFileWriter(writer);
+    await this.#file.stream().pipeTo(
+      new WritableStream({
+        async write(chunk) {
+          await unixfsFileWriter.write(chunk);
+        }
+      })
+    );
+    return await unixfsFileWriter.close();
   }
-  return import_cement.URI.from(base.toString()).build().setParam("name", name || "").URI();
+};
+
+// src/blockstore/store.ts
+var import_dag_json2 = require("@fireproof/vendor/@ipld/dag-json");
+var import_cement8 = require("@adviser/cement");
+
+// src/types.ts
+function isFalsy(value) {
+  return value === false && value === null && value === void 0;
 }
-function UInt8ArrayEqual(a, b) {
-  if (a.length !== b.length) {
-    return false;
+function throwFalsy(value) {
+  if (isFalsy(value)) {
+    throw new Error("value is Falsy");
   }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
+  return value;
+}
+function falsyToUndef(value) {
+  if (isFalsy(value)) {
+    return void 0;
   }
-  return true;
+  return value;
 }
-var import_cement, import_base58, _globalLogger, registerFP_DEBUG, SuperThisImpl, pathOpsImpl, pathOps, txtOps, _onSuperThis, NotFoundError;
-var init_utils = __esm({
-  "src/utils.ts"() {
-    "use strict";
-    import_cement = require("@adviser/cement");
-    import_base58 = require("multiformats/bases/base58");
-    _globalLogger = new import_cement.ResolveOnce();
-    registerFP_DEBUG = new import_cement.ResolveOnce();
-    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: import_base58.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: (0, import_cement.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 }
-        });
-      }
-    };
-    pathOpsImpl = class {
-      join(...paths) {
-        return paths.map((i) => i.replace(/\/+$/, "")).join("/");
-      }
-      dirname(path) {
-        return path.split("/").slice(0, -1).join("/");
-      }
-      // homedir() {
-      //     throw new Error("SysContainer:homedir is not available in seeded state");
-      //   }
-    };
-    pathOps = new pathOpsImpl();
-    txtOps = {
-      // eslint-disable-next-line no-restricted-globals
-      encode: (input) => new TextEncoder().encode(input),
-      // eslint-disable-next-line no-restricted-globals
-      decode: (input) => new TextDecoder().decode(input)
-    };
-    _onSuperThis = /* @__PURE__ */ new Map();
-    NotFoundError = class extends Error {
-      constructor() {
-        super(...arguments);
-        this.code = "ENOENT";
-      }
+
+// src/utils.ts
+var import_cement = require("@adviser/cement");
+var import_base58 = require("multiformats/bases/base58");
+var _globalLogger = new import_cement.ResolveOnce();
+function globalLogger() {
+  return _globalLogger.once(() => new import_cement.LoggerImpl());
+}
+var registerFP_DEBUG = new import_cement.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: import_base58.base58btc.encode(bin),
+      bin
     };
   }
-});
-
-// src/runtime/gateways/file/get-file-system-static.ts
-async function getFileSystem(url) {
-  const name = url.getParam("fs", "node");
-  let fs;
-  switch (name) {
-    case "mem":
-      fs = await externalLoaders.get(name).once(async () => {
-        const { MemFileSystem } = await import("@fireproof/core/mem");
-        return new MemFileSystem();
-      });
-      break;
-    // case 'deno': {
-    //   const { DenoFileSystem } = await import("./deno-filesystem.js");
-    //   fs = new DenoFileSystem();
-    //   break;
-    // }
-    default:
-      fs = await externalLoaders.get(name).once(async () => {
-        const { NodeFileSystem } = await import("@fireproof/core/node");
-        return new NodeFileSystem();
-      });
+  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)}`
+    };
   }
-  return fs.start();
-}
-var import_cement4, externalLoaders;
-var init_get_file_system_static = __esm({
-  "src/runtime/gateways/file/get-file-system-static.ts"() {
-    "use strict";
-    import_cement4 = require("@adviser/cement");
-    externalLoaders = new import_cement4.KeyedResolvOnce();
+  start() {
+    return Promise.resolve();
   }
-});
-
-// src/runtime/gateways/file/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  getFileName: () => getFileName,
-  getFileSystem: () => getFileSystem,
-  getPath: () => getPath
-});
-function getPath(url, sthis) {
-  const basePath = url.pathname;
-  const name = url.getParam("name");
-  if (name) {
-    const version = url.getParam("version");
-    if (!version) throw sthis.logger.Error().Url(url).Msg(`version not found`).AsError();
-    return sthis.pathOps.join(basePath, version, name);
+  clone(override) {
+    return new _SuperThisImpl({
+      logger: override.logger || this.logger,
+      env: (0, import_cement.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 }
+    });
   }
-  return sthis.pathOps.join(basePath);
+};
+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;
 }
-function getFileName(url, sthis) {
-  const key = url.getParam("key");
-  if (!key) throw sthis.logger.Error().Url(url).Msg(`key not found`).AsError();
-  const res = getStore(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();
+var pathOpsImpl = class {
+  join(...paths) {
+    return paths.map((i) => i.replace(/\/+$/, "")).join("/");
   }
-}
-var init_utils2 = __esm({
-  "src/runtime/gateways/file/utils.ts"() {
-    "use strict";
-    init_utils();
-    init_get_file_system_static();
+  dirname(path) {
+    return path.split("/").slice(0, -1).join("/");
   }
-});
-
-// src/runtime/key-bag-file.ts
-var key_bag_file_exports = {};
-__export(key_bag_file_exports, {
-  KeyBagProviderFile: () => KeyBagProviderFile
-});
-var KeyBagProviderFile;
-var init_key_bag_file = __esm({
-  "src/runtime/key-bag-file.ts"() {
-    "use strict";
-    init_utils();
-    KeyBagProviderFile = class {
-      async _prepare(id) {
-        await this.sthis.start();
-        let sysFS;
-        switch (this.url.protocol) {
-          case "file:": {
-            const { getFileSystem: getFileSystem2 } = await Promise.resolve().then(() => (init_utils2(), utils_exports));
-            sysFS = await getFileSystem2(this.url);
-            break;
-          }
-          default:
-            throw this.logger.Error().Url(this.url).Msg("unsupported protocol").AsError();
-        }
-        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-indexdb.ts
-var key_bag_indexdb_exports = {};
-__export(key_bag_indexdb_exports, {
-  KeyBagProviderIndexDB: () => KeyBagProviderIndexDB
-});
-var import_idb, import_cement5, KeyBagProviderIndexDB;
-var init_key_bag_indexdb = __esm({
-  "src/runtime/key-bag-indexdb.ts"() {
-    "use strict";
-    import_idb = require("idb");
-    init_utils2();
-    import_cement5 = require("@adviser/cement");
-    KeyBagProviderIndexDB = class {
-      constructor(url, sthis) {
-        this._db = new import_cement5.ResolveOnce();
-        this.sthis = sthis;
-        this.logger = sthis.logger;
-        this.url = url;
-        this.dbName = getPath(this.url, this.sthis);
-      }
-      async _prepare() {
-        return this._db.once(async () => {
-          return await (0, import_idb.openDB)(this.dbName, 1, {
-            upgrade(db) {
-              ["bag"].map((store) => {
-                db.createObjectStore(store, {
-                  autoIncrement: false
-                });
-              });
-            }
-          });
-        });
-      }
-      async get(id) {
-        const db = await this._prepare();
-        const tx = db.transaction(["bag"], "readonly");
-        const keyItem = await tx.objectStore("bag").get(id);
-        await tx.done;
-        if (!keyItem) {
-          return void 0;
-        }
-        return keyItem;
-      }
-      async set(id, item) {
-        const db = await this._prepare();
-        const tx = db.transaction(["bag"], "readwrite");
-        await tx.objectStore("bag").put(item, id);
-        await tx.done;
-      }
-    };
-  }
-});
-
-// src/runtime/gateways/file/version.ts
-var FILESTORE_VERSION;
-var init_version = __esm({
-  "src/runtime/gateways/file/version.ts"() {
-    "use strict";
-    FILESTORE_VERSION = "v0.19-file";
-  }
-});
-
-// src/runtime/gateways/file/gateway.ts
-var gateway_exports = {};
-__export(gateway_exports, {
-  FileGateway: () => FileGateway,
-  FileTestStore: () => FileTestStore
-});
-var import_cement11, versionFiles, FileGateway, FileTestStore;
-var init_gateway = __esm({
-  "src/runtime/gateways/file/gateway.ts"() {
-    "use strict";
-    init_version();
-    import_cement11 = require("@adviser/cement");
-    init_utils();
-    init_utils2();
-    init_get_file_system_static();
-    versionFiles = new import_cement11.KeyedResolvOnce();
-    FileGateway = class {
-      get fs() {
-        if (!this._fs) throw this.logger.Error().Msg("fs not initialized").AsError();
-        return this._fs;
-      }
-      constructor(sthis) {
-        this.sthis = sthis;
-        this.logger = sthis.logger;
-      }
-      async getVersionFromFile(path, logger) {
-        return versionFiles.get(path).once(async () => {
-          await this.fs.mkdir(path, { recursive: true });
-          const vFile = this.sthis.pathOps.join(path, "version");
-          const vFileStat = await this.fs.stat(vFile).catch(() => void 0);
-          if (!vFileStat) {
-            await this.fs.writefile(this.sthis.pathOps.join(path, "version"), FILESTORE_VERSION);
-            return FILESTORE_VERSION;
-          } else if (!vFileStat.isFile()) {
-            throw logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
-          }
-          const v = await this.fs.readfile(vFile);
-          const vStr = this.sthis.txt.decode(v);
-          if (vStr !== FILESTORE_VERSION) {
-            logger.Warn().Str("file", vFile).Str("from", vStr).Str("expected", FILESTORE_VERSION).Msg(`version mismatch`);
-          }
-          return vStr;
-        });
-      }
-      start(baseURL) {
-        return (0, import_cement11.exception2Result)(async () => {
-          this._fs = await getFileSystem(baseURL);
-          await this.fs.start();
-          const url = baseURL.build();
-          url.defParam("version", FILESTORE_VERSION);
-          const dbUrl = await this.buildUrl(url.URI(), "dummy");
-          const dbdirFile = this.getFilePath(dbUrl.Ok());
-          await this.fs.mkdir(this.sthis.pathOps.dirname(dbdirFile), { recursive: true });
-          const dbroot = this.sthis.pathOps.dirname(dbdirFile);
-          this.logger.Debug().Url(url.URI()).Str("dbroot", dbroot).Msg("start");
-          url.setParam("version", await this.getVersionFromFile(dbroot, this.logger));
-          return url.URI();
-        });
-      }
-      async buildUrl(baseUrl, key) {
-        return import_cement11.Result.Ok(baseUrl.build().setParam("key", key).URI());
-      }
-      async close() {
-        return import_cement11.Result.Ok(void 0);
-      }
-      // abstract buildUrl(baseUrl: URL, key: string): Promise<Result<URL>>;
-      getFilePath(url) {
-        const key = url.getParam("key");
-        if (!key) throw this.logger.Error().Url(url).Msg(`key not found`).AsError();
-        return this.sthis.pathOps.join(getPath(url, this.sthis), getFileName(url, this.sthis));
-      }
-      async put(url, body) {
-        return (0, import_cement11.exception2Result)(async () => {
-          const file = await this.getFilePath(url);
-          this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
-          await this.fs.writefile(file, body);
-        });
-      }
-      async get(url) {
-        return exceptionWrapper(async () => {
-          const file = this.getFilePath(url);
-          try {
-            const res = await this.fs.readfile(file);
-            this.logger.Debug().Url(url.asURL()).Str("file", file).Msg("get");
-            return import_cement11.Result.Ok(new Uint8Array(res));
-          } catch (e) {
-            if (isNotFoundError(e)) {
-              return import_cement11.Result.Err(new NotFoundError(`file not found: ${file}`));
-            }
-            return import_cement11.Result.Err(e);
-          }
-        });
-      }
-      async delete(url) {
-        return (0, import_cement11.exception2Result)(async () => {
-          await this.fs.unlink(this.getFilePath(url));
-        });
-      }
-      async destroy(baseURL) {
-        const url = await this.buildUrl(baseURL, "x");
-        if (url.isErr()) return url;
-        const filepath = this.sthis.pathOps.dirname(this.getFilePath(url.Ok()));
-        let files = [];
-        try {
-          files = await this.fs.readdir(filepath);
-        } catch (e) {
-          if (!isNotFoundError(e)) {
-            throw this.logger.Error().Err(e).Str("dir", filepath).Msg("destroy:readdir").AsError();
-          }
-        }
-        for (const file of files) {
-          const pathed = this.sthis.pathOps.join(filepath, file);
-          try {
-            await this.fs.unlink(pathed);
-          } catch (e) {
-            if (!isNotFoundError(e)) {
-              throw this.logger.Error().Err(e).Str("file", pathed).Msg("destroy:unlink").AsError();
-            }
-          }
-        }
-        return import_cement11.Result.Ok(void 0);
-      }
-    };
-    FileTestStore = class {
-      constructor(sthis) {
-        this.logger = ensureLogger(sthis, "FileTestStore");
-        this.sthis = sthis;
-      }
-      async get(iurl, key) {
-        const url = iurl.build().setParam("key", key).URI();
-        const dbFile = this.sthis.pathOps.join(getPath(url, this.sthis), getFileName(url, this.sthis));
-        this.logger.Debug().Url(url).Str("dbFile", dbFile).Msg("get");
-        const buffer = await (await getFileSystem(url)).readfile(dbFile);
-        this.logger.Debug().Url(url).Str("dbFile", dbFile).Len(buffer).Msg("got");
-        return buffer;
-      }
-    };
-  }
-});
-
-// src/runtime/gateways/indexdb/gateway-import-static.ts
-function gatewayImport() {
-  return import("@fireproof/core/web");
+  // homedir() {
+  //     throw new Error("SysContainer:homedir is not available in seeded state");
+  //   }
+};
+var pathOps = new pathOpsImpl();
+var txtOps = {
+  // eslint-disable-next-line no-restricted-globals
+  encode: (input) => new TextEncoder().encode(input),
+  // eslint-disable-next-line no-restricted-globals
+  decode: (input) => new TextDecoder().decode(input)
+};
+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);
+  };
 }
-var init_gateway_import_static = __esm({
-  "src/runtime/gateways/indexdb/gateway-import-static.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/gateways/indexdb/gateway.ts
-var gateway_exports2 = {};
-__export(gateway_exports2, {
-  IndexDBGateway: () => IndexDBGateway,
-  IndexDBTestStore: () => IndexDBTestStore
-});
-var import_cement12, loadExternal, IndexDBGateway, IndexDBTestStore;
-var init_gateway2 = __esm({
-  "src/runtime/gateways/indexdb/gateway.ts"() {
-    "use strict";
-    import_cement12 = require("@adviser/cement");
-    init_gateway_import_static();
-    loadExternal = new import_cement12.ResolveOnce();
-    IndexDBGateway = class {
-      constructor(sthis) {
-        this.sthis = sthis;
-      }
-      getGateway() {
-        return loadExternal.once(() => {
-          return gatewayImport().then(({ IndexDBGatewayImpl }) => new IndexDBGatewayImpl(this.sthis));
-        });
-      }
-      buildUrl(baseUrl, key) {
-        return this.getGateway().then((gw) => gw.buildUrl(baseUrl, key));
-      }
-      start(baseUrl) {
-        return this.getGateway().then((gw) => gw.start(baseUrl));
-      }
-      close(baseUrl) {
-        return this.getGateway().then((gw) => gw.close(baseUrl));
-      }
-      destroy(baseUrl) {
-        return this.getGateway().then((gw) => gw.destroy(baseUrl));
-      }
-      put(url, body) {
-        return this.getGateway().then((gw) => gw.put(url, body));
-      }
-      get(url) {
-        return this.getGateway().then((gw) => gw.get(url));
-      }
-      delete(url) {
-        return this.getGateway().then((gw) => gw.delete(url));
-      }
-      // subscribe?(url: URI, callback: (meta: Uint8Array) => void): Promise<UnsubscribeResult> {
-      //     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      //     return this.getGateway().then(gw => gw.subscribe!(url, callback));
-      // }
-    };
-    IndexDBTestStore = class {
-      constructor(sthis) {
-        this.loadExternal = new import_cement12.ResolveOnce();
-        this.sthis = sthis;
-      }
-      getGateway() {
-        return this.loadExternal.once(() => {
-          return gatewayImport().then(({ IndexDBTestStore: IndexDBTestStore2 }) => new IndexDBTestStore2(this.sthis));
-        });
-      }
-      get(url, key) {
-        return this.getGateway().then((gw) => gw.get(url, key));
-      }
-    };
+function ensureSuperThis(osthis) {
+  const env = (0, import_cement.envFactory)({
+    symbol: osthis?.env?.symbol || "FP_ENV",
+    presetEnv: osthis?.env?.presetEnv || presetEnv()
+  });
+  const ret = new SuperThisImpl({
+    logger: osthis?.logger || globalLogger(),
+    env,
+    crypto: osthis?.crypto || (0, import_cement.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 ((0, import_cement.IsLogger)(sthis)) {
+    logger = sthis;
+  } else if (sthis && (0, import_cement.IsLogger)(sthis.logger)) {
+    logger = sthis.logger;
+  } else {
+    logger = globalLogger();
   }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  CRDT: () => CRDT,
-  Database: () => Database,
-  Index: () => Index,
-  NotFoundError: () => NotFoundError,
-  PACKAGE_VERSION: () => PACKAGE_VERSION,
-  Result: () => import_cement.Result,
-  UInt8ArrayEqual: () => UInt8ArrayEqual,
-  blockstore: () => blockstore_exports,
-  bs: () => blockstore_exports,
-  dataDir: () => dataDir,
-  ensureLogger: () => ensureLogger,
-  ensureSuperLog: () => ensureSuperLog,
-  ensureSuperThis: () => ensureSuperThis,
-  exceptionWrapper: () => exceptionWrapper,
-  falsyToUndef: () => falsyToUndef,
-  fireproof: () => fireproof,
-  getKey: () => getKey,
-  getName: () => getName,
-  getStore: () => getStore,
-  index: () => index,
-  isFalsy: () => isFalsy,
-  isNotFoundError: () => isNotFoundError,
-  onSuperThis: () => onSuperThis,
-  rt: () => runtime_exports,
-  runtime: () => runtime_exports,
-  throwFalsy: () => throwFalsy
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/database.ts
-var import_cement16 = require("@adviser/cement");
-
-// 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) {
-      const promises = updates.map(async (update, index2) => {
-        try {
-          const result = await worker([update]);
-          tasksToProcess[index2].resolve(result);
-        } catch (error) {
-          tasksToProcess[index2].reject(error);
-        }
-      });
-      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));
+  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;
     }
-    isProcessing = false;
-    void process();
-  }
-  return {
-    push(task) {
-      return new Promise((resolve, reject) => {
-        queue.push({ task, resolve, reject });
-        void process();
-      });
+    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 ((0, import_cement.isURL)(value)) {
+            cLogger.Str(key, value.toString());
+          } else if (typeof value === "function") {
+            cLogger.Ref(key, value);
+          } else {
+            cLogger.Any(key, value);
+          }
+          break;
+      }
     }
-  };
-}
-
-// src/crdt.ts
-var import_cement15 = require("@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
-});
-var import_multiformats = require("multiformats");
-var import_block = require("multiformats/block");
-var Block = import_block.Block;
-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 = import_multiformats.CID.create(1, codec3.code, hash);
-  return new import_block.Block({ 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 = import_multiformats.CID.create(1, codec3.code, hash);
-  return new import_block.Block({ 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 (!import_multiformats.bytes.equals(cid.multihash.bytes, hash.bytes)) {
-    throw new Error("CID hash does not match bytes");
   }
-  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
+  registerFP_DEBUG.once(async () => {
+    sthis.env.onSet(
+      (key, value) => {
+        switch (key) {
+          case "FP_FORMAT": {
+            switch (value) {
+              case "jsonice":
+                logger.SetFormatter(new import_cement.JSONFormatter(logger.TxtEnDe(), 2));
+                break;
+              case "yaml":
+                logger.SetFormatter(new import_cement.YAMLFormatter(logger.TxtEnDe(), 2));
+                break;
+              case "json":
+              default:
+                logger.SetFormatter(new import_cement.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();
+  return out;
 }
-
-// src/crdt-helpers.ts
-var import_link = require("multiformats/link");
-var import_sha25 = require("multiformats/hashes/sha2");
-var codec = __toESM(require("@fireproof/vendor/@ipld/dag-cbor"), 1);
-var import_crdt = require("@fireproof/vendor/@web3-storage/pail/crdt");
-var import_clock2 = require("@fireproof/vendor/@web3-storage/pail/clock");
-var Batch = __toESM(require("@fireproof/vendor/@web3-storage/pail/crdt/batch"), 1);
-
-// src/blockstore/index.ts
-var blockstore_exports = {};
-__export(blockstore_exports, {
-  BaseBlockstore: () => BaseBlockstore,
-  CarTransaction: () => CarTransaction,
-  CompactionFetcher: () => CompactionFetcher,
-  ConnectionBase: () => ConnectionBase,
-  EncryptedBlockstore: () => EncryptedBlockstore,
-  FragmentGateway: () => FragmentGateway,
-  Loader: () => Loader,
-  addCryptoKeyToGatewayMetaPayload: () => addCryptoKeyToGatewayMetaPayload,
-  ensureStart: () => ensureStart,
-  getGatewayFromURL: () => getGatewayFromURL,
-  parseCarFile: () => parseCarFile,
-  registerStoreProtocol: () => registerStoreProtocol,
-  setCryptoKeyFromGatewayMetaPayload: () => setCryptoKeyFromGatewayMetaPayload,
-  testStoreFactory: () => testStoreFactory,
-  toCIDBlock: () => toCIDBlock,
-  toStoreRuntime: () => toStoreRuntime
-});
-
-// src/blockstore/types.ts
-function toCIDBlock(block) {
-  return block;
-}
-
-// src/blockstore/store-factory.ts
-var import_cement13 = require("@adviser/cement");
-
-// src/runtime/files.ts
-var files_exports = {};
-__export(files_exports, {
-  decodeFile: () => decodeFile,
-  encodeFile: () => encodeFile
-});
-var UnixFS = __toESM(require("@ipld/unixfs"), 1);
-var raw = __toESM(require("multiformats/codecs/raw"), 1);
-var import_fixed = require("@ipld/unixfs/file/chunker/fixed");
-var import_balanced = require("@ipld/unixfs/file/layout/balanced");
-var import_ipfs_unixfs_exporter = require("@fireproof/vendor/ipfs-unixfs-exporter");
-var queuingStrategy = UnixFS.withCapacity();
-var settings = UnixFS.configure({
-  fileChunkEncoder: raw,
-  smallFileEncoder: raw,
-  chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
-  fileLayout: (0, import_balanced.withWidth)(1024)
-});
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
+function getStore(url, sthis, joiner) {
+  const store = url.getParam("store");
+  switch (store) {
+    case "data":
+    case "wal":
+    case "meta":
+      break;
+    default:
+      throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
+  }
+  let name = store;
+  if (url.hasParam("index")) {
+    name = joiner(url.getParam("index") || "idx", name);
+  }
+  return { store, name };
 }
-async function encodeFile(blob) {
-  const readable = createFileEncoderStream(blob);
-  const blocks = await collect(readable);
-  return { cid: blocks.at(-1).cid, blocks };
+function getKey(url, logger) {
+  const result = url.getParam("key");
+  if (!result) throw logger.Error().Str("url", url.toString()).Msg(`key not found`).AsError();
+  return result;
 }
-async function decodeFile(blocks, cid, meta) {
-  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
-  const chunks = [];
-  for await (const chunk of entry.content()) {
-    chunks.push(chunk);
+function getName(sthis, url) {
+  let result = url.getParam("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 new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
+  return result;
 }
-function createFileEncoderStream(blob) {
-  const { readable, writable } = new TransformStream({}, queuingStrategy);
-  const unixfsWriter = UnixFS.createWriter({ writable, settings });
-  const fileBuilder = new UnixFSFileBuilder("", blob);
-  void (async () => {
-    await fileBuilder.finalize(unixfsWriter);
-    await unixfsWriter.close();
-  })();
-  return readable;
+async function exceptionWrapper(fn) {
+  return fn().catch((e) => import_cement.Result.Err(e));
 }
-var UnixFSFileBuilder = class {
-  #file;
-  constructor(name, file) {
-    this.name = name;
-    this.#file = file;
-  }
-  async finalize(writer) {
-    const unixfsFileWriter = UnixFS.createFileWriter(writer);
-    await this.#file.stream().pipeTo(
-      new WritableStream({
-        async write(chunk) {
-          await unixfsFileWriter.write(chunk);
-        }
-      })
-    );
-    return await unixfsFileWriter.close();
+var NotFoundError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.code = "ENOENT";
   }
 };
-
-// src/blockstore/store.ts
-var import_dag_json2 = require("@fireproof/vendor/@ipld/dag-json");
-var import_cement10 = require("@adviser/cement");
-
-// src/types.ts
-function isFalsy(value) {
-  return value === false && value === null && value === void 0;
+function isNotFoundError(e) {
+  if (import_cement.Result.Is(e)) {
+    if (e.isOk()) return false;
+    e = e.Err();
+  }
+  if (e.code === "ENOENT") return true;
+  return false;
 }
-function throwFalsy(value) {
-  if (isFalsy(value)) {
-    throw new Error("value is Falsy");
+function dataDir(sthis, name, base) {
+  if (!base) {
+    if (!(0, import_cement.runtimeFn)().isBrowser) {
+      const home = sthis.env.get("HOME") || "./";
+      base = sthis.env.get("FP_STORAGE_URL") || `file://${sthis.pathOps.join(home, ".fireproof")}`;
+    } else {
+      base = sthis.env.get("FP_STORAGE_URL") || `indexdb://fp`;
+    }
   }
-  return value;
+  return import_cement.URI.from(base.toString()).build().setParam("name", name || "").URI();
 }
-function falsyToUndef(value) {
-  if (isFalsy(value)) {
-    return void 0;
+function UInt8ArrayEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
   }
-  return value;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
 }
 
-// src/blockstore/store.ts
-init_utils();
-
 // src/blockstore/loader.ts
 var import_p_limit = __toESM(require("p-limit"), 1);
 var import_reader = require("@fireproof/vendor/@ipld/car/reader");
-var import_cement7 = require("@adviser/cement");
+var import_cement5 = require("@adviser/cement");
 
 // src/blockstore/loader-helpers.ts
 var import_sha2 = require("multiformats/hashes/sha2");
@@ -1020,7 +601,6 @@ async function parseCarFile(reader, logger) {
 // src/blockstore/transaction.ts
 var import_block3 = require("@fireproof/vendor/@web3-storage/pail/block");
 var import_cement2 = require("@adviser/cement");
-init_utils();
 var CarTransaction = class extends import_block3.MemoryBlockstore {
   constructor(parent, opts = { add: true, noLoader: false }) {
     super();
@@ -1289,14 +869,13 @@ __export(key_bag_exports, {
   getKeyBag: () => getKeyBag,
   registerKeyBagProviderFactory: () => registerKeyBagProviderFactory
 });
-var import_cement6 = require("@adviser/cement");
-init_utils();
+var import_cement4 = require("@adviser/cement");
 var import_base582 = require("multiformats/bases/base58");
 var KeyBag = class {
   constructor(rt) {
     this.rt = rt;
-    this._warnOnce = new import_cement6.ResolveOnce();
-    this._seq = new import_cement6.ResolveSeq();
+    this._warnOnce = new import_cement4.ResolveOnce();
+    this._seq = new import_cement4.ResolveSeq();
     this.logger = ensureLogger(rt.sthis, "KeyBag");
     this.logger.Debug().Msg("KeyBag created");
   }
@@ -1320,7 +899,7 @@ var KeyBag = class {
   async ensureKeyFromUrl(url, keyFactory) {
     const storeKey = url.getParam("storekey");
     if (storeKey === "insecure") {
-      return import_cement6.Result.Ok(url);
+      return import_cement4.Result.Ok(url);
     }
     if (!storeKey) {
       const keyName = `@${keyFactory()}@`;
@@ -1329,7 +908,7 @@ var KeyBag = class {
         return ret;
       }
       const urb = url.build().setParam("storekey", keyName);
-      return import_cement6.Result.Ok(urb.URI());
+      return import_cement4.Result.Ok(urb.URI());
     }
     if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
       const ret = await this.getNamedKey(storeKey);
@@ -1337,13 +916,13 @@ var KeyBag = class {
         return ret;
       }
     }
-    return import_cement6.Result.Ok(url);
+    return import_cement4.Result.Ok(url);
   }
   async toKeyWithFingerPrint(keyStr) {
     const material = import_base582.base58btc.decode(keyStr);
     const key = await this.subtleKey(keyStr);
     const fpr = await this.rt.crypto.digestSHA256(material);
-    return import_cement6.Result.Ok({
+    return import_cement4.Result.Ok({
       key,
       fingerPrint: import_base582.base58btc.encode(new Uint8Array(fpr))
     });
@@ -1368,7 +947,7 @@ var KeyBag = class {
       return ret;
     }
     const named = ret.Ok();
-    return import_cement6.Result.Ok({
+    return import_cement4.Result.Ok({
       ...named,
       extract: async () => {
         const ext = new Uint8Array(await this.rt.crypto.exportKey("raw", named.key));
@@ -1391,7 +970,7 @@ var KeyBag = class {
       }
       if (failIfNotFound) {
         this.logger.Debug().Str("id", id).Str("name", name).Msg("failIfNotFound getNamedKey");
-        return import_cement6.Result.Err(new Error(`Key not found: ${name}`));
+        return import_cement4.Result.Err(new Error(`Key not found: ${name}`));
       }
       const ret = await this._setNamedKey(name, import_base582.base58btc.encode(this.rt.crypto.randomBytes(this.rt.keyLength)));
       this.logger.Debug().Str("id", id).Str("name", name).Result("fpr", ret).Msg("createKey getNamedKey-post");
@@ -1404,15 +983,15 @@ var keyBagProviderFactories = new Map(
     {
       protocol: "file:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderFile: KeyBagProviderFile2 } = await Promise.resolve().then(() => (init_key_bag_file(), key_bag_file_exports));
-        return new KeyBagProviderFile2(url, sthis);
+        const { KeyBagProviderImpl } = await import("@fireproof/core/node");
+        return new KeyBagProviderImpl(url, sthis);
       }
     },
     {
       protocol: "indexdb:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderIndexDB: KeyBagProviderIndexDB2 } = await Promise.resolve().then(() => (init_key_bag_indexdb(), key_bag_indexdb_exports));
-        return new KeyBagProviderIndexDB2(url, sthis);
+        const { KeyBagProviderImpl } = await import("@fireproof/core/web");
+        return new KeyBagProviderImpl(url, sthis);
       }
     }
   ].map((i) => [i.protocol, i])
@@ -1427,15 +1006,15 @@ function registerKeyBagProviderFactory(item) {
 function defaultKeyBagUrl(sthis) {
   let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
   let url;
-  if ((0, import_cement6.runtimeFn)().isBrowser) {
-    url = import_cement6.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
+  if ((0, import_cement4.runtimeFn)().isBrowser) {
+    url = import_cement4.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
   } else {
     if (!bagFnameOrUrl) {
       const home = sthis.env.get("HOME");
       bagFnameOrUrl = `${home}/.fireproof/keybag`;
-      url = import_cement6.URI.from(`file://${bagFnameOrUrl}`);
+      url = import_cement4.URI.from(`file://${bagFnameOrUrl}`);
     } else {
-      url = import_cement6.URI.from(bagFnameOrUrl);
+      url = import_cement4.URI.from(bagFnameOrUrl);
     }
   }
   const logger = ensureLogger(sthis, "defaultKeyBagUrl");
@@ -1449,7 +1028,7 @@ function defaultKeyBagOpts(sthis, kbo) {
   const logger = ensureLogger(sthis, "KeyBag");
   let url;
   if (kbo.url) {
-    url = import_cement6.URI.from(kbo.url);
+    url = import_cement4.URI.from(kbo.url);
     logger.Debug().Url(url).Msg("from opts");
   } else {
     url = defaultKeyBagUrl(sthis);
@@ -1464,7 +1043,7 @@ function defaultKeyBagOpts(sthis, kbo) {
   }
   return {
     url,
-    crypto: kbo.crypto || (0, import_cement6.toCryptoRuntime)({}),
+    crypto: kbo.crypto || (0, import_cement4.toCryptoRuntime)({}),
     sthis,
     logger,
     keyLength: kbo.keyLength || 16,
@@ -1474,7 +1053,7 @@ function defaultKeyBagOpts(sthis, kbo) {
     }
   };
 }
-var _keyBags = new import_cement6.KeyedResolvOnce();
+var _keyBags = new import_cement4.KeyedResolvOnce();
 async function getKeyBag(sthis, kbo = {}) {
   await sthis.start();
   const rt = defaultKeyBagOpts(sthis, kbo);
@@ -1587,7 +1166,6 @@ async function prepareCarFiles(encoder, threshold, rootBlock, t) {
 var import_sha23 = require("multiformats/hashes/sha2");
 
 // src/blockstore/task-manager.ts
-init_utils();
 var TaskManager = class {
   constructor(sthis, callback) {
     // we need to remove the events after some time
@@ -1659,7 +1237,7 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = (0, import_p_limit.default)(1);
-    this.onceReady = new import_cement7.ResolveOnce();
+    this.onceReady = new import_cement5.ResolveOnce();
     this.name = name;
     this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
@@ -1984,7 +1562,6 @@ __export(keyed_crypto_exports, {
   BlockIvKeyIdCodec: () => BlockIvKeyIdCodec,
   keyedCryptoFactory: () => keyedCryptoFactory
 });
-init_utils();
 var import_base583 = require("multiformats/bases/base58");
 var import_sha24 = require("multiformats/hashes/sha2");
 var CBOR = __toESM(require("@fireproof/vendor/cborg"), 1);
@@ -2152,10 +1729,9 @@ async function keyedCryptoFactory(url, kb, sthis) {
 }
 
 // src/blockstore/fragment-gateway.ts
-var import_cement8 = require("@adviser/cement");
+var import_cement6 = require("@adviser/cement");
 var import_base584 = require("multiformats/bases/base58");
 var import_cborg = require("@fireproof/vendor/cborg");
-init_utils();
 function getFragSize(url) {
   const fragSize = url.getParam("fragSize");
   let ret = 0;
@@ -2176,7 +1752,7 @@ async function getFrags(url, innerGW, headerSize, logger) {
     }
     const data = res.unwrap();
     return [
-      import_cement8.Result.Ok({
+      import_cement6.Result.Ok({
         fid: new Uint8Array(0),
         ofs: 0,
         len: data.length,
@@ -2190,7 +1766,7 @@ async function getFrags(url, innerGW, headerSize, logger) {
   }
   const firstFragment = (0, import_cborg.decode)(firstRaw.unwrap());
   const blockSize = firstFragment.data.length;
-  const ops = [Promise.resolve(import_cement8.Result.Ok(firstFragment))];
+  const ops = [Promise.resolve(import_cement6.Result.Ok(firstFragment))];
   const fidStr = import_base584.base58btc.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) {
@@ -2202,12 +1778,12 @@ async function getFrags(url, innerGW, headerSize, logger) {
         }
         const fragment = (0, import_cborg.decode)(raw2.unwrap());
         if (import_base584.base58btc.encode(fragment.fid) !== fidStr) {
-          return import_cement8.Result.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
+          return import_cement6.Result.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
         }
         if (fragment.ofs !== ofs2) {
-          return import_cement8.Result.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
+          return import_cement6.Result.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
         }
-        return import_cement8.Result.Ok(fragment);
+        return import_cement6.Result.Ok(fragment);
       })(fragUrl.setParam("ofs", ofs.toString()).URI(), ofs)
     );
   }
@@ -2269,40 +1845,40 @@ var FragmentGateway = class {
   }
   async put(url, body) {
     await Promise.all(this.slicer(url, body));
-    return import_cement8.Result.Ok(void 0);
+    return import_cement6.Result.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 import_cement8.Result.Err(rfrag.Err());
+        return import_cement6.Result.Err(rfrag.Err());
       }
       const frag = rfrag.Ok();
       buffer = buffer || new Uint8Array(frag.len);
       buffer.set(frag.data, frag.ofs);
     }
-    return import_cement8.Result.Ok(buffer || new Uint8Array(0));
+    return import_cement6.Result.Ok(buffer || new Uint8Array(0));
   }
   async subscribe(url, callback) {
     if (this.innerGW.subscribe) {
       return this.innerGW.subscribe(url, callback);
     } else {
-      return import_cement8.Result.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+      return import_cement6.Result.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
     }
   }
   async delete(url) {
     const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
     for (const rfrag of rfrags) {
       if (rfrag.isErr()) {
-        return import_cement8.Result.Err(rfrag.Err());
+        return import_cement6.Result.Err(rfrag.Err());
       }
       const frag = rfrag.Ok();
       const fidStr = import_base584.base58btc.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);
     }
-    return import_cement8.Result.Ok(void 0);
+    return import_cement6.Result.Ok(void 0);
   }
 };
 
@@ -2311,8 +1887,7 @@ var import_dag_json = require("@fireproof/vendor/@ipld/dag-json");
 var import_clock = require("@fireproof/vendor/@web3-storage/pail/clock");
 var import_multiformats2 = require("multiformats");
 var import_base64 = require("multiformats/bases/base64");
-var import_cement9 = require("@adviser/cement");
-init_utils();
+var import_cement7 = require("@adviser/cement");
 async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
   const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
   if (!Array.isArray(crdtEntries)) {
@@ -2358,13 +1933,13 @@ async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
         }
       }
       sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
-      return import_cement9.Result.Ok(dbMeta);
+      return import_cement7.Result.Ok(dbMeta);
     }
     sthis.logger.Debug().Any("data", data).Msg("No crypto in gateway meta payload");
-    return import_cement9.Result.Ok(void 0);
+    return import_cement7.Result.Ok(void 0);
   } catch (error) {
     sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
-    return import_cement9.Result.Err(error);
+    return import_cement7.Result.Err(error);
   }
 }
 async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
@@ -2385,10 +1960,10 @@ async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
     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 import_cement9.Result.Ok(encoded);
+    return import_cement7.Result.Ok(encoded);
   } catch (error) {
     sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
-    return import_cement9.Result.Err(error);
+    return import_cement7.Result.Err(error);
   }
 }
 function getStoreKeyName(url) {
@@ -2426,9 +2001,9 @@ var import_p_retry = __toESM(require("p-retry"), 1);
 var import_p_map = __toESM(require("p-map"), 1);
 function guardVersion(url) {
   if (!url.hasParam("version")) {
-    return import_cement10.Result.Err(`missing version: ${url.toString()}`);
+    return import_cement8.Result.Err(`missing version: ${url.toString()}`);
   }
-  return import_cement10.Result.Ok(url);
+  return import_cement8.Result.Ok(url);
 }
 var BaseStoreImpl = class {
   constructor(name, url, opts, sthis, logger) {
@@ -2488,7 +2063,7 @@ var BaseStoreImpl = class {
     }
     if (this.ready) {
       const fn = this.ready.bind(this);
-      const ready = await (0, import_cement10.exception2Result)(fn);
+      const ready = await (0, import_cement8.exception2Result)(fn);
       if (ready.isErr()) {
         await this.close();
         return ready;
@@ -2570,7 +2145,7 @@ var MetaStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement10.Result.Ok(void 0);
+    return import_cement8.Result.Ok(void 0);
   }
   async destroy() {
     return this.gateway.destroy(this.url());
@@ -2617,7 +2192,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement10.Result.Ok(void 0);
+    return import_cement8.Result.Ok(void 0);
   }
   destroy() {
     return this.gateway.destroy(this.url());
@@ -2627,7 +2202,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
   constructor(loader, url, opts) {
     super(loader.name, url, { ...opts }, loader.sthis, ensureLogger(loader.sthis, "WALStoreImpl"));
     this.storeType = "wal";
-    this._ready = new import_cement10.ResolveOnce();
+    this._ready = new import_cement8.ResolveOnce();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
@@ -2798,7 +2373,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement10.Result.Ok(void 0);
+    return import_cement8.Result.Ok(void 0);
   }
   destroy() {
     return this.gateway.destroy(this.url());
@@ -2806,7 +2381,6 @@ var WALStoreImpl = class extends BaseStoreImpl {
 };
 
 // src/blockstore/store-factory.ts
-init_utils();
 function ensureIsIndex(url, isIndex) {
   if (isIndex) {
     return url.build().setParam("index", isIndex).URI();
@@ -2825,15 +2399,15 @@ function buildURL(optURL, loader) {
   const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
   let obuUrl;
   if (obuItem && obuItem.overrideBaseURL) {
-    obuUrl = import_cement13.URI.from(obuItem.overrideBaseURL);
+    obuUrl = import_cement9.URI.from(obuItem.overrideBaseURL);
   }
   const ret = ensureIsIndex(
-    import_cement13.URI.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
+    import_cement9.URI.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
     storeOpts.isIndex
   );
   return ret;
 }
-var onceGateway = new import_cement13.KeyedResolvOnce();
+var onceGateway = new import_cement9.KeyedResolvOnce();
 async function getGatewayFromURL(url, sthis) {
   return onceGateway.get(url.toString()).once(async () => {
     const item = storeFactory.get(url.protocol);
@@ -2875,7 +2449,7 @@ function registerStoreProtocol(item) {
     storeFactory.delete(protocol);
   };
 }
-var onceDataStoreFactory = new import_cement13.KeyedResolvOnce();
+var onceDataStoreFactory = new import_cement9.KeyedResolvOnce();
 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() });
@@ -2893,7 +2467,7 @@ async function dataStoreFactory(loader) {
     return store;
   });
 }
-var onceMetaStoreFactory = new import_cement13.KeyedResolvOnce();
+var onceMetaStoreFactory = new import_cement9.KeyedResolvOnce();
 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() });
@@ -2912,7 +2486,7 @@ async function metaStoreFactory(loader) {
     return store;
   });
 }
-var onceRemoteWalFactory = new import_cement13.KeyedResolvOnce();
+var onceRemoteWalFactory = new import_cement9.KeyedResolvOnce();
 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() });
@@ -2966,28 +2540,32 @@ function toStoreRuntime(opts, sthis) {
     decodeFile: opts.decodeFile || decodeFile
   };
 }
-registerStoreProtocol({
-  protocol: "file:",
-  gateway: async (sthis) => {
-    const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
-    return new FileGateway2(sthis);
-  },
-  test: async (sthis) => {
-    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
-    return new FileTestStore2(sthis);
-  }
-});
-registerStoreProtocol({
-  protocol: "indexdb:",
-  gateway: async (sthis) => {
-    const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
-    return new IndexDBGateway2(sthis);
-  },
-  test: async (sthis) => {
-    const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
-    return new IndexDBTestStore2(sthis);
-  }
-});
+if ((0, import_cement9.runtimeFn)().isNodeIsh || (0, import_cement9.runtimeFn)().isDeno) {
+  registerStoreProtocol({
+    protocol: "file:",
+    gateway: async (sthis) => {
+      const { GatewayImpl } = await import("@fireproof/core/node");
+      return new GatewayImpl(sthis);
+    },
+    test: async (sthis) => {
+      const { GatewayTestImpl } = await import("@fireproof/core/node");
+      return new GatewayTestImpl(sthis);
+    }
+  });
+}
+if ((0, import_cement9.runtimeFn)().isBrowser) {
+  registerStoreProtocol({
+    protocol: "indexdb:",
+    gateway: async (sthis) => {
+      const { GatewayImpl } = await import("@fireproof/core/web");
+      return new GatewayImpl(sthis);
+    },
+    test: async (sthis) => {
+      const { GatewayTestImpl } = await import("@fireproof/core/web");
+      return new GatewayTestImpl(sthis);
+    }
+  });
+}
 
 // src/blockstore/store-remote.ts
 async function RemoteDataStore(sthis, name, url, opts) {
@@ -3362,7 +2940,7 @@ var import_sha26 = require("multiformats/hashes/sha2");
 var codec2 = __toESM(require("@fireproof/vendor/@ipld/dag-cbor"), 1);
 var import_charwise = __toESM(require("charwise"), 1);
 var DbIndex = __toESM(require("prolly-trees/db-index"), 1);
-var import_utils14 = require("prolly-trees/utils");
+var import_utils9 = require("prolly-trees/utils");
 var import_cache = require("prolly-trees/cache");
 var IndexTree = class {
 };
@@ -3370,17 +2948,17 @@ function refCompare(aRef, bRef) {
   if (Number.isNaN(aRef)) return -1;
   if (Number.isNaN(bRef)) throw new Error("ref may not be Infinity or NaN");
   if (aRef === Infinity) return 1;
-  return (0, import_utils14.simpleCompare)(aRef, bRef);
+  return (0, import_utils9.simpleCompare)(aRef, bRef);
 }
 function compare(a, b) {
   const [aKey, aRef] = a;
   const [bKey, bRef] = b;
-  const comp = (0, import_utils14.simpleCompare)(aKey, bKey);
+  const comp = (0, import_utils9.simpleCompare)(aKey, bKey);
   if (comp !== 0) return comp;
   return refCompare(aRef, bRef);
 }
-var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils14.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare };
-var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils14.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare: import_utils14.simpleCompare };
+var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils9.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare };
+var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils9.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare: import_utils9.simpleCompare };
 function indexEntriesForChanges(changes, mapFn) {
   const indexEntries = [];
   changes.forEach(({ id: key, value, del }) => {
@@ -3479,7 +3057,6 @@ function encodeKey(key) {
 }
 
 // src/indexer.ts
-init_utils();
 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();
@@ -3688,7 +3265,7 @@ var Index = class {
 // src/crdt-clock.ts
 var import_clock3 = require("@fireproof/vendor/@web3-storage/pail/clock");
 var import_crdt2 = require("@fireproof/vendor/@web3-storage/pail/crdt");
-var import_cement14 = require("@adviser/cement");
+var import_cement10 = require("@adviser/cement");
 
 // src/apply-head-queue.ts
 function applyHeadQueue(worker, logger) {
@@ -3736,7 +3313,6 @@ function applyHeadQueue(worker, logger) {
 }
 
 // src/crdt-clock.ts
-init_utils();
 var CRDTClock = class {
   constructor(blockstore) {
     // todo: track local and remote clocks independently, merge on read
@@ -3746,7 +3322,7 @@ var CRDTClock = class {
     this.zoomers = /* @__PURE__ */ new Set();
     this.watchers = /* @__PURE__ */ new Set();
     this.emptyWatchers = /* @__PURE__ */ new Set();
-    this._ready = new import_cement14.ResolveOnce();
+    this._ready = new import_cement10.ResolveOnce();
     this.blockstore = blockstore;
     this.logger = ensureLogger(blockstore.sthis, "CRDTClock");
     this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
@@ -3856,11 +3432,10 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 }
 
 // src/crdt.ts
-init_utils();
 var CRDT = class {
   constructor(sthis, name, opts = {}) {
     this.indexers = /* @__PURE__ */ new Map();
-    this.onceReady = new import_cement15.ResolveOnce();
+    this.onceReady = new import_cement11.ResolveOnce();
     this.sthis = sthis;
     this.name = name;
     this.logger = ensureLogger(sthis, "CRDT");
@@ -3974,14 +3549,13 @@ var CRDT = class {
 };
 
 // src/database.ts
-init_utils();
 var Database = class {
   constructor(name, opts) {
     this.opts = {};
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new import_cement16.ResolveOnce();
+    this._ready = new import_cement12.ResolveOnce();
     this.name = name;
     this.opts = opts || this.opts;
     this.sthis = ensureSuperThis(this.opts);
@@ -4188,14 +3762,39 @@ __export(runtime_exports, {
   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: () => import_cement17.runtimeFn
+  runtimeFn: () => import_cement13.runtimeFn
 });
-init_utils2();
+
+// src/runtime/gateways/file/node/utils.ts
+var import_core = require("@fireproof/core");
+function getPath(url, sthis) {
+  const basePath = url.pathname;
+  const name = url.getParam("name");
+  if (name) {
+    const version = url.getParam("version");
+    if (!version) throw sthis.logger.Error().Url(url).Msg(`version not found`).AsError();
+    return sthis.pathOps.join(basePath, version, 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 = (0, import_core.getStore)(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 = {};
@@ -4208,17 +3807,16 @@ __export(wait_pr_multiformats_exports, {
 var codec_interface_exports = {};
 
 // src/runtime/index.ts
-var import_cement17 = require("@adviser/cement");
-init_version();
+var import_cement13 = require("@adviser/cement");
+
+// src/runtime/gateways/file/version.ts
+var FILESTORE_VERSION = "v0.19-file";
 
 // src/runtime/gateways/indexdb/version.ts
 var INDEXDB_VERSION = "v0.19-indexdb";
 
-// src/index.ts
-init_utils();
-
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.121-dev": "xxxx"
+  "0.19.121": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map