@fireproof/core 0.19.121-dev → 0.19.121

package/index.js

@@ -1,32 +1,11 @@
-import {
-  FILESTORE_VERSION
-} from "./chunk-7EWIAXTM.js";
-import {
-  getFileName,
-  getFileSystem,
-  getPath
-} from "./chunk-F4FC6B2T.js";
-import {
-  NotFoundError,
-  Result,
-  UInt8ArrayEqual,
-  dataDir,
-  ensureLogger,
-  ensureSuperLog,
-  ensureSuperThis,
-  exceptionWrapper,
-  getKey,
-  getName,
-  getStore,
-  isNotFoundError,
-  onSuperThis
-} from "./chunk-RXC4JGJT.js";
-import {
-  __export
-} from "./chunk-PZ5AY32C.js";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/database.ts
-import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce7 } from "@adviser/cement";
 
 // src/write-queue.ts
 function writeQueue(worker, payload = Infinity, unbounded = false) {
@@ -69,7 +48,7 @@ function writeQueue(worker, payload = Infinity, unbounded = false) {
 }
 
 // src/crdt.ts
-import { ResolveOnce as ResolveOnce5 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce6 } from "@adviser/cement";
 
 // src/runtime/wait-pr-multiformats/block.ts
 var block_exports = {};
@@ -177,7 +156,7 @@ function toCIDBlock(block) {
 }
 
 // src/blockstore/store-factory.ts
-import { KeyedResolvOnce as KeyedResolvOnce2, URI as URI5 } from "@adviser/cement";
+import { KeyedResolvOnce as KeyedResolvOnce2, URI as URI6, runtimeFn as runtimeFn3 } from "@adviser/cement";
 
 // src/runtime/files.ts
 var files_exports = {};
@@ -252,7 +231,7 @@ 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) {
@@ -271,10 +250,295 @@ function falsyToUndef(value) {
   return value;
 }
 
+// src/utils.ts
+import {
+  LoggerImpl,
+  IsLogger,
+  Result,
+  ResolveOnce,
+  isURL,
+  URI,
+  runtimeFn,
+  envFactory,
+  toCryptoRuntime,
+  JSONFormatter,
+  YAMLFormatter
+} from "@adviser/cement";
+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("/");
+  }
+  // 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);
+  };
+}
+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 (IsLogger(sthis)) {
+    logger = sthis;
+  } else 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 ("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();
+  return out;
+}
+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 };
+}
+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;
+}
+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 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 dataDir(sthis, name, base) {
+  if (!base) {
+    if (!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 URI.from(base.toString()).build().setParam("name", name || "").URI();
+}
+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;
+}
+
 // src/blockstore/loader.ts
 import pLimit from "p-limit";
 import { CarReader } from "@fireproof/vendor/@ipld/car/reader";
-import { ResolveOnce as ResolveOnce2 } from "@adviser/cement";
+import { ResolveOnce as ResolveOnce3 } from "@adviser/cement";
 
 // src/blockstore/loader-helpers.ts
 import { sha256 as hasher } from "multiformats/hashes/sha2";
@@ -293,7 +557,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();
@@ -328,7 +592,7 @@ function defaultedBlockstoreRuntime(sthis, opts, component, ctx) {
     ...opts,
     logger,
     keyBag: opts.keyBag || {},
-    crypto: toCryptoRuntime(opts.crypto),
+    crypto: toCryptoRuntime2(opts.crypto),
     store,
     storeRuntime: toStoreRuntime(store, sthis)
   };
@@ -564,18 +828,18 @@ __export(key_bag_exports, {
 });
 import {
   KeyedResolvOnce,
-  ResolveOnce,
+  ResolveOnce as ResolveOnce2,
   ResolveSeq,
   Result as Result2,
-  runtimeFn,
-  toCryptoRuntime as toCryptoRuntime2,
-  URI
+  runtimeFn as runtimeFn2,
+  toCryptoRuntime as toCryptoRuntime3,
+  URI as URI2
 } from "@adviser/cement";
-import { base58btc } from "multiformats/bases/base58";
+import { base58btc as base58btc2 } from "multiformats/bases/base58";
 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.Debug().Msg("KeyBag created");
@@ -590,7 +854,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,
@@ -620,12 +884,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 +918,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 +937,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 +948,15 @@ var keyBagProviderFactories = new Map(
     {
       protocol: "file:",
       factory: async (url, sthis) => {
-        const { KeyBagProviderFile } = await import("./key-bag-file-PWZ3QE7B.js");
-        return new KeyBagProviderFile(url, sthis);
+        const { KeyBagProviderImpl } = await import("@fireproof/core/node");
+        return new KeyBagProviderImpl(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);
       }
     }
   ].map((i) => [i.protocol, i])
@@ -707,15 +971,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 = URI2.from(bagFnameOrUrl || "indexdb://fp-keybag");
   } else {
     if (!bagFnameOrUrl) {
       const home = sthis.env.get("HOME");
       bagFnameOrUrl = `${home}/.fireproof/keybag`;
-      url = URI.from(`file://${bagFnameOrUrl}`);
+      url = URI2.from(`file://${bagFnameOrUrl}`);
     } else {
-      url = URI.from(bagFnameOrUrl);
+      url = URI2.from(bagFnameOrUrl);
     }
   }
   const logger = ensureLogger(sthis, "defaultKeyBagUrl");
@@ -729,7 +993,7 @@ function defaultKeyBagOpts(sthis, kbo) {
   const logger = ensureLogger(sthis, "KeyBag");
   let url;
   if (kbo.url) {
-    url = URI.from(kbo.url);
+    url = URI2.from(kbo.url);
     logger.Debug().Url(url).Msg("from opts");
   } else {
     url = defaultKeyBagUrl(sthis);
@@ -744,7 +1008,7 @@ function defaultKeyBagOpts(sthis, kbo) {
   }
   return {
     url,
-    crypto: kbo.crypto || toCryptoRuntime2({}),
+    crypto: kbo.crypto || toCryptoRuntime3({}),
     sthis,
     logger,
     keyLength: kbo.keyLength || 16,
@@ -938,7 +1202,7 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = pLimit(1);
-    this.onceReady = new ResolveOnce2();
+    this.onceReady = new ResolveOnce3();
     this.name = name;
     this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
@@ -1263,7 +1527,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 = {
@@ -1308,7 +1572,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 +1589,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)) {
@@ -1431,7 +1695,7 @@ async function keyedCryptoFactory(url, kb, sthis) {
 
 // src/blockstore/fragment-gateway.ts
 import { Result as Result3 } from "@adviser/cement";
-import { base58btc as base58btc3 } from "multiformats/bases/base58";
+import { base58btc as base58btc4 } from "multiformats/bases/base58";
 import { encode as encode3, decode as decode3 } from "@fireproof/vendor/cborg";
 function getFragSize(url) {
   const fragSize = url.getParam("fragSize");
@@ -1468,7 +1732,7 @@ async function getFrags(url, innerGW, headerSize, logger) {
   const firstFragment = decode3(firstRaw.unwrap());
   const blockSize = firstFragment.data.length;
   const ops = [Promise.resolve(Result3.Ok(firstFragment))];
-  const fidStr = base58btc3.encode(firstFragment.fid);
+  const fidStr = base58btc4.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(
@@ -1478,7 +1742,7 @@ async function getFrags(url, innerGW, headerSize, logger) {
           return raw2;
         }
         const fragment = decode3(raw2.unwrap());
-        if (base58btc3.encode(fragment.fid) !== fidStr) {
+        if (base58btc4.encode(fragment.fid) !== fidStr) {
           return Result3.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
         }
         if (fragment.ofs !== ofs2) {
@@ -1575,7 +1839,7 @@ var FragmentGateway = class {
         return Result3.Err(rfrag.Err());
       }
       const frag = rfrag.Ok();
-      const fidStr = base58btc3.encode(frag.fid);
+      const fidStr = base58btc4.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);
     }
@@ -1903,7 +2167,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 ResolveOnce3();
+    this._ready = new ResolveOnce4();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
@@ -2100,10 +2364,10 @@ function buildURL(optURL, loader) {
   const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
   let obuUrl;
   if (obuItem && obuItem.overrideBaseURL) {
-    obuUrl = URI5.from(obuItem.overrideBaseURL);
+    obuUrl = URI6.from(obuItem.overrideBaseURL);
   }
   const ret = ensureIsIndex(
-    URI5.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
+    URI6.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
     storeOpts.isIndex
   );
   return ret;
@@ -2241,28 +2505,32 @@ function toStoreRuntime(opts, sthis) {
     decodeFile: opts.decodeFile || decodeFile
   };
 }
-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);
-  }
-});
+if (runtimeFn3().isNodeIsh || runtimeFn3().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 (runtimeFn3().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) {
@@ -2962,7 +3230,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 +3287,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);
@@ -3132,7 +3400,7 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 var CRDT = class {
   constructor(sthis, name, 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");
@@ -3252,7 +3520,7 @@ var Database = class {
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new ResolveOnce6();
+    this._ready = new ResolveOnce7();
     this.name = name;
     this.opts = opts || this.opts;
     this.sthis = ensureSuperThis(this.opts);
@@ -3459,14 +3727,40 @@ __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: () => runtimeFn2
+  runtimeFn: () => runtimeFn4
 });
 
+// src/runtime/gateways/file/node/utils.ts
+import { getStore as getStore2 } from "@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 = 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, {
@@ -3478,14 +3772,17 @@ __export(wait_pr_multiformats_exports, {
 var codec_interface_exports = {};
 
 // src/runtime/index.ts
-import { runtimeFn as runtimeFn2 } from "@adviser/cement";
+import { runtimeFn as runtimeFn4 } from "@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/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.121-dev": "xxxx"
+  "0.19.121": "xxxx"
 })[0];
 export {
   CRDT,