pullfrog 0.1.29 → 0.1.31

package/dist/yes.js

@@ -0,0 +1,1244 @@
+import { createRequire as __createRequire } from 'module'; import { fileURLToPath as __fileURLToPath } from 'url'; import { dirname as __dirnameFn } from 'path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __dirnameFn(__filename);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/object-hash@3.0.0/node_modules/object-hash/index.js
+var require_object_hash = __commonJS({
+  "node_modules/.pnpm/object-hash@3.0.0/node_modules/object-hash/index.js"(exports, module) {
+    "use strict";
+    var crypto = __require("crypto");
+    exports = module.exports = objectHash;
+    function objectHash(object, options) {
+      options = applyDefaults(object, options);
+      return hash2(object, options);
+    }
+    exports.sha1 = function(object) {
+      return objectHash(object);
+    };
+    exports.keys = function(object) {
+      return objectHash(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
+    };
+    exports.MD5 = function(object) {
+      return objectHash(object, { algorithm: "md5", encoding: "hex" });
+    };
+    exports.keysMD5 = function(object) {
+      return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
+    };
+    var hashes = crypto.getHashes ? crypto.getHashes().slice() : ["sha1", "md5"];
+    hashes.push("passthrough");
+    var encodings = ["buffer", "hex", "binary", "base64"];
+    function applyDefaults(object, sourceOptions) {
+      sourceOptions = sourceOptions || {};
+      var options = {};
+      options.algorithm = sourceOptions.algorithm || "sha1";
+      options.encoding = sourceOptions.encoding || "hex";
+      options.excludeValues = sourceOptions.excludeValues ? true : false;
+      options.algorithm = options.algorithm.toLowerCase();
+      options.encoding = options.encoding.toLowerCase();
+      options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
+      options.respectType = sourceOptions.respectType === false ? false : true;
+      options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
+      options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
+      options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
+      options.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
+      options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
+      options.replacer = sourceOptions.replacer || void 0;
+      options.excludeKeys = sourceOptions.excludeKeys || void 0;
+      if (typeof object === "undefined") {
+        throw new Error("Object argument required.");
+      }
+      for (var i = 0; i < hashes.length; ++i) {
+        if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
+          options.algorithm = hashes[i];
+        }
+      }
+      if (hashes.indexOf(options.algorithm) === -1) {
+        throw new Error('Algorithm "' + options.algorithm + '"  not supported. supported values: ' + hashes.join(", "));
+      }
+      if (encodings.indexOf(options.encoding) === -1 && options.algorithm !== "passthrough") {
+        throw new Error('Encoding "' + options.encoding + '"  not supported. supported values: ' + encodings.join(", "));
+      }
+      return options;
+    }
+    function isNativeFunction(f) {
+      if (typeof f !== "function") {
+        return false;
+      }
+      var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+      return exp.exec(Function.prototype.toString.call(f)) != null;
+    }
+    function hash2(object, options) {
+      var hashingStream;
+      if (options.algorithm !== "passthrough") {
+        hashingStream = crypto.createHash(options.algorithm);
+      } else {
+        hashingStream = new PassThrough();
+      }
+      if (typeof hashingStream.write === "undefined") {
+        hashingStream.write = hashingStream.update;
+        hashingStream.end = hashingStream.update;
+      }
+      var hasher = typeHasher(options, hashingStream);
+      hasher.dispatch(object);
+      if (!hashingStream.update) {
+        hashingStream.end("");
+      }
+      if (hashingStream.digest) {
+        return hashingStream.digest(options.encoding === "buffer" ? void 0 : options.encoding);
+      }
+      var buf = hashingStream.read();
+      if (options.encoding === "buffer") {
+        return buf;
+      }
+      return buf.toString(options.encoding);
+    }
+    exports.writeToStream = function(object, options, stream) {
+      if (typeof stream === "undefined") {
+        stream = options;
+        options = {};
+      }
+      options = applyDefaults(object, options);
+      return typeHasher(options, stream).dispatch(object);
+    };
+    function typeHasher(options, writeTo, context) {
+      context = context || [];
+      var write = function(str) {
+        if (writeTo.update) {
+          return writeTo.update(str, "utf8");
+        } else {
+          return writeTo.write(str, "utf8");
+        }
+      };
+      return {
+        dispatch: function(value) {
+          if (options.replacer) {
+            value = options.replacer(value);
+          }
+          var type = typeof value;
+          if (value === null) {
+            type = "null";
+          }
+          return this["_" + type](value);
+        },
+        _object: function(object) {
+          var pattern = /\[object (.*)\]/i;
+          var objString = Object.prototype.toString.call(object);
+          var objType = pattern.exec(objString);
+          if (!objType) {
+            objType = "unknown:[" + objString + "]";
+          } else {
+            objType = objType[1];
+          }
+          objType = objType.toLowerCase();
+          var objectNumber = null;
+          if ((objectNumber = context.indexOf(object)) >= 0) {
+            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+          } else {
+            context.push(object);
+          }
+          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+            write("buffer:");
+            return write(object);
+          }
+          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+            if (this["_" + objType]) {
+              this["_" + objType](object);
+            } else if (options.ignoreUnknown) {
+              return write("[" + objType + "]");
+            } else {
+              throw new Error('Unknown object type "' + objType + '"');
+            }
+          } else {
+            var keys = Object.keys(object);
+            if (options.unorderedObjects) {
+              keys = keys.sort();
+            }
+            if (options.respectType !== false && !isNativeFunction(object)) {
+              keys.splice(0, 0, "prototype", "__proto__", "constructor");
+            }
+            if (options.excludeKeys) {
+              keys = keys.filter(function(key) {
+                return !options.excludeKeys(key);
+              });
+            }
+            write("object:" + keys.length + ":");
+            var self = this;
+            return keys.forEach(function(key) {
+              self.dispatch(key);
+              write(":");
+              if (!options.excludeValues) {
+                self.dispatch(object[key]);
+              }
+              write(",");
+            });
+          }
+        },
+        _array: function(arr, unordered) {
+          unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
+          var self = this;
+          write("array:" + arr.length + ":");
+          if (!unordered || arr.length <= 1) {
+            return arr.forEach(function(entry) {
+              return self.dispatch(entry);
+            });
+          }
+          var contextAdditions = [];
+          var entries = arr.map(function(entry) {
+            var strm = new PassThrough();
+            var localContext = context.slice();
+            var hasher = typeHasher(options, strm, localContext);
+            hasher.dispatch(entry);
+            contextAdditions = contextAdditions.concat(localContext.slice(context.length));
+            return strm.read().toString();
+          });
+          context = context.concat(contextAdditions);
+          entries.sort();
+          return this._array(entries, false);
+        },
+        _date: function(date) {
+          return write("date:" + date.toJSON());
+        },
+        _symbol: function(sym) {
+          return write("symbol:" + sym.toString());
+        },
+        _error: function(err) {
+          return write("error:" + err.toString());
+        },
+        _boolean: function(bool) {
+          return write("bool:" + bool.toString());
+        },
+        _string: function(string) {
+          write("string:" + string.length + ":");
+          write(string.toString());
+        },
+        _function: function(fn) {
+          write("fn:");
+          if (isNativeFunction(fn)) {
+            this.dispatch("[native]");
+          } else {
+            this.dispatch(fn.toString());
+          }
+          if (options.respectFunctionNames !== false) {
+            this.dispatch("function-name:" + String(fn.name));
+          }
+          if (options.respectFunctionProperties) {
+            this._object(fn);
+          }
+        },
+        _number: function(number) {
+          return write("number:" + number.toString());
+        },
+        _xml: function(xml) {
+          return write("xml:" + xml.toString());
+        },
+        _null: function() {
+          return write("Null");
+        },
+        _undefined: function() {
+          return write("Undefined");
+        },
+        _regexp: function(regex) {
+          return write("regex:" + regex.toString());
+        },
+        _uint8array: function(arr) {
+          write("uint8array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint8clampedarray: function(arr) {
+          write("uint8clampedarray:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int8array: function(arr) {
+          write("int8array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint16array: function(arr) {
+          write("uint16array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int16array: function(arr) {
+          write("int16array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _uint32array: function(arr) {
+          write("uint32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _int32array: function(arr) {
+          write("int32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _float32array: function(arr) {
+          write("float32array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _float64array: function(arr) {
+          write("float64array:");
+          return this.dispatch(Array.prototype.slice.call(arr));
+        },
+        _arraybuffer: function(arr) {
+          write("arraybuffer:");
+          return this.dispatch(new Uint8Array(arr));
+        },
+        _url: function(url) {
+          return write("url:" + url.toString(), "utf8");
+        },
+        _map: function(map) {
+          write("map:");
+          var arr = Array.from(map);
+          return this._array(arr, options.unorderedSets !== false);
+        },
+        _set: function(set) {
+          write("set:");
+          var arr = Array.from(set);
+          return this._array(arr, options.unorderedSets !== false);
+        },
+        _file: function(file) {
+          write("file:");
+          return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+        },
+        _blob: function() {
+          if (options.ignoreUnknown) {
+            return write("[blob]");
+          }
+          throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
+        },
+        _domwindow: function() {
+          return write("domwindow");
+        },
+        _bigint: function(number) {
+          return write("bigint:" + number.toString());
+        },
+        /* Node.js standard native objects */
+        _process: function() {
+          return write("process");
+        },
+        _timer: function() {
+          return write("timer");
+        },
+        _pipe: function() {
+          return write("pipe");
+        },
+        _tcp: function() {
+          return write("tcp");
+        },
+        _udp: function() {
+          return write("udp");
+        },
+        _tty: function() {
+          return write("tty");
+        },
+        _statwatcher: function() {
+          return write("statwatcher");
+        },
+        _securecontext: function() {
+          return write("securecontext");
+        },
+        _connection: function() {
+          return write("connection");
+        },
+        _zlib: function() {
+          return write("zlib");
+        },
+        _context: function() {
+          return write("context");
+        },
+        _nodescript: function() {
+          return write("nodescript");
+        },
+        _httpparser: function() {
+          return write("httpparser");
+        },
+        _dataview: function() {
+          return write("dataview");
+        },
+        _signal: function() {
+          return write("signal");
+        },
+        _fsevent: function() {
+          return write("fsevent");
+        },
+        _tlswrap: function() {
+          return write("tlswrap");
+        }
+      };
+    }
+    function PassThrough() {
+      return {
+        buf: "",
+        write: function(b) {
+          this.buf += b;
+        },
+        end: function(b) {
+          this.buf += b;
+        },
+        read: function() {
+          return this.buf;
+        }
+      };
+    }
+  }
+});
+
+// yes/index.ts
+import { performance as performance2 } from "node:perf_hooks";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// node_modules/.pnpm/lru-cache@11.3.6/node_modules/lru-cache/dist/esm/node/index.min.js
+import { tracingChannel as I, channel as G } from "node:diagnostics_channel";
+var S = G("lru-cache:metrics");
+var W = I("lru-cache");
+var C = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var D = () => S.hasSubscribers || W.hasSubscribers;
+var U = /* @__PURE__ */ new Set();
+var L = typeof process == "object" && process ? process : {};
+var P = (u3, e, t, i) => {
+  typeof L.emitWarning == "function" ? L.emitWarning(u3, e, t, i) : console.error(`[${t}] ${e}: ${u3}`);
+};
+var H = (u3) => !U.has(u3);
+var X = Symbol("type");
+var F = (u3) => !!u3 && u3 === Math.floor(u3) && u3 > 0 && isFinite(u3);
+var j = (u3) => F(u3) ? u3 <= Math.pow(2, 8) ? Uint8Array : u3 <= Math.pow(2, 16) ? Uint16Array : u3 <= Math.pow(2, 32) ? Uint32Array : u3 <= Number.MAX_SAFE_INTEGER ? O : null : null;
+var O = class extends Array {
+  constructor(e) {
+    super(e), this.fill(0);
+  }
+};
+var R = class u {
+  heap;
+  length;
+  static #o = false;
+  static create(e) {
+    let t = j(e);
+    if (!t) return [];
+    u.#o = true;
+    let i = new u(e, t);
+    return u.#o = false, i;
+  }
+  constructor(e, t) {
+    if (!u.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+    this.heap = new t(e), this.length = 0;
+  }
+  push(e) {
+    this.heap[this.length++] = e;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+};
+var M = class u2 {
+  #o;
+  #u;
+  #w;
+  #x;
+  #S;
+  #M;
+  #U;
+  #m;
+  get perf() {
+    return this.#m;
+  }
+  ttl;
+  ttlResolution;
+  ttlAutopurge;
+  updateAgeOnGet;
+  updateAgeOnHas;
+  allowStale;
+  noDisposeOnSet;
+  noUpdateTTL;
+  maxEntrySize;
+  sizeCalculation;
+  noDeleteOnFetchRejection;
+  noDeleteOnStaleGet;
+  allowStaleOnFetchAbort;
+  allowStaleOnFetchRejection;
+  ignoreFetchAbort;
+  #n;
+  #b;
+  #s;
+  #i;
+  #t;
+  #a;
+  #c;
+  #l;
+  #h;
+  #y;
+  #r;
+  #_;
+  #F;
+  #d;
+  #g;
+  #T;
+  #W;
+  #f;
+  #j;
+  static unsafeExposeInternals(e) {
+    return { starts: e.#F, ttls: e.#d, autopurgeTimers: e.#g, sizes: e.#_, keyMap: e.#s, keyList: e.#i, valList: e.#t, next: e.#a, prev: e.#c, get head() {
+      return e.#l;
+    }, get tail() {
+      return e.#h;
+    }, free: e.#y, isBackgroundFetch: (t) => e.#e(t), backgroundFetch: (t, i, s, n) => e.#P(t, i, s, n), moveToTail: (t) => e.#L(t), indexes: (t) => e.#A(t), rindexes: (t) => e.#z(t), isStale: (t) => e.#p(t) };
+  }
+  get max() {
+    return this.#o;
+  }
+  get maxSize() {
+    return this.#u;
+  }
+  get calculatedSize() {
+    return this.#b;
+  }
+  get size() {
+    return this.#n;
+  }
+  get fetchMethod() {
+    return this.#M;
+  }
+  get memoMethod() {
+    return this.#U;
+  }
+  get dispose() {
+    return this.#w;
+  }
+  get onInsert() {
+    return this.#x;
+  }
+  get disposeAfter() {
+    return this.#S;
+  }
+  constructor(e) {
+    let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: r, allowStale: h, dispose: l, onInsert: c, disposeAfter: f, noDisposeOnSet: g, noUpdateTTL: p, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: y, fetchMethod: a, memoMethod: m, noDeleteOnFetchRejection: _, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, perf: x } = e;
+    if (x !== void 0 && typeof x?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+    if (this.#m = x ?? C, t !== 0 && !F(t)) throw new TypeError("max option must be a nonnegative integer");
+    let v = t ? j(t) : Array;
+    if (!v) throw new Error("invalid max value: " + t);
+    if (this.#o = t, this.#u = T, this.maxEntrySize = w || this.#u, this.sizeCalculation = y, this.sizeCalculation) {
+      if (!this.#u && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+      if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+    }
+    if (m !== void 0 && typeof m != "function") throw new TypeError("memoMethod must be a function if defined");
+    if (this.#U = m, a !== void 0 && typeof a != "function") throw new TypeError("fetchMethod must be a function if specified");
+    if (this.#M = a, this.#W = !!a, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: t }).fill(void 0), this.#t = Array.from({ length: t }).fill(void 0), this.#a = new v(t), this.#c = new v(t), this.#l = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof l == "function" && (this.#w = l), typeof c == "function" && (this.#x = c), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#j = !!this.#x, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, this.maxEntrySize !== 0) {
+      if (this.#u !== 0 && !F(this.#u)) throw new TypeError("maxSize must be a positive integer if specified");
+      if (!F(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+      this.#X();
+    }
+    if (this.allowStale = !!h, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!r, this.ttlResolution = F(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+      if (!F(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+      this.#H();
+    }
+    if (this.#o === 0 && this.ttl === 0 && this.#u === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+    if (!this.ttlAutopurge && !this.#o && !this.#u) {
+      let E = "LRU_CACHE_UNBOUNDED";
+      H(E) && (U.add(E), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, u2));
+    }
+  }
+  getRemainingTTL(e) {
+    return this.#s.has(e) ? 1 / 0 : 0;
+  }
+  #H() {
+    let e = new O(this.#o), t = new O(this.#o);
+    this.#d = e, this.#F = t;
+    let i = this.ttlAutopurge ? Array.from({ length: this.#o }) : void 0;
+    this.#g = i, this.#N = (r, h, l = this.#m.now()) => {
+      t[r] = h !== 0 ? l : 0, e[r] = h, s(r, h);
+    }, this.#D = (r) => {
+      t[r] = e[r] !== 0 ? this.#m.now() : 0, s(r, e[r]);
+    };
+    let s = this.ttlAutopurge ? (r, h) => {
+      if (i?.[r] && (clearTimeout(i[r]), i[r] = void 0), h && h !== 0 && i) {
+        let l = setTimeout(() => {
+          this.#p(r) && this.#v(this.#i[r], "expire");
+        }, h + 1);
+        l.unref && l.unref(), i[r] = l;
+      }
+    } : () => {
+    };
+    this.#E = (r, h) => {
+      if (e[h]) {
+        let l = e[h], c = t[h];
+        if (!l || !c) return;
+        r.ttl = l, r.start = c, r.now = n || o();
+        let f = r.now - c;
+        r.remainingTTL = l - f;
+      }
+    };
+    let n = 0, o = () => {
+      let r = this.#m.now();
+      if (this.ttlResolution > 0) {
+        n = r;
+        let h = setTimeout(() => n = 0, this.ttlResolution);
+        h.unref && h.unref();
+      }
+      return r;
+    };
+    this.getRemainingTTL = (r) => {
+      let h = this.#s.get(r);
+      if (h === void 0) return 0;
+      let l = e[h], c = t[h];
+      if (!l || !c) return 1 / 0;
+      let f = (n || o()) - c;
+      return l - f;
+    }, this.#p = (r) => {
+      let h = t[r], l = e[r];
+      return !!l && !!h && (n || o()) - h > l;
+    };
+  }
+  #D = () => {
+  };
+  #E = () => {
+  };
+  #N = () => {
+  };
+  #p = () => false;
+  #X() {
+    let e = new O(this.#o);
+    this.#b = 0, this.#_ = e, this.#R = (t) => {
+      this.#b -= e[t], e[t] = 0;
+    }, this.#k = (t, i, s, n) => {
+      if (this.#e(i)) return 0;
+      if (!F(s)) if (n) {
+        if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
+        if (s = n(i, t), !F(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+      } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+      return s;
+    }, this.#I = (t, i, s) => {
+      if (e[t] = i, this.#u) {
+        let n = this.#u - e[t];
+        for (; this.#b > n; ) this.#G(true);
+      }
+      this.#b += e[t], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
+    };
+  }
+  #R = (e) => {
+  };
+  #I = (e, t, i) => {
+  };
+  #k = (e, t, i, s) => {
+    if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+    return 0;
+  };
+  *#A({ allowStale: e = this.allowStale } = {}) {
+    if (this.#n) for (let t = this.#h; this.#V(t) && ((e || !this.#p(t)) && (yield t), t !== this.#l); ) t = this.#c[t];
+  }
+  *#z({ allowStale: e = this.allowStale } = {}) {
+    if (this.#n) for (let t = this.#l; this.#V(t) && ((e || !this.#p(t)) && (yield t), t !== this.#h); ) t = this.#a[t];
+  }
+  #V(e) {
+    return e !== void 0 && this.#s.get(this.#i[e]) === e;
+  }
+  *entries() {
+    for (let e of this.#A()) this.#t[e] !== void 0 && this.#i[e] !== void 0 && !this.#e(this.#t[e]) && (yield [this.#i[e], this.#t[e]]);
+  }
+  *rentries() {
+    for (let e of this.#z()) this.#t[e] !== void 0 && this.#i[e] !== void 0 && !this.#e(this.#t[e]) && (yield [this.#i[e], this.#t[e]]);
+  }
+  *keys() {
+    for (let e of this.#A()) {
+      let t = this.#i[e];
+      t !== void 0 && !this.#e(this.#t[e]) && (yield t);
+    }
+  }
+  *rkeys() {
+    for (let e of this.#z()) {
+      let t = this.#i[e];
+      t !== void 0 && !this.#e(this.#t[e]) && (yield t);
+    }
+  }
+  *values() {
+    for (let e of this.#A()) this.#t[e] !== void 0 && !this.#e(this.#t[e]) && (yield this.#t[e]);
+  }
+  *rvalues() {
+    for (let e of this.#z()) this.#t[e] !== void 0 && !this.#e(this.#t[e]) && (yield this.#t[e]);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  [Symbol.toStringTag] = "LRUCache";
+  find(e, t = {}) {
+    for (let i of this.#A()) {
+      let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+      if (n !== void 0 && e(n, this.#i[i], this)) return this.#C(this.#i[i], t);
+    }
+  }
+  forEach(e, t = this) {
+    for (let i of this.#A()) {
+      let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+      n !== void 0 && e.call(t, n, this.#i[i], this);
+    }
+  }
+  rforEach(e, t = this) {
+    for (let i of this.#z()) {
+      let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+      n !== void 0 && e.call(t, n, this.#i[i], this);
+    }
+  }
+  purgeStale() {
+    let e = false;
+    for (let t of this.#z({ allowStale: true })) this.#p(t) && (this.#v(this.#i[t], "expire"), e = true);
+    return e;
+  }
+  info(e) {
+    let t = this.#s.get(e);
+    if (t === void 0) return;
+    let i = this.#t[t], s = this.#e(i) ? i.__staleWhileFetching : i;
+    if (s === void 0) return;
+    let n = { value: s };
+    if (this.#d && this.#F) {
+      let o = this.#d[t], r = this.#F[t];
+      if (o && r) {
+        let h = o - (this.#m.now() - r);
+        n.ttl = h, n.start = Date.now();
+      }
+    }
+    return this.#_ && (n.size = this.#_[t]), n;
+  }
+  dump() {
+    let e = [];
+    for (let t of this.#A({ allowStale: true })) {
+      let i = this.#i[t], s = this.#t[t], n = this.#e(s) ? s.__staleWhileFetching : s;
+      if (n === void 0 || i === void 0) continue;
+      let o = { value: n };
+      if (this.#d && this.#F) {
+        o.ttl = this.#d[t];
+        let r = this.#m.now() - this.#F[t];
+        o.start = Math.floor(Date.now() - r);
+      }
+      this.#_ && (o.size = this.#_[t]), e.unshift([i, o]);
+    }
+    return e;
+  }
+  load(e) {
+    this.clear();
+    for (let [t, i] of e) {
+      if (i.start) {
+        let s = Date.now() - i.start;
+        i.start = this.#m.now() - s;
+      }
+      this.#O(t, i.value, i);
+    }
+  }
+  set(e, t, i = {}) {
+    let { status: s = S.hasSubscribers ? {} : void 0 } = i;
+    i.status = s, s && (s.op = "set", s.key = e, t !== void 0 && (s.value = t));
+    let n = this.#O(e, t, i);
+    return s && S.hasSubscribers && S.publish(s), n;
+  }
+  #O(e, t, i = {}) {
+    let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: r = this.sizeCalculation, status: h } = i;
+    if (t === void 0) return h && (h.set = "deleted"), this.delete(e), this;
+    let { noUpdateTTL: l = this.noUpdateTTL } = i;
+    h && !this.#e(t) && (h.value = t);
+    let c = this.#k(e, t, i.size || 0, r, h);
+    if (this.maxEntrySize && c > this.maxEntrySize) return this.#v(e, "set"), h && (h.set = "miss", h.maxEntrySizeExceeded = true), this;
+    let f = this.#n === 0 ? void 0 : this.#s.get(e);
+    if (f === void 0) f = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(false) : this.#n, this.#i[f] = e, this.#t[f] = t, this.#s.set(e, f), this.#a[this.#h] = f, this.#c[f] = this.#h, this.#h = f, this.#n++, this.#I(f, c, h), h && (h.set = "add"), l = false, this.#j && this.#x?.(t, e, "add");
+    else {
+      this.#L(f);
+      let g = this.#t[f];
+      if (t !== g) {
+        if (this.#W && this.#e(g)) {
+          g.__abortController.abort(new Error("replaced"));
+          let { __staleWhileFetching: p } = g;
+          p !== void 0 && !o && (this.#T && this.#w?.(p, e, "set"), this.#f && this.#r?.push([p, e, "set"]));
+        } else o || (this.#T && this.#w?.(g, e, "set"), this.#f && this.#r?.push([g, e, "set"]));
+        if (this.#R(f), this.#I(f, c, h), this.#t[f] = t, h) {
+          h.set = "replace";
+          let p = g && this.#e(g) ? g.__staleWhileFetching : g;
+          p !== void 0 && (h.oldValue = p);
+        }
+      } else h && (h.set = "update");
+      this.#j && this.onInsert?.(t, e, t === g ? "update" : "replace");
+    }
+    if (s !== 0 && !this.#d && this.#H(), this.#d && (l || this.#N(f, s, n), h && this.#E(h, f)), !o && this.#f && this.#r) {
+      let g = this.#r, p;
+      for (; p = g?.shift(); ) this.#S?.(...p);
+    }
+    return this;
+  }
+  pop() {
+    try {
+      for (; this.#n; ) {
+        let e = this.#t[this.#l];
+        if (this.#G(true), this.#e(e)) {
+          if (e.__staleWhileFetching) return e.__staleWhileFetching;
+        } else if (e !== void 0) return e;
+      }
+    } finally {
+      if (this.#f && this.#r) {
+        let e = this.#r, t;
+        for (; t = e?.shift(); ) this.#S?.(...t);
+      }
+    }
+  }
+  #G(e) {
+    let t = this.#l, i = this.#i[t], s = this.#t[t];
+    return this.#W && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([s, i, "evict"])), this.#R(t), this.#g?.[t] && (clearTimeout(this.#g[t]), this.#g[t] = void 0), e && (this.#i[t] = void 0, this.#t[t] = void 0, this.#y.push(t)), this.#n === 1 ? (this.#l = this.#h = 0, this.#y.length = 0) : this.#l = this.#a[t], this.#s.delete(i), this.#n--, t;
+  }
+  has(e, t = {}) {
+    let { status: i = S.hasSubscribers ? {} : void 0 } = t;
+    t.status = i, i && (i.op = "has", i.key = e);
+    let s = this.#Y(e, t);
+    return S.hasSubscribers && S.publish(i), s;
+  }
+  #Y(e, t = {}) {
+    let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = t, n = this.#s.get(e);
+    if (n !== void 0) {
+      let o = this.#t[n];
+      if (this.#e(o) && o.__staleWhileFetching === void 0) return false;
+      if (this.#p(n)) s && (s.has = "stale", this.#E(s, n));
+      else return i && this.#D(n), s && (s.has = "hit", this.#E(s, n)), true;
+    } else s && (s.has = "miss");
+    return false;
+  }
+  peek(e, t = {}) {
+    let { status: i = D() ? {} : void 0 } = t;
+    i && (i.op = "peek", i.key = e), t.status = i;
+    let s = this.#J(e, t);
+    return S.hasSubscribers && S.publish(i), s;
+  }
+  #J(e, t) {
+    let { status: i, allowStale: s = this.allowStale } = t, n = this.#s.get(e);
+    if (n === void 0 || !s && this.#p(n)) {
+      i && (i.peek = n === void 0 ? "miss" : "stale");
+      return;
+    }
+    let o = this.#t[n], r = this.#e(o) ? o.__staleWhileFetching : o;
+    return i && (r !== void 0 ? (i.peek = "hit", i.value = r) : i.peek = "miss"), r;
+  }
+  #P(e, t, i, s) {
+    let n = t === void 0 ? void 0 : this.#t[t];
+    if (this.#e(n)) return n;
+    let o = new AbortController(), { signal: r } = i;
+    r?.addEventListener("abort", () => o.abort(r.reason), { signal: o.signal });
+    let h = { signal: o.signal, options: i, context: s }, l = (w, y = false) => {
+      let { aborted: a } = o.signal, m = i.ignoreFetchAbort && w !== void 0, _ = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && w !== void 0);
+      if (i.status && (a && !y ? (i.status.fetchAborted = true, i.status.fetchError = o.signal.reason, m && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), a && !m && !y) return f(o.signal.reason, _);
+      let b = p, d = this.#t[t];
+      return (d === p || d === void 0 && m && y) && (w === void 0 ? b.__staleWhileFetching !== void 0 ? this.#t[t] = b.__staleWhileFetching : this.#v(e, "fetch") : (i.status && (i.status.fetchUpdated = true), this.#O(e, w, h.options))), w;
+    }, c = (w) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = w), f(w, false)), f = (w, y) => {
+      let { aborted: a } = o.signal, m = a && i.allowStaleOnFetchAbort, _ = m || i.allowStaleOnFetchRejection, b = _ || i.noDeleteOnFetchRejection, d = p;
+      if (this.#t[t] === p && (!b || !y && d.__staleWhileFetching === void 0 ? this.#v(e, "fetch") : m || (this.#t[t] = d.__staleWhileFetching)), _) return i.status && d.__staleWhileFetching !== void 0 && (i.status.returnedStale = true), d.__staleWhileFetching;
+      if (d.__returned === d) throw w;
+    }, g = (w, y) => {
+      let a = this.#M?.(e, n, h);
+      a && a instanceof Promise && a.then((m) => w(m === void 0 ? void 0 : m), y), o.signal.addEventListener("abort", () => {
+        (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (w(void 0), i.allowStaleOnFetchAbort && (w = (m) => l(m, true)));
+      });
+    };
+    i.status && (i.status.fetchDispatched = true);
+    let p = new Promise(g).then(l, c), T = Object.assign(p, { __abortController: o, __staleWhileFetching: n, __returned: void 0 });
+    return t === void 0 ? (this.#O(e, T, { ...h.options, status: void 0 }), t = this.#s.get(e)) : this.#t[t] = T, T;
+  }
+  #e(e) {
+    if (!this.#W) return false;
+    let t = e;
+    return !!t && t instanceof Promise && t.hasOwnProperty("__staleWhileFetching") && t.__abortController instanceof AbortController;
+  }
+  fetch(e, t = {}) {
+    let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t;
+    t.status = s, s && t.context && (s.context = t.context);
+    let n = this.#B(e, t);
+    return s && i && (s.trace = true, W.tracePromise(() => n, s).catch(() => {
+    })), n;
+  }
+  async #B(e, t = {}) {
+    let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: r = this.noDisposeOnSet, size: h = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: g = this.allowStaleOnFetchRejection, ignoreFetchAbort: p = this.ignoreFetchAbort, allowStaleOnFetchAbort: T = this.allowStaleOnFetchAbort, context: w, forceRefresh: y = false, status: a, signal: m } = t;
+    if (a && (a.op = "fetch", a.key = e, y && (a.forceRefresh = true)), !this.#W) return a && (a.fetch = "get"), this.#C(e, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, status: a });
+    let _ = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: n, ttl: o, noDisposeOnSet: r, size: h, sizeCalculation: l, noUpdateTTL: c, noDeleteOnFetchRejection: f, allowStaleOnFetchRejection: g, allowStaleOnFetchAbort: T, ignoreFetchAbort: p, status: a, signal: m }, b = this.#s.get(e);
+    if (b === void 0) {
+      a && (a.fetch = "miss");
+      let d = this.#P(e, b, _, w);
+      return d.__returned = d;
+    } else {
+      let d = this.#t[b];
+      if (this.#e(d)) {
+        let E = i && d.__staleWhileFetching !== void 0;
+        return a && (a.fetch = "inflight", E && (a.returnedStale = true)), E ? d.__staleWhileFetching : d.__returned = d;
+      }
+      let A = this.#p(b);
+      if (!y && !A) return a && (a.fetch = "hit"), this.#L(b), s && this.#D(b), a && this.#E(a, b), d;
+      let z = this.#P(e, b, _, w), v = z.__staleWhileFetching !== void 0 && i;
+      return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = true)), v ? z.__staleWhileFetching : z.__returned = z;
+    }
+  }
+  forceFetch(e, t = {}) {
+    let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t;
+    t.status = s, s && t.context && (s.context = t.context);
+    let n = this.#K(e, t);
+    return s && i && (s.trace = true, W.tracePromise(() => n, s).catch(() => {
+    })), n;
+  }
+  async #K(e, t = {}) {
+    let i = await this.#B(e, t);
+    if (i === void 0) throw new Error("fetch() returned undefined");
+    return i;
+  }
+  memo(e, t = {}) {
+    let { status: i = S.hasSubscribers ? {} : void 0 } = t;
+    t.status = i, i && (i.op = "memo", i.key = e, t.context && (i.context = t.context));
+    let s = this.#Q(e, t);
+    return i && (i.value = s), S.hasSubscribers && S.publish(i), s;
+  }
+  #Q(e, t = {}) {
+    let i = this.#U;
+    if (!i) throw new Error("no memoMethod provided to constructor");
+    let { context: s, status: n, forceRefresh: o, ...r } = t;
+    n && o && (n.forceRefresh = true);
+    let h = this.#C(e, r), l = o || h === void 0;
+    if (n && (n.memo = l ? "miss" : "hit", l || (n.value = h)), !l) return h;
+    let c = i(e, h, { options: r, context: s });
+    return n && (n.value = c), this.#O(e, c, r), c;
+  }
+  get(e, t = {}) {
+    let { status: i = S.hasSubscribers ? {} : void 0 } = t;
+    t.status = i, i && (i.op = "get", i.key = e);
+    let s = this.#C(e, t);
+    return i && (s !== void 0 && (i.value = s), S.hasSubscribers && S.publish(i)), s;
+  }
+  #C(e, t = {}) {
+    let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = t, r = this.#s.get(e);
+    if (r === void 0) {
+      o && (o.get = "miss");
+      return;
+    }
+    let h = this.#t[r], l = this.#e(h);
+    return o && this.#E(o, r), this.#p(r) ? l ? (o && (o.get = "stale-fetching"), i && h.__staleWhileFetching !== void 0 ? (o && (o.returnedStale = true), h.__staleWhileFetching) : void 0) : (n || this.#v(e, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = true), h) : void 0) : (o && (o.get = l ? "fetching" : "hit"), this.#L(r), s && this.#D(r), l ? h.__staleWhileFetching : h);
+  }
+  #$(e, t) {
+    this.#c[t] = e, this.#a[e] = t;
+  }
+  #L(e) {
+    e !== this.#h && (e === this.#l ? this.#l = this.#a[e] : this.#$(this.#c[e], this.#a[e]), this.#$(this.#h, e), this.#h = e);
+  }
+  delete(e) {
+    return this.#v(e, "delete");
+  }
+  #v(e, t) {
+    S.hasSubscribers && S.publish({ op: "delete", delete: t, key: e });
+    let i = false;
+    if (this.#n !== 0) {
+      let s = this.#s.get(e);
+      if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = true, this.#n === 1) this.#q(t);
+      else {
+        this.#R(s);
+        let n = this.#t[s];
+        if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n, e, t), this.#f && this.#r?.push([n, e, t])), this.#s.delete(e), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#c[s];
+        else if (s === this.#l) this.#l = this.#a[s];
+        else {
+          let o = this.#c[s];
+          this.#a[o] = this.#a[s];
+          let r = this.#a[s];
+          this.#c[r] = this.#c[s];
+        }
+        this.#n--, this.#y.push(s);
+      }
+    }
+    if (this.#f && this.#r?.length) {
+      let s = this.#r, n;
+      for (; n = s?.shift(); ) this.#S?.(...n);
+    }
+    return i;
+  }
+  clear() {
+    return this.#q("delete");
+  }
+  #q(e) {
+    for (let t of this.#z({ allowStale: true })) {
+      let i = this.#t[t];
+      if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
+      else {
+        let s = this.#i[t];
+        this.#T && this.#w?.(i, s, e), this.#f && this.#r?.push([i, s, e]);
+      }
+    }
+    if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
+      this.#d.fill(0), this.#F.fill(0);
+      for (let t of this.#g ?? []) t !== void 0 && clearTimeout(t);
+      this.#g?.fill(void 0);
+    }
+    if (this.#_ && this.#_.fill(0), this.#l = 0, this.#h = 0, this.#y.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
+      let t = this.#r, i;
+      for (; i = t?.shift(); ) this.#S?.(...i);
+    }
+  }
+};
+
+// yes/index.ts
+var import_object_hash = __toESM(require_object_hash(), 1);
+var VOID_KEY = "~void";
+function getCacheKeyString(value) {
+  if (value === void 0) return VOID_KEY;
+  if (value === null) {
+    throw new Error("cache key cannot be null");
+  }
+  try {
+    if (typeof value === "string") return value;
+    return (0, import_object_hash.default)(value, { unorderedObjects: true, unorderedArrays: true });
+  } catch (error) {
+    throw new Error(
+      `cache key cannot be hashed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function range(a, b) {
+  if (b === void 0) {
+    return Array.from({ length: a }, (_, i) => i);
+  }
+  if (typeof b === "function") {
+    return Array.from({ length: a }, (_, i) => b(i));
+  }
+  return Array.from({ length: b - a + 1 }, (_, i) => a + i);
+}
+function schedule(fn, count) {
+  return Array.from({ length: count }, (_, i) => fn(i));
+}
+function validateSchema(schema, value) {
+  const result = schema["~standard"].validate(value);
+  if (result instanceof Promise) {
+    return result.then((res) => {
+      if (res.issues) {
+        const messages = res.issues.map((i) => i.message).join(", ");
+        throw new Error(`validation failed: ${messages}`);
+      }
+      return res.value;
+    });
+  }
+  if (result.issues) {
+    const messages = result.issues.map((i) => i.message).join(", ");
+    throw new Error(`validation failed: ${messages}`);
+  }
+  return result.value;
+}
+var log = {
+  info: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => {
+    if (process.env.LOG_LEVEL === "debug") console.log(...args);
+  },
+  prod: (...args) => {
+    if (process.env.NODE_ENV === "production") console.log(...args);
+  }
+};
+function op(fnOrOptions, options) {
+  if (typeof fnOrOptions === "function") {
+    return _op(fnOrOptions, options ?? {});
+  }
+  const { input: inputSchema, output: outputSchema, run, ...opOptions } = fnOrOptions;
+  const wrappedFn = async (rawInput, ctx) => {
+    let input = rawInput;
+    if (inputSchema) {
+      const validated = validateSchema(inputSchema, rawInput);
+      input = validated instanceof Promise ? await validated : validated;
+    }
+    const result = await run(input, ctx);
+    if (outputSchema) {
+      const validated = validateSchema(outputSchema, result);
+      return validated instanceof Promise ? await validated : validated;
+    }
+    return result;
+  };
+  return _op(wrappedFn, opOptions);
+}
+function _op(fn, options) {
+  const shouldCache = options.ttl !== void 0;
+  const lruCache = shouldCache ? new M({
+    max: options.maxItems ?? 1e3,
+    ttl: options.ttl
+  }) : null;
+  const keyMap = shouldCache ? new M({
+    max: options.maxItems ?? 1e3,
+    ttl: options.ttl
+  }) : null;
+  const inFlightPromises = /* @__PURE__ */ new Map();
+  const namePrefix = options.name ? `[${options.name}] ` : "";
+  const defaultCacheHit = options.cacheHit === null ? () => {
+  } : options.cacheHit ?? (() => {
+    if (options.name && shouldCache) log.prod(`${namePrefix}cache hit`);
+  });
+  const defaultCacheMiss = options.cacheMiss === null ? () => {
+  } : options.cacheMiss ?? (() => {
+    if (options.name && shouldCache) log.prod(`${namePrefix}cache miss`);
+  });
+  const acceptsCtx = fn.length === 2;
+  const cachedFn = async (input, ctx) => {
+    let key;
+    try {
+      key = getCacheKeyString(input);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `failed to create cache key${namePrefix ? ` for ${options.name}` : ""}: ${errorMessage}`
+      );
+    }
+    const startTime = performance2.now();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    log.debug(`${namePrefix}[${timestamp}] cache lookup started`, { key });
+    if (shouldCache && lruCache) {
+      const cached = lruCache.get(key);
+      if (cached !== void 0) {
+        if (keyMap?.get(key) === void 0) keyMap?.set(key, input);
+        const runtime = performance2.now() - startTime;
+        log.debug(`${namePrefix}[${timestamp}] cache hit (from lru)`, {
+          key,
+          runtime: `${Math.round(runtime)}ms`
+        });
+        defaultCacheHit(key);
+        return cached;
+      }
+    }
+    const inFlight = inFlightPromises.get(key);
+    if (inFlight) {
+      log.debug(`${namePrefix}[${timestamp}] cache hit (in-flight)`, { key });
+      defaultCacheHit(key);
+      return inFlight;
+    }
+    log.debug(`${namePrefix}[${timestamp}] cache miss, executing function`, { key });
+    defaultCacheMiss(key);
+    const retries = options.retries ?? [];
+    let lastError;
+    const execStartTime = performance2.now();
+    const promise = (async () => {
+      for (let attempt = 0; attempt <= retries.length; attempt++) {
+        try {
+          const result = acceptsCtx ? await fn(input, ctx) : await fn(input);
+          const execRuntime2 = performance2.now() - execStartTime;
+          const skip = options.skipCache ? options.skipCache(result) : false;
+          if (shouldCache && lruCache && result !== null && result !== void 0 && !skip) {
+            lruCache.set(key, result);
+            keyMap?.set(key, input);
+          }
+          log.debug(`${namePrefix}[${timestamp}] function executed successfully`, {
+            key,
+            runtime: `${Math.round(execRuntime2)}ms`,
+            attempt: attempt + 1,
+            cached: shouldCache && result !== null && result !== void 0 && !skip
+          });
+          return result;
+        } catch (error) {
+          if (options.bail?.(error)) throw error;
+          lastError = error;
+          const isLastAttempt = attempt >= retries.length;
+          if (isLastAttempt) {
+            if (namePrefix) {
+              log.info(
+                `${namePrefix}attempt ${attempt + 1}/${retries.length + 1} failed, no more retries`
+              );
+              log.info(`${namePrefix}`, { key, error, attempt });
+            } else {
+              log.info(`attempt ${attempt + 1}/${retries.length + 1} failed, no more retries`);
+              log.info({ key, error, attempt });
+            }
+          } else {
+            const delay = retries[attempt];
+            if (namePrefix) {
+              log.info(
+                `${namePrefix}attempt ${attempt + 1}/${retries.length + 1} failed, retrying in ${delay}ms`
+              );
+              log.info(`${namePrefix}`, { key, error, attempt });
+            } else {
+              log.info(
+                `attempt ${attempt + 1}/${retries.length + 1} failed, retrying in ${delay}ms`
+              );
+              log.info({ key, error, attempt });
+            }
+            await sleep(delay);
+          }
+        }
+      }
+      const execRuntime = performance2.now() - execStartTime;
+      log.debug(`${namePrefix}[${timestamp}] function failed after all retries`, {
+        key,
+        runtime: `${Math.round(execRuntime)}ms`,
+        attempts: retries.length + 1,
+        error: lastError instanceof Error ? lastError.message : lastError
+      });
+      throw lastError;
+    })();
+    inFlightPromises.set(key, promise);
+    try {
+      return await promise;
+    } finally {
+      inFlightPromises.delete(key);
+    }
+  };
+  cachedFn.clear = (key) => {
+    if (shouldCache && lruCache) {
+      if (key !== void 0) {
+        let stringKey;
+        try {
+          stringKey = getCacheKeyString(key);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(
+            `failed to hash cache key for clear()${namePrefix ? ` in ${options.name}` : ""}: ${errorMessage}`
+          );
+        }
+        lruCache.delete(stringKey);
+        keyMap.delete(stringKey);
+      } else {
+        lruCache.clear();
+        keyMap.clear();
+      }
+    }
+  };
+  cachedFn.has = (key) => {
+    if (!shouldCache || !lruCache) return false;
+    try {
+      const stringKey = getCacheKeyString(key);
+      return lruCache.has(stringKey);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `failed to hash cache key for has()${namePrefix ? ` in ${options.name}` : ""}: ${errorMessage}`
+      );
+    }
+  };
+  cachedFn.invalidate = (predicate) => {
+    if (!shouldCache || !lruCache) return 0;
+    let count = 0;
+    for (const [stringKey, originalKey] of keyMap) {
+      if (predicate(originalKey)) {
+        lruCache.delete(stringKey);
+        keyMap.delete(stringKey);
+        count++;
+      }
+    }
+    return count;
+  };
+  return cachedFn;
+}
+export {
+  op,
+  range,
+  schedule
+};