@fireproof/core 0.19.111 → 0.19.112-dev-iife

package/index.global.js

@@ -34,13 +34,13 @@ var Fireproof = (() => {
   ));
   var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
-  // node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-GES3MUGV.js
+  // node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-GES3MUGV.js
   function Utf8EnDecoderSingleton() {
     return utf8EnDecoder;
   }
   var __defProp2, __defProps, __getOwnPropDescs, __getOwnPropSymbols, __hasOwnProp2, __propIsEnum, __typeError, __defNormalProp, __spreadValues, __spreadProps, __export2, __accessCheck, __privateGet, __privateAdd, __privateSet, encoder, decoder, Utf8EnDecoder, utf8EnDecoder;
   var init_chunk_GES3MUGV = __esm({
-    "node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-GES3MUGV.js"() {
+    "node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-GES3MUGV.js"() {
       "use strict";
       __defProp2 = Object.defineProperty;
       __defProps = Object.defineProperties;
@@ -86,7 +86,7 @@ var Fireproof = (() => {
     }
   });
 
-  // node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-7KFVMTOS.js
+  // node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-USQXEZHL.js
   function streamMap(s, sm) {
     const state = { reader: s.getReader(), streamMap: sm, idx: 0 };
     return new ReadableStream({
@@ -261,8 +261,8 @@ var Fireproof = (() => {
     });
   }
   var utils_exports, ConsoleWriterStreamDefaultWriter, ConsoleWriterStream, FanoutWriteStream;
-  var init_chunk_7KFVMTOS = __esm({
-    "node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-7KFVMTOS.js"() {
+  var init_chunk_USQXEZHL = __esm({
+    "node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-USQXEZHL.js"() {
       "use strict";
       init_chunk_GES3MUGV();
       utils_exports = {};
@@ -302,22 +302,22 @@ var Fireproof = (() => {
           this.closed = Promise.resolve(void 0);
         }
         async write(chunk) {
-          const str = this.decoder.decode(chunk).trimEnd();
+          let strObj = this.decoder.decode(chunk).trimEnd();
           let output = "log";
           try {
-            const decode17 = JSON.parse(str);
-            output = decode17.level;
+            strObj = JSON.parse(strObj);
+            output = strObj.level;
           } catch (e) {
           }
           switch (output) {
             case "error":
-              console.error(str);
+              console.error(strObj);
               break;
             case "warn":
-              console.warn(str);
+              console.warn(strObj);
               break;
             default:
-              console.log(str);
+              console.log(strObj);
           }
         }
       };
@@ -370,7 +370,7 @@ var Fireproof = (() => {
     }
   });
 
-  // node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-Q65HLCNL.js
+  // node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-Q65HLCNL.js
   function TimeFactory(timeMode) {
     switch (timeMode) {
       case "real":
@@ -395,7 +395,7 @@ var Fireproof = (() => {
   }
   var Time, SysTime, ConstTime, StepTime, RandomService, IdService, BaseSysAbstraction, WrapperSysAbstraction, _promise, _resolveFn, _rejectFn, Future, ResolveSeq, ResolveOnce, Keyed, KeyedResolvOnce, _node, NodeEnvActions, _deno, DenoEnvActions, BrowserEnvActions, _envFactory, EnvImpl;
   var init_chunk_Q65HLCNL = __esm({
-    "node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-Q65HLCNL.js"() {
+    "node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-Q65HLCNL.js"() {
       "use strict";
       init_chunk_GES3MUGV();
       Time = class {
@@ -894,7 +894,7 @@ var Fireproof = (() => {
     }
   });
 
-  // node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-WMMUXBDX.js
+  // node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-WMMUXBDX.js
   function WebSysAbstraction(param) {
     if (!my) {
       my = new BaseSysAbstraction({
@@ -907,7 +907,7 @@ var Fireproof = (() => {
   }
   var WebFileService, WebSystemService, my;
   var init_chunk_WMMUXBDX = __esm({
-    "node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/chunk-WMMUXBDX.js"() {
+    "node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/chunk-WMMUXBDX.js"() {
       "use strict";
       init_chunk_Q65HLCNL();
       init_chunk_GES3MUGV();
@@ -8095,7 +8095,7 @@ ${end.comment}` : end.comment;
     }
   });
 
-  // node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/index.js
+  // node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/index.js
   function bin2text(hex, lineFn, size = 0) {
     const arr = new Uint8Array(hex.buffer, hex.byteOffset, hex.byteLength);
     let cutted = "  ";
@@ -8140,16 +8140,6 @@ ${end.comment}` : end.comment;
     );
     return collector.join("\n");
   }
-  function removeSelfRef(lineEnd) {
-    const cache2 = /* @__PURE__ */ new Set();
-    return function(key, value) {
-      if (typeof value === "object" && value !== null) {
-        if (cache2.has(value)) return "...";
-        cache2.add(value);
-      }
-      return lineEnd ? value + lineEnd : value;
-    };
-  }
   function asyncLogValue(val) {
     throw new Error("Not implemented");
   }
@@ -8176,19 +8166,31 @@ ${end.comment}` : end.comment;
       case "boolean":
         return new LogValue(() => val);
       case "object": {
+        if (val === null) {
+          return new LogValue(() => "null");
+        }
         if (ArrayBuffer.isView(val)) {
           return logValue(bin2string(val, 512));
         }
         if (Array.isArray(val)) {
           return new LogValue(() => val.map((v) => logValue(v).value()));
         }
-        if (val === null) {
-          return new LogValue(() => "null");
+        if (val instanceof Headers) {
+          return new LogValue(() => Object.fromEntries(val.entries()));
+        }
+        if (val instanceof ReadableStream) {
+          return new LogValue(() => ">Stream<");
+        }
+        if (val instanceof Promise) {
+          return new LogValue(() => ">Promise<");
         }
         if (state.has(val)) {
           return new LogValue(() => "...");
         }
         state.add(val);
+        if (typeof val.toJSON === "function") {
+          return new LogValue(() => val.toJSON());
+        }
         const res = {};
         const typedVal = val;
         for (const key in typedVal) {
@@ -8196,7 +8198,9 @@ ${end.comment}` : end.comment;
           if (element instanceof LogValue) {
             res[key] = element;
           } else {
-            res[key] = logValue(element, state);
+            if (typeof element !== "function") {
+              res[key] = logValue(element, state);
+            }
           }
         }
         return new LogValue(() => res);
@@ -8239,6 +8243,72 @@ ${end.comment}` : end.comment;
       return Result.Err(e);
     }
   }
+  function stripper(strip, obj) {
+    const strips = Array.isArray(strip) ? strip : [strip];
+    const restrips = strips.map((s) => {
+      if (typeof s === "string") {
+        const escaped = s.replace(/[-\\[\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\^\\$\\|]/g, "\\$&");
+        return new RegExp(`^${escaped}$`);
+      }
+      return s;
+    });
+    return localStripper(void 0, restrips, obj);
+  }
+  function localStripper(path, restrips, obj) {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((i) => localStripper(path, restrips, i));
+    }
+    const ret = __spreadValues({}, obj);
+    const matcher = (key, nextPath) => {
+      for (const re of restrips) {
+        if (re.test(key) || re.test(nextPath)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    for (const key in ret) {
+      if (Object.prototype.hasOwnProperty.call(ret, key)) {
+        let nextPath;
+        if (path) {
+          nextPath = [path, key].join(".");
+        } else {
+          nextPath = key;
+        }
+        if (matcher(key, nextPath)) {
+          delete ret[key];
+          continue;
+        }
+        if (typeof ret[key] === "object") {
+          if (Array.isArray(ret[key])) {
+            ret[key] = ret[key].reduce((acc, v, i) => {
+              const toDelete = matcher(key, `${nextPath}[${i}]`);
+              if (!toDelete) {
+                acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
+              }
+              return acc;
+            }, []);
+          } else {
+            ret[key] = localStripper(nextPath, restrips, ret[key]);
+          }
+        }
+      }
+    }
+    return ret;
+  }
+  function coerceKey(key, def) {
+    if (typeof key === "object") {
+      const keys = Object.keys(key);
+      if (keys.length !== 1) {
+        throw new Error(`Invalid key: ${JSON.stringify(key)}`);
+      }
+      return { key: keys[0], def: key[keys[0]] };
+    }
+    return { key, def };
+  }
   function falsy2undef(value) {
     return value === void 0 || value === null ? void 0 : value;
   }
@@ -8278,6 +8348,49 @@ ${end.comment}` : end.comment;
         throw new Error(`Invalid argument: ${typeof strURLUri}`);
     }
   }
+  function getParamResult(key, val, msgFn = (key2) => {
+    return `missing parameter: ${key2}`;
+  }) {
+    if (val === void 0) {
+      return Result.Err(msgFn(key));
+    }
+    return Result.Ok(val);
+  }
+  function getParamsResult(keys, getParam) {
+    const keyDef = keys.flat().reduce(
+      (acc, i) => {
+        if (typeof i === "string") {
+          acc.push({ key: i });
+        } else if (typeof i === "object") {
+          acc.push(...Object.keys(i).map((k) => ({ key: k, def: i[k] })));
+        }
+        return acc;
+      },
+      []
+    );
+    const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
+      const msg = keys2.join(",");
+      return `missing parameters: ${msg}`;
+    });
+    const errors = [];
+    const result = {};
+    for (const kd of keyDef) {
+      const val = getParam.getParam(kd.key);
+      if (val === void 0) {
+        if (kd.def) {
+          result[kd.key] = kd.def;
+        } else {
+          errors.push(kd.key);
+        }
+      } else {
+        result[kd.key] = val;
+      }
+    }
+    if (errors.length) {
+      return Result.Err(msgFn(...errors));
+    }
+    return Result.Ok(result);
+  }
   function isSet(value, ref = globalThis) {
     const [head, ...tail] = value.split(".");
     if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
@@ -8353,9 +8466,9 @@ ${end.comment}` : end.comment;
   }
   var LogValue, Result, ResultOK, ResultError, MutableURL, BuildURI, hasHostPartProtocols, URI, LogWriterStream, LevelHandlerImpl, levelSingleton, JSONFormatter, YAMLFormatter, LoggerImpl, WithLoggerBuilder, VERSION;
   var init_cement = __esm({
-    "node_modules/.pnpm/@adviser+cement@0.2.31_typescript@5.6.2/node_modules/@adviser/cement/index.js"() {
+    "node_modules/.pnpm/@adviser+cement@0.2.36_typescript@5.6.2/node_modules/@adviser/cement/index.js"() {
       "use strict";
-      init_chunk_7KFVMTOS();
+      init_chunk_USQXEZHL();
       init_chunk_WMMUXBDX();
       init_chunk_Q65HLCNL();
       init_chunk_GES3MUGV();
@@ -8365,7 +8478,11 @@ ${end.comment}` : end.comment;
           this.fn = fn;
         }
         value() {
-          return this.fn();
+          try {
+            return this.fn();
+          } catch (e) {
+            return `LogValue:${e.message}`;
+          }
         }
         toJSON() {
           return this.value();
@@ -8592,6 +8709,22 @@ ${end.comment}` : end.comment;
         //   this._url.host = h;
         //   return this;
         // }
+        appendRelative(p) {
+          const appendUrl = URI.from(p);
+          let pathname = appendUrl.pathname;
+          let basePath = this._url.pathname;
+          if (pathname.startsWith("/")) {
+            pathname = pathname.replace(/^\//, "");
+          }
+          if (basePath.length > 0) {
+            basePath = basePath.replace(/\/$/, "");
+          }
+          this.pathname(basePath + "/" + pathname);
+          for (const [key, value] of appendUrl.getParams) {
+            this.setParam(key, value);
+          }
+          return this;
+        }
         delParam(key) {
           this._url.searchParams.delete(key);
           return this;
@@ -8609,8 +8742,22 @@ ${end.comment}` : end.comment;
         hasParam(key) {
           return this._url.searchParams.has(key);
         }
-        getParam(key) {
-          return falsy2undef(this._url.searchParams.get(key));
+        get getParams() {
+          return this._url.searchParams.entries();
+        }
+        getParam(key, def) {
+          const { key: k, def: d } = coerceKey(key, def);
+          let val = this._url.searchParams.get(k);
+          if (!falsy2undef(val) && d) {
+            val = d;
+          }
+          return falsy2undef(val);
+        }
+        getParamResult(key, msgFn) {
+          return getParamResult(key, this.getParam(key), msgFn);
+        }
+        getParamsResult(...keys) {
+          return getParamsResult(keys, this);
         }
         toString() {
           this._url.searchParams.sort();
@@ -8619,6 +8766,15 @@ ${end.comment}` : end.comment;
         toJSON() {
           return this.toString();
         }
+        asURL() {
+          return this.URI().asURL();
+        }
+        asObj(...strips) {
+          return this.URI().asObj(...strips);
+        }
+        clone() {
+          return _BuildURI.from(this.toString());
+        }
         URI() {
           return URI.from(this._url);
         }
@@ -8698,8 +8854,19 @@ ${end.comment}` : end.comment;
         hasParam(key) {
           return this._url.searchParams.has(key);
         }
-        getParam(key) {
-          return falsy2undef(this._url.searchParams.get(key));
+        getParam(key, def) {
+          const { key: k, def: d } = coerceKey(key, def);
+          let val = this._url.searchParams.get(k);
+          if (!falsy2undef(val) && d) {
+            val = d;
+          }
+          return falsy2undef(val);
+        }
+        getParamResult(key, msgFn) {
+          return getParamResult(key, this.getParam(key), msgFn);
+        }
+        getParamsResult(...keys) {
+          return getParamsResult(keys, this);
         }
         clone() {
           return new _URI(this._url);
@@ -8713,7 +8880,7 @@ ${end.comment}` : end.comment;
         toJSON() {
           return this.toString();
         }
-        asObj() {
+        asObj(...strips) {
           const pathURI = {
             style: "path",
             protocol: this.protocol,
@@ -8721,13 +8888,13 @@ ${end.comment}` : end.comment;
             searchParams: Object.fromEntries(this.getParams)
           };
           if (hasHostPartProtocols.has(this.protocol.replace(/:$/, ""))) {
-            return __spreadProps(__spreadValues({}, pathURI), {
+            return stripper(strips, __spreadProps(__spreadValues({}, pathURI), {
               style: "host",
               hostname: this.hostname,
               port: this.port
-            });
+            }));
           }
-          return pathURI;
+          return stripper(strips, pathURI);
         }
       };
       LogWriterStream = class {
@@ -8863,7 +9030,13 @@ ${end.comment}` : end.comment;
           this._space = space;
         }
         format(attr) {
-          return this._txtEnDe.encode(JSON.stringify(attr, removeSelfRef(), this._space) + "\n");
+          let ret;
+          try {
+            ret = JSON.stringify(attr, null, this._space);
+          } catch (e) {
+            ret = JSON.stringify({ internal: { message: e.message, stack: e.stack } });
+          }
+          return this._txtEnDe.encode(ret + "\n");
         }
       };
       YAMLFormatter = class {
@@ -8872,7 +9045,7 @@ ${end.comment}` : end.comment;
           this._space = space;
         }
         format(attr) {
-          return this._txtEnDe.encode("---\n" + browser_default.stringify(attr, removeSelfRef(), this._space) + "\n");
+          return this._txtEnDe.encode("---\n" + browser_default.stringify(attr, null, this._space) + "\n");
         }
       };
       LoggerImpl = class _LoggerImpl {
@@ -8933,7 +9106,7 @@ ${end.comment}` : end.comment;
           return this._txtEnDe;
         }
         Attributes() {
-          return JSON.parse(JSON.stringify(this._attributes, removeSelfRef()));
+          return JSON.parse(JSON.stringify(this._attributes, null));
         }
         SetExposeStack(enable) {
           this._levelHandler.setExposeStack(enable);
@@ -9029,7 +9202,37 @@ ${end.comment}` : end.comment;
           return this;
         }
         Bool(key, value) {
-          this._attributes[key] = logValue(!!value);
+          this.coerceKey(key, !!value);
+          return this;
+        }
+        Http(res, req, key) {
+          if (Result.Is(res)) {
+            if (res.isErr()) {
+              this.Err(res.Err());
+              return this;
+            }
+            res = res.Ok();
+          }
+          let reqRes = res;
+          if (req) {
+            reqRes = { res, req };
+          }
+          this.Any(key || "Http", reqRes);
+          return this;
+        }
+        Pair(x) {
+          for (const key of Object.keys(x)) {
+            const value = x[key];
+            if (value instanceof LogValue) {
+              this._attributes[key] = value;
+              continue;
+            }
+            if (Result.Is(value)) {
+              this.Result(key, value);
+              continue;
+            }
+            this.Any(key, value);
+          }
           return this;
         }
         Result(key, res) {
@@ -9052,12 +9255,19 @@ ${end.comment}` : end.comment;
           this.Ref(key, () => URI.from(url).toString());
           return this;
         }
+        coerceKey(key, value) {
+          if (typeof key === "string") {
+            this._attributes[key] = logValue(value);
+          } else {
+            this.Pair(key);
+          }
+        }
         Str(key, value) {
-          this._attributes[key] = logValue(value);
+          this.coerceKey(key, value);
           return this;
         }
         Any(key, value) {
-          this._attributes[key] = logValue(value);
+          this.coerceKey(key, value);
           return this;
         }
         Dur(key, nsec) {
@@ -9065,7 +9275,7 @@ ${end.comment}` : end.comment;
           return this;
         }
         Uint64(key, value) {
-          this._attributes[key] = logValue(value);
+          this.coerceKey(key, value);
           return this;
         }
         Int(key, value) {
@@ -9117,8 +9327,10 @@ ${end.comment}` : end.comment;
             }
             return fnRet;
           });
+          const asError = () => new Error(this._txtEnDe.decode(fnError()));
           return {
-            AsError: () => new Error(this._txtEnDe.decode(fnError()))
+            ResultError: () => Result.Err(asError()),
+            AsError: asError
           };
         }
       };
@@ -9160,6 +9372,14 @@ ${end.comment}` : end.comment;
           this._li.SetDebug(...modules);
           return this;
         }
+        Http(res, req, key) {
+          this._li.Http(res, req, key);
+          return this;
+        }
+        Pair(x) {
+          this._li.Pair(x);
+          return this;
+        }
         Str(key, value) {
           this._li.Str(key, value);
           return this;
@@ -12095,7 +12315,9 @@ ${end.comment}` : end.comment;
       };
       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)
       };
       NotFoundError2 = class extends Error {
@@ -12204,6 +12426,128 @@ ${end.comment}` : end.comment;
     }
   });
 
+  // src/runtime/gateways/file/utils.ts
+  var utils_exports2 = {};
+  __export(utils_exports2, {
+    getFileName: () => getFileName,
+    getFileSystem: () => getFileSystem,
+    getPath: () => getPath
+  });
+  async function getFileSystem(url) {
+    const name6 = url.getParam("fs", "node");
+    let fs;
+    switch (name6) {
+      case "mem":
+        fs = await externalLoaders.get(name6).once(async () => {
+          const { MemFileSystem } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
+          return new MemFileSystem();
+        });
+        break;
+      // case 'deno': {
+      //   const { DenoFileSystem } = await import("./deno-filesystem.js");
+      //   fs = new DenoFileSystem();
+      //   break;
+      // }
+      default:
+        fs = await externalLoaders.get(name6).once(async () => {
+          const { NodeFileSystem } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
+          return new NodeFileSystem();
+        });
+    }
+    return fs.start();
+  }
+  function getPath(url, sthis) {
+    const basePath = url.pathname;
+    const name6 = url.getParam("name");
+    if (name6) {
+      const version = url.getParam("version");
+      if (!version) throw sthis.logger.Error().Url(url).Msg(`version not found`).AsError();
+      return sthis.pathOps.join(basePath, version, name6);
+    }
+    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 = 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 externalLoaders;
+  var init_utils2 = __esm({
+    "src/runtime/gateways/file/utils.ts"() {
+      "use strict";
+      init_cement();
+      init_utils();
+      externalLoaders = new KeyedResolvOnce();
+    }
+  });
+
+  // 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_exports2));
+              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);
+        }
+      };
+    }
+  });
+
   // node_modules/.pnpm/idb@8.0.0/node_modules/idb/build/index.js
   function getIdbProxyableTypes() {
     return idbProxyableTypes || (idbProxyableTypes = [
@@ -12443,124 +12787,6 @@ ${end.comment}` : end.comment;
     }
   });
 
-  // src/runtime/gateways/file/node-filesystem.ts
-  var node_filesystem_exports = {};
-  __export(node_filesystem_exports, {
-    NodeFileSystem: () => NodeFileSystem
-  });
-  var NodeFileSystem;
-  var init_node_filesystem = __esm({
-    "src/runtime/gateways/file/node-filesystem.ts"() {
-      "use strict";
-      init_utils2();
-      init_cement();
-      NodeFileSystem = class {
-        async start() {
-          this.fs = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-          return this;
-        }
-        async mkdir(path, options) {
-          return this.fs?.mkdir(path, options);
-        }
-        async readdir(path, options) {
-          return this.fs?.readdir(path, options);
-        }
-        async rm(path, options) {
-          return this.fs?.rm(path, options);
-        }
-        async copyFile(source, destination) {
-          return this.fs?.copyFile(source, destination);
-        }
-        async readfile(path, options) {
-          const ret = await this.fs?.readFile(path, options);
-          return toArrayBuffer(ret);
-        }
-        stat(path) {
-          return this.fs?.stat(path);
-        }
-        async unlink(path) {
-          return this.fs?.unlink(path);
-        }
-        async writefile(path, data) {
-          if (runtimeFn().isDeno) {
-            return this.fs?.writeFile(path, data);
-          }
-          return this.fs?.writeFile(path, Buffer.from(data));
-        }
-      };
-    }
-  });
-
-  // src/runtime/gateways/file/utils.ts
-  async function getFileSystem(url) {
-    const name6 = url.getParam("fs");
-    let fs;
-    switch (name6) {
-      case "mem":
-        {
-          const { MemFileSystem } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-          fs = new MemFileSystem();
-        }
-        break;
-      // case 'deno': {
-      //   const { DenoFileSystem } = await import("./deno-filesystem.js");
-      //   fs = new DenoFileSystem();
-      //   break;
-      // }
-      case "node": {
-        const { NodeFileSystem: NodeFileSystem2 } = await Promise.resolve().then(() => (init_node_filesystem(), node_filesystem_exports));
-        fs = new NodeFileSystem2();
-        break;
-      }
-      case "sys":
-      default: {
-        return getFileSystem(url.build().setParam("fs", "node").URI());
-      }
-    }
-    return fs.start();
-  }
-  function getPath(url, sthis) {
-    const basePath = url.pathname;
-    const name6 = url.getParam("name");
-    if (name6) {
-      const version = url.getParam("version");
-      if (!version) throw sthis.logger.Error().Url(url).Msg(`version not found`).AsError();
-      return sthis.pathOps.join(basePath, version, name6);
-    }
-    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 = 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();
-    }
-  }
-  function toArrayBuffer(buffer2) {
-    if (typeof buffer2 === "string") {
-      buffer2 = Buffer.from(buffer2);
-    }
-    const ab = new ArrayBuffer(buffer2.length);
-    const view = new Uint8Array(ab);
-    for (let i = 0; i < buffer2.length; ++i) {
-      view[i] = buffer2[i];
-    }
-    return view;
-  }
-  var init_utils2 = __esm({
-    "src/runtime/gateways/file/utils.ts"() {
-      "use strict";
-      init_utils();
-    }
-  });
-
   // src/runtime/key-bag-indexdb.ts
   var key_bag_indexdb_exports = {};
   __export(key_bag_indexdb_exports, {
@@ -12845,173 +13071,213 @@ ${end.comment}` : end.comment;
     }
   });
 
-  // src/runtime/gateways/indexdb/version.ts
-  var INDEXDB_VERSION;
+  // src/runtime/gateways/file/version.ts
+  var FILESTORE_VERSION;
   var init_version = __esm({
-    "src/runtime/gateways/indexdb/version.ts"() {
+    "src/runtime/gateways/file/version.ts"() {
       "use strict";
-      INDEXDB_VERSION = "v0.19-indexdb";
+      FILESTORE_VERSION = "v0.19-file";
     }
   });
 
-  // src/runtime/gateways/indexdb/gateway.ts
+  // src/runtime/gateways/file/gateway.ts
   var gateway_exports = {};
   __export(gateway_exports, {
-    IndexDBGateway: () => IndexDBGateway,
-    IndexDBTestStore: () => IndexDBTestStore,
-    getIndexDBName: () => getIndexDBName
+    FileGateway: () => FileGateway,
+    FileTestStore: () => FileTestStore
   });
-  function ensureVersion(url) {
-    return url.build().defParam("version", INDEXDB_VERSION).URI();
-  }
-  function sanitzeKey(key) {
-    if (key.length === 1) {
-      key = key[0];
-    }
-    return key;
-  }
-  async function connectIdb(url, sthis) {
-    const dbName = getIndexDBName(url, sthis);
-    const once = await onceIndexDB.get(dbName.fullDb).once(async () => {
-      const db = await openDB(dbName.fullDb, 1, {
-        upgrade(db2) {
-          ["version", "data", "wal", "meta", "idx.data", "idx.wal", "idx.meta"].map((store) => {
-            db2.createObjectStore(store, {
-              autoIncrement: false
-            });
-          });
-        }
-      });
-      const found = await db.get("version", "version");
-      const version = ensureVersion(url).getParam("version");
-      if (!found) {
-        await db.put("version", { version }, "version");
-      } else if (found.version !== version) {
-        sthis.logger.Warn().Str("url", url.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
-      }
-      return { db, dbName, version, url };
-    });
-    return {
-      ...once,
-      url: url.build().setParam("version", once.version).URI()
-    };
-  }
-  function joinDBName(...names) {
-    return names.map((i) => i.replace(/^[^a-zA-Z0-9]+/g, "").replace(/[^a-zA-Z0-9]+/g, "_")).filter((i) => i.length).join(".");
-  }
-  function getIndexDBName(iurl, sthis) {
-    const url = ensureVersion(iurl);
-    const fullDb = url.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
-    const dbName = url.getParam("name");
-    if (!dbName) throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
-    const result = joinDBName(fullDb, dbName);
-    const objStore = getStore(url, sthis, joinDBName).name;
-    const connectionKey = [result, objStore].join(":");
-    return {
-      fullDb: result,
-      objStore,
-      connectionKey,
-      dbName
-    };
-  }
-  var onceIndexDB, IndexDBGateway, IndexDBTestStore;
+  var versionFiles, FileGateway, FileTestStore;
   var init_gateway = __esm({
-    "src/runtime/gateways/indexdb/gateway.ts"() {
+    "src/runtime/gateways/file/gateway.ts"() {
       "use strict";
-      init_build();
-      init_cement();
       init_version();
+      init_cement();
       init_utils();
-      onceIndexDB = new KeyedResolvOnce();
-      IndexDBGateway = class {
+      init_utils2();
+      versionFiles = new KeyedResolvOnce();
+      FileGateway = class {
+        get fs() {
+          if (!this._fs) throw this.logger.Error().Msg("fs not initialized").AsError();
+          return this._fs;
+        }
         constructor(sthis) {
-          this._db = {};
-          this.logger = ensureLogger(sthis, "IndexDBGateway");
           this.sthis = sthis;
+          this.logger = sthis.logger;
         }
-        async start(baseURL) {
+        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 exception2Result(async () => {
-            this.logger.Debug().Url(baseURL).Msg("starting");
-            await this.sthis.start();
-            const ic = await connectIdb(baseURL, this.sthis);
-            this._db = ic.db;
-            this.logger.Debug().Url(ic.url).Msg("started");
-            return ic.url;
+            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 Result.Ok(baseUrl.build().setParam("key", key).URI());
+        }
         async close() {
           return Result.Ok(void 0);
         }
-        async destroy(baseUrl) {
+        // 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 exception2Result(async () => {
-            const type2 = getStore(baseUrl, this.sthis, joinDBName).name;
-            const idb = this._db;
-            const trans = idb.transaction(type2, "readwrite");
-            const object_store = trans.objectStore(type2);
-            const toDelete = [];
-            for (let cursor = await object_store.openCursor(); cursor; cursor = await cursor.continue()) {
-              toDelete.push(cursor.primaryKey);
-            }
-            for (const key of toDelete) {
-              await trans.db.delete(type2, key);
-            }
-            await trans.done;
+            const file = await this.getFilePath(url);
+            this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
+            await this.fs.writefile(file, body);
           });
         }
-        buildUrl(baseUrl, key) {
-          return Promise.resolve(Result.Ok(baseUrl.build().setParam("key", key).URI()));
-        }
         async get(url) {
           return exceptionWrapper(async () => {
-            const key = getKey(url, this.logger);
-            const store = getStore(url, this.sthis, joinDBName).name;
-            this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("getting");
-            const tx = this._db.transaction([store], "readonly");
-            const bytes = await tx.objectStore(store).get(sanitzeKey(key));
-            await tx.done;
-            if (!bytes) {
-              return Result.Err(new NotFoundError2(`missing ${key}`));
+            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 Result.Ok(new Uint8Array(res));
+            } catch (e) {
+              if (isNotFoundError(e)) {
+                return Result.Err(new NotFoundError2(`file not found: ${file}`));
+              }
+              return Result.Err(e);
             }
-            return Result.Ok(bytes);
           });
         }
-        async put(url, value) {
+        async delete(url) {
           return exception2Result(async () => {
-            const key = getKey(url, this.logger);
-            const store = getStore(url, this.sthis, joinDBName).name;
-            this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("putting");
-            const tx = this._db.transaction([store], "readwrite");
-            await tx.objectStore(store).put(value, sanitzeKey(key));
-            await tx.done;
+            await this.fs.unlink(this.getFilePath(url));
           });
         }
-        async delete(url) {
-          return exception2Result(async () => {
-            const key = getKey(url, this.logger);
-            const store = getStore(url, this.sthis, joinDBName).name;
-            this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("deleting");
-            const tx = this._db.transaction([store], "readwrite");
-            await tx.objectStore(store).delete(sanitzeKey(key));
-            await tx.done;
-            return Result.Ok(void 0);
+        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 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 buffer2 = await (await getFileSystem(url)).readfile(dbFile);
+          this.logger.Debug().Url(url).Str("dbFile", dbFile).Len(buffer2).Msg("got");
+          return buffer2;
+        }
+      };
+    }
+  });
+
+  // src/runtime/gateways/indexdb/gateway.ts
+  var gateway_exports2 = {};
+  __export(gateway_exports2, {
+    IndexDBGateway: () => IndexDBGateway,
+    IndexDBTestStore: () => IndexDBTestStore
+  });
+  var loadExternal, IndexDBGateway, IndexDBTestStore;
+  var init_gateway2 = __esm({
+    "src/runtime/gateways/indexdb/gateway.ts"() {
+      "use strict";
+      init_cement();
+      loadExternal = new ResolveOnce();
+      IndexDBGateway = class {
+        constructor(sthis) {
+          this.sthis = sthis;
+        }
+        getGateway() {
+          return loadExternal.once(() => {
+            return Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1)).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 ResolveOnce();
           this.sthis = sthis;
-          this.logger = ensureLogger(sthis, "IndexDBTestStore", {});
         }
-        async get(url, key) {
-          const ic = await connectIdb(url, this.sthis);
-          const store = getStore(ic.url, this.sthis, joinDBName).name;
-          this.logger.Debug().Str("key", key).Str("store", store).Msg("getting");
-          let bytes = await ic.db.get(store, sanitzeKey(key));
-          this.logger.Debug().Str("key", key).Str("store", store).Int("len", bytes.length).Msg("got");
-          if (typeof bytes === "string") {
-            bytes = this.sthis.txt.encode(bytes);
-          }
-          return bytes;
+        getGateway() {
+          return this.loadExternal.once(() => {
+            return Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1)).then(({ IndexDBTestStore: IndexDBTestStore2 }) => new IndexDBTestStore2(this.sthis));
+          });
+        }
+        get(url, key) {
+          return this.getGateway().then((gw) => gw.get(url, key));
         }
       };
     }
@@ -26371,8 +26637,8 @@ You can use close({ resize: true }) to resize header`);
       {
         protocol: "file:",
         factory: async (url, sthis) => {
-          const { KeyBagProviderFile } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-          return new KeyBagProviderFile(url, sthis);
+          const { KeyBagProviderFile: KeyBagProviderFile2 } = await Promise.resolve().then(() => (init_key_bag_file(), key_bag_file_exports));
+          return new KeyBagProviderFile2(url, sthis);
         }
       },
       {
@@ -27261,7 +27527,7 @@ You can use close({ resize: true }) to resize header`);
   async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
     const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
     if (!crdtEntries.length) {
-      sthis.logger.Debug().Str("byteHeads", new TextDecoder().decode(byteHeads)).Msg("No CRDT entries found");
+      sthis.logger.Debug().Any("byteHeads", byteHeads).Msg("No CRDT entries found");
       return [];
     }
     if (!crdtEntries.map) {
@@ -27298,7 +27564,7 @@ You can use close({ resize: true }) to resize header`);
         sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
         return Result.Ok(dbMeta);
       }
-      sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
+      sthis.logger.Debug().Any("data", data).Msg("No crypto in gateway meta payload");
       return Result.Ok(void 0);
     } catch (error) {
       sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
@@ -28131,22 +28397,22 @@ You can use close({ resize: true }) to resize header`);
   registerStoreProtocol({
     protocol: "file:",
     gateway: async (sthis) => {
-      const { FileGateway } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-      return new FileGateway(sthis);
+      const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+      return new FileGateway2(sthis);
     },
     test: async (sthis) => {
-      const { FileTestStore } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-      return new FileTestStore(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_gateway(), gateway_exports));
+      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_gateway(), gateway_exports));
+      const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
       return new IndexDBTestStore2(sthis);
     }
   });
@@ -30519,8 +30785,7 @@ You can use close({ resize: true }) to resize header`);
     kb: () => key_bag_exports,
     kc: () => keyed_crypto_exports,
     mf: () => wait_pr_multiformats_exports,
-    runtimeFn: () => runtimeFn,
-    toArrayBuffer: () => toArrayBuffer
+    runtimeFn: () => runtimeFn
   });
   init_utils2();
 
@@ -30536,19 +30801,17 @@ You can use close({ resize: true }) to resize header`);
 
   // src/runtime/index.ts
   init_cement();
-
-  // src/runtime/gateways/file/version.ts
-  var FILESTORE_VERSION = "v0.19-file";
-
-  // src/runtime/index.ts
   init_version();
 
+  // 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.111": "xxxx"
+    "0.19.112-dev-iife": "xxxx"
   })[0];
   return __toCommonJS(src_exports6);
 })();