pullfrog 0.1.94 → 0.1.95

package/dist/index.js

@@ -3682,7 +3682,7 @@ var require_util2 = __commonJS({
     "use strict";
     var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2();
     var { getGlobalOrigin } = require_global();
-    var { performance: performance10 } = __require("perf_hooks");
+    var { performance: performance9 } = __require("perf_hooks");
     var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
     var assert3 = __require("assert");
     var { isUint8Array } = __require("util/types");
@@ -3845,7 +3845,7 @@ var require_util2 = __commonJS({
       }
     }
     function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
-      return performance10.now();
+      return performance9.now();
     }
     function createOpaqueTimingInfo(timingInfo) {
       return {
@@ -45129,7 +45129,7 @@ var require_util9 = __commonJS({
     var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants9();
     var { getGlobalOrigin } = require_global3();
     var { collectAnHTTPQuotedString, parseMIMEType } = require_data_url();
-    var { performance: performance10 } = __require("node:perf_hooks");
+    var { performance: performance9 } = __require("node:perf_hooks");
     var { ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util8();
     var assert3 = __require("node:assert");
     var { isUint8Array } = __require("node:util/types");
@@ -45284,7 +45284,7 @@ var require_util9 = __commonJS({
       };
     }
     function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
-      return coarsenTime(performance10.now(), crossOriginIsolatedCapability);
+      return coarsenTime(performance9.now(), crossOriginIsolatedCapability);
     }
     function createOpaqueTimingInfo(timingInfo) {
       return {
@@ -75565,7 +75565,7 @@ var require_fast_uri = __commonJS({
         normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse6(serialize(uri, options), options);
+        parse6(serialize2(uri, options), options);
       }
       return uri;
     }
@@ -75600,13 +75600,13 @@ var require_fast_uri = __commonJS({
         throw new Error(resolved.error);
       }
       schemelessOptions.skipEscape = true;
-      return serialize(resolved, schemelessOptions);
+      return serialize2(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse6(serialize(base, options), options);
-        relative = parse6(serialize(relative, options), options);
+        base = parse6(serialize2(base, options), options);
+        relative = parse6(serialize2(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -75660,7 +75660,7 @@ var require_fast_uri = __commonJS({
       const normalizedB = normalizeComparableURI(uriB, options);
       return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
-    function serialize(cmpts, opts) {
+    function serialize2(cmpts, opts) {
       const component = {
         host: cmpts.host,
         scheme: cmpts.scheme,
@@ -75914,7 +75914,7 @@ var require_fast_uri = __commonJS({
     function normalizeStringWithStatus(uri, opts) {
       const { parsed: parsed2, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed2, opts),
+        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize2(parsed2, opts),
         malformedAuthorityOrPort,
         malformedPercentEncoding,
         malformedSchemeSpecific,
@@ -75928,7 +75928,7 @@ var require_fast_uri = __commonJS({
       }
       let value2;
       try {
-        value2 = typeof uri === "string" ? uri : serialize(uri, opts);
+        value2 = typeof uri === "string" ? uri : serialize2(uri, opts);
       } catch {
         return void 0;
       }
@@ -75941,7 +75941,7 @@ var require_fast_uri = __commonJS({
       resolve: resolve3,
       resolveComponent,
       equal,
-      serialize,
+      serialize: serialize2,
       parse: parse6
     };
     module.exports = fastUri;
@@ -79498,384 +79498,6 @@ var init_index_DoHiaFQM = __esm({
   }
 });
 
-// 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 crypto5 = __require("crypto");
-    exports = module.exports = objectHash;
-    function objectHash(object5, options) {
-      options = applyDefaults(object5, options);
-      return hash3(object5, options);
-    }
-    exports.sha1 = function(object5) {
-      return objectHash(object5);
-    };
-    exports.keys = function(object5) {
-      return objectHash(object5, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
-    };
-    exports.MD5 = function(object5) {
-      return objectHash(object5, { algorithm: "md5", encoding: "hex" });
-    };
-    exports.keysMD5 = function(object5) {
-      return objectHash(object5, { algorithm: "md5", encoding: "hex", excludeValues: true });
-    };
-    var hashes = crypto5.getHashes ? crypto5.getHashes().slice() : ["sha1", "md5"];
-    hashes.push("passthrough");
-    var encodings = ["buffer", "hex", "binary", "base64"];
-    function applyDefaults(object5, 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 object5 === "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 hash3(object5, options) {
-      var hashingStream;
-      if (options.algorithm !== "passthrough") {
-        hashingStream = crypto5.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(object5);
-      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(object5, options, stream) {
-      if (typeof stream === "undefined") {
-        stream = options;
-        options = {};
-      }
-      options = applyDefaults(object5, options);
-      return typeHasher(options, stream).dispatch(object5);
-    };
-    function typeHasher(options, writeTo, context) {
-      context = context || [];
-      var write2 = function(str) {
-        if (writeTo.update) {
-          return writeTo.update(str, "utf8");
-        } else {
-          return writeTo.write(str, "utf8");
-        }
-      };
-      return {
-        dispatch: function(value2) {
-          if (options.replacer) {
-            value2 = options.replacer(value2);
-          }
-          var type2 = typeof value2;
-          if (value2 === null) {
-            type2 = "null";
-          }
-          return this["_" + type2](value2);
-        },
-        _object: function(object5) {
-          var pattern = /\[object (.*)\]/i;
-          var objString = Object.prototype.toString.call(object5);
-          var objType = pattern.exec(objString);
-          if (!objType) {
-            objType = "unknown:[" + objString + "]";
-          } else {
-            objType = objType[1];
-          }
-          objType = objType.toLowerCase();
-          var objectNumber = null;
-          if ((objectNumber = context.indexOf(object5)) >= 0) {
-            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
-          } else {
-            context.push(object5);
-          }
-          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object5)) {
-            write2("buffer:");
-            return write2(object5);
-          }
-          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
-            if (this["_" + objType]) {
-              this["_" + objType](object5);
-            } else if (options.ignoreUnknown) {
-              return write2("[" + objType + "]");
-            } else {
-              throw new Error('Unknown object type "' + objType + '"');
-            }
-          } else {
-            var keys = Object.keys(object5);
-            if (options.unorderedObjects) {
-              keys = keys.sort();
-            }
-            if (options.respectType !== false && !isNativeFunction(object5)) {
-              keys.splice(0, 0, "prototype", "__proto__", "constructor");
-            }
-            if (options.excludeKeys) {
-              keys = keys.filter(function(key) {
-                return !options.excludeKeys(key);
-              });
-            }
-            write2("object:" + keys.length + ":");
-            var self2 = this;
-            return keys.forEach(function(key) {
-              self2.dispatch(key);
-              write2(":");
-              if (!options.excludeValues) {
-                self2.dispatch(object5[key]);
-              }
-              write2(",");
-            });
-          }
-        },
-        _array: function(arr, unordered) {
-          unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
-          var self2 = this;
-          write2("array:" + arr.length + ":");
-          if (!unordered || arr.length <= 1) {
-            return arr.forEach(function(entry) {
-              return self2.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(date6) {
-          return write2("date:" + date6.toJSON());
-        },
-        _symbol: function(sym) {
-          return write2("symbol:" + sym.toString());
-        },
-        _error: function(err) {
-          return write2("error:" + err.toString());
-        },
-        _boolean: function(bool) {
-          return write2("bool:" + bool.toString());
-        },
-        _string: function(string6) {
-          write2("string:" + string6.length + ":");
-          write2(string6.toString());
-        },
-        _function: function(fn2) {
-          write2("fn:");
-          if (isNativeFunction(fn2)) {
-            this.dispatch("[native]");
-          } else {
-            this.dispatch(fn2.toString());
-          }
-          if (options.respectFunctionNames !== false) {
-            this.dispatch("function-name:" + String(fn2.name));
-          }
-          if (options.respectFunctionProperties) {
-            this._object(fn2);
-          }
-        },
-        _number: function(number6) {
-          return write2("number:" + number6.toString());
-        },
-        _xml: function(xml) {
-          return write2("xml:" + xml.toString());
-        },
-        _null: function() {
-          return write2("Null");
-        },
-        _undefined: function() {
-          return write2("Undefined");
-        },
-        _regexp: function(regex4) {
-          return write2("regex:" + regex4.toString());
-        },
-        _uint8array: function(arr) {
-          write2("uint8array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint8clampedarray: function(arr) {
-          write2("uint8clampedarray:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int8array: function(arr) {
-          write2("int8array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint16array: function(arr) {
-          write2("uint16array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int16array: function(arr) {
-          write2("int16array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint32array: function(arr) {
-          write2("uint32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int32array: function(arr) {
-          write2("int32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _float32array: function(arr) {
-          write2("float32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _float64array: function(arr) {
-          write2("float64array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _arraybuffer: function(arr) {
-          write2("arraybuffer:");
-          return this.dispatch(new Uint8Array(arr));
-        },
-        _url: function(url4) {
-          return write2("url:" + url4.toString(), "utf8");
-        },
-        _map: function(map2) {
-          write2("map:");
-          var arr = Array.from(map2);
-          return this._array(arr, options.unorderedSets !== false);
-        },
-        _set: function(set2) {
-          write2("set:");
-          var arr = Array.from(set2);
-          return this._array(arr, options.unorderedSets !== false);
-        },
-        _file: function(file2) {
-          write2("file:");
-          return this.dispatch([file2.name, file2.size, file2.type, file2.lastModfied]);
-        },
-        _blob: function() {
-          if (options.ignoreUnknown) {
-            return write2("[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 write2("domwindow");
-        },
-        _bigint: function(number6) {
-          return write2("bigint:" + number6.toString());
-        },
-        /* Node.js standard native objects */
-        _process: function() {
-          return write2("process");
-        },
-        _timer: function() {
-          return write2("timer");
-        },
-        _pipe: function() {
-          return write2("pipe");
-        },
-        _tcp: function() {
-          return write2("tcp");
-        },
-        _udp: function() {
-          return write2("udp");
-        },
-        _tty: function() {
-          return write2("tty");
-        },
-        _statwatcher: function() {
-          return write2("statwatcher");
-        },
-        _securecontext: function() {
-          return write2("securecontext");
-        },
-        _connection: function() {
-          return write2("connection");
-        },
-        _zlib: function() {
-          return write2("zlib");
-        },
-        _context: function() {
-          return write2("context");
-        },
-        _nodescript: function() {
-          return write2("nodescript");
-        },
-        _httpparser: function() {
-          return write2("httpparser");
-        },
-        _dataview: function() {
-          return write2("dataview");
-        },
-        _signal: function() {
-          return write2("signal");
-        },
-        _fsevent: function() {
-          return write2("fsevent");
-        },
-        _tlswrap: function() {
-          return write2("tlswrap");
-        }
-      };
-    }
-    function PassThrough() {
-      return {
-        buf: "",
-        write: function(b) {
-          this.buf += b;
-        },
-        end: function(b) {
-          this.buf += b;
-        },
-        read: function() {
-          return this.buf;
-        }
-      };
-    }
-  }
-});
-
 // node_modules/.pnpm/bottleneck@2.19.5/node_modules/bottleneck/light.js
 var require_light = __commonJS({
   "node_modules/.pnpm/bottleneck@2.19.5/node_modules/bottleneck/light.js"(exports, module) {
@@ -104358,6 +103980,17 @@ var providers = {
         // see the big-pickle note above (#1077).
         isFree: true
       },
+      // Zen's FREE stealth preview (listed 2026-10-01), the fifth promo. Zen
+      // has not published its data terms yet, so the description claims none.
+      "fledge-alpha": {
+        displayName: "Fledge Alpha",
+        description: "Stealth preview, free for a limited time",
+        resolve: "opencode/fledge-alpha-free",
+        effort: ["low", "high", "max"],
+        // free to run, still gated on the provider's own OPENCODE_API_KEY —
+        // see the big-pickle note above (#1077).
+        isFree: true
+      },
       // Zen's live free MiMo, and the second free row in a menu that big-pickle
       // was alone in since `mimo-v2-pro-free` lost its model.
       mimo: {
@@ -105972,7 +105605,7 @@ var import_semver = __toESM(require_semver2(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.94",
+  version: "0.1.95",
   cliContractVersion: "1",
   type: "module",
   bin: {
@@ -106038,7 +105671,7 @@ var package_default = {
     undici: "^7.22.0",
     vitest: "^4.0.17",
     yaml: "^2.8.2",
-    yes: "0.0.3",
+    yes: "0.1.0",
     zod: "4.3.6"
   },
   repository: {
@@ -134763,21 +134396,21 @@ var require_fast_uri2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils6();
   const { SCHEMES, getSchemeHandler } = require_schemes2();
   function normalize3(uri, options) {
-    if (typeof uri === "string") uri = serialize(parse6(uri, options), options);
-    else if (typeof uri === "object") uri = parse6(serialize(uri, options), options);
+    if (typeof uri === "string") uri = serialize2(parse6(uri, options), options);
+    else if (typeof uri === "object") uri = parse6(serialize2(uri, options), options);
     return uri;
   }
   function resolve3(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
-    return serialize(resolved, schemelessOptions);
+    return serialize2(resolved, schemelessOptions);
   }
   function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
-      base = parse6(serialize(base, options), options);
-      relative = parse6(serialize(relative, options), options);
+      base = parse6(serialize2(base, options), options);
+      relative = parse6(serialize2(relative, options), options);
     }
     options = options || {};
     if (!options.tolerant && relative.scheme) {
@@ -134821,27 +134454,27 @@ var require_fast_uri2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function equal(uriA, uriB, options) {
     if (typeof uriA === "string") {
       uriA = unescape(uriA);
-      uriA = serialize(normalizeComponentEncoding(parse6(uriA, options), true), {
+      uriA = serialize2(normalizeComponentEncoding(parse6(uriA, options), true), {
         ...options,
         skipEscape: true
       });
-    } else if (typeof uriA === "object") uriA = serialize(normalizeComponentEncoding(uriA, true), {
+    } else if (typeof uriA === "object") uriA = serialize2(normalizeComponentEncoding(uriA, true), {
       ...options,
       skipEscape: true
     });
     if (typeof uriB === "string") {
       uriB = unescape(uriB);
-      uriB = serialize(normalizeComponentEncoding(parse6(uriB, options), true), {
+      uriB = serialize2(normalizeComponentEncoding(parse6(uriB, options), true), {
         ...options,
         skipEscape: true
       });
-    } else if (typeof uriB === "object") uriB = serialize(normalizeComponentEncoding(uriB, true), {
+    } else if (typeof uriB === "object") uriB = serialize2(normalizeComponentEncoding(uriB, true), {
       ...options,
       skipEscape: true
     });
     return uriA.toLowerCase() === uriB.toLowerCase();
   }
-  function serialize(cmpts, opts) {
+  function serialize2(cmpts, opts) {
     const component = {
       host: cmpts.host,
       scheme: cmpts.scheme,
@@ -134944,7 +134577,7 @@ var require_fast_uri2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     resolve: resolve3,
     resolveComponent,
     equal,
-    serialize,
+    serialize: serialize2,
     parse: parse6
   };
   module.exports = fastUri;
@@ -149048,21 +148681,21 @@ var require_fast_uri3 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils7();
   const { SCHEMES, getSchemeHandler } = require_schemes3();
   function normalize3(uri, options) {
-    if (typeof uri === "string") uri = serialize(parse6(uri, options), options);
-    else if (typeof uri === "object") uri = parse6(serialize(uri, options), options);
+    if (typeof uri === "string") uri = serialize2(parse6(uri, options), options);
+    else if (typeof uri === "object") uri = parse6(serialize2(uri, options), options);
     return uri;
   }
   function resolve3(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
-    return serialize(resolved, schemelessOptions);
+    return serialize2(resolved, schemelessOptions);
   }
   function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
-      base = parse6(serialize(base, options), options);
-      relative = parse6(serialize(relative, options), options);
+      base = parse6(serialize2(base, options), options);
+      relative = parse6(serialize2(relative, options), options);
     }
     options = options || {};
     if (!options.tolerant && relative.scheme) {
@@ -149106,27 +148739,27 @@ var require_fast_uri3 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
   function equal(uriA, uriB, options) {
     if (typeof uriA === "string") {
       uriA = unescape(uriA);
-      uriA = serialize(normalizeComponentEncoding(parse6(uriA, options), true), {
+      uriA = serialize2(normalizeComponentEncoding(parse6(uriA, options), true), {
         ...options,
         skipEscape: true
       });
-    } else if (typeof uriA === "object") uriA = serialize(normalizeComponentEncoding(uriA, true), {
+    } else if (typeof uriA === "object") uriA = serialize2(normalizeComponentEncoding(uriA, true), {
       ...options,
       skipEscape: true
     });
     if (typeof uriB === "string") {
       uriB = unescape(uriB);
-      uriB = serialize(normalizeComponentEncoding(parse6(uriB, options), true), {
+      uriB = serialize2(normalizeComponentEncoding(parse6(uriB, options), true), {
         ...options,
         skipEscape: true
       });
-    } else if (typeof uriB === "object") uriB = serialize(normalizeComponentEncoding(uriB, true), {
+    } else if (typeof uriB === "object") uriB = serialize2(normalizeComponentEncoding(uriB, true), {
       ...options,
       skipEscape: true
     });
     return uriA.toLowerCase() === uriB.toLowerCase();
   }
-  function serialize(cmpts, opts) {
+  function serialize2(cmpts, opts) {
     const component = {
       host: cmpts.host,
       scheme: cmpts.scheme,
@@ -149229,7 +148862,7 @@ var require_fast_uri3 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
     resolve: resolve3,
     resolveComponent,
     equal,
-    serialize,
+    serialize: serialize2,
     parse: parse6
   };
   module.exports = fastUri;
@@ -174522,8 +174155,8 @@ var createNode = ({ id, kind, inner, meta: meta3, $: $2, ignoreCache }) => {
   let innerJson = {};
   for (const [k2, v] of innerEntries) {
     const keyImpl = impl.keys[k2];
-    const serialize = keyImpl.serialize ?? (keyImpl.child ? serializeListableChild : defaultValueSerializer);
-    innerJson[k2] = serialize(v);
+    const serialize2 = keyImpl.serialize ?? (keyImpl.child ? serializeListableChild : defaultValueSerializer);
+    innerJson[k2] = serialize2(v);
     if (keyImpl.child === true) {
       const listableNode = v;
       if (isArray(listableNode))
@@ -180072,10 +179705,22 @@ var schema = ark.schema;
 var define2 = ark.define;
 var declare = ark.declare;
 
-// node_modules/.pnpm/yes@0.0.3/node_modules/yes/dist/index.js
-import { performance as performance8 } from "node:perf_hooks";
+// node_modules/.pnpm/yes@0.1.0/node_modules/yes/dist/index.js
 import { setTimeout as sleep2 } from "node:timers/promises";
 
+// node_modules/.pnpm/yes@0.1.0/node_modules/yes/dist/cache/adapter.js
+var AdapterError = class extends Error {
+  method;
+  /** the full store key, or the op's prefix when the call covered many keys. never the raw input. */
+  key;
+  constructor(method, key, cause) {
+    super(`cache ${method} failed for ${key}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.name = "AdapterError";
+    this.method = method;
+    this.key = key;
+  }
+};
+
 // node_modules/.pnpm/lru-cache@11.5.3/node_modules/lru-cache/dist/esm/node/index.min.js
 import { tracingChannel as G, channel as P } from "node:diagnostics_channel";
 var S = P("lru-cache:metrics");
@@ -180661,8 +180306,78 @@ var I = class d2 {
   }
 };
 
-// node_modules/.pnpm/yes@0.0.3/node_modules/yes/dist/index.js
-var import_object_hash = __toESM(require_object_hash(), 1);
+// node_modules/.pnpm/yes@0.1.0/node_modules/yes/dist/cache/memory.js
+function memory(options = {}) {
+  const store = new I({ max: options.maxItems ?? 1e3 });
+  return {
+    get: (key) => store.get(key),
+    peek: (key) => store.peek(key),
+    // the TTL rides on each entry rather than the whole cache, so ops with
+    // different lifetimes can share one store
+    set: (key, entry, ttlMs) => {
+      store.set(key, entry, { ttl: ttlMs });
+    },
+    delete: (keys) => {
+      for (const key of keys)
+        store.delete(key);
+    },
+    // a snapshot, so deleting while iterating is safe. lru-cache skips expired
+    // entries itself.
+    list: (prefix) => [...store.entries()].filter(([key]) => key.startsWith(prefix))
+  };
+}
+
+// node_modules/.pnpm/yes@0.1.0/node_modules/yes/dist/key.js
+import { hash as hash2 } from "node:crypto";
+function hashKey(value2) {
+  return hash2("sha1", serialize(value2, 0));
+}
+var MAX_DEPTH = 64;
+function serialize(value2, depth) {
+  switch (typeof value2) {
+    case "string":
+      return JSON.stringify(value2);
+    case "number":
+      if (!Number.isFinite(value2))
+        throw new Error(`${value2} cannot be part of a cache key`);
+      return String(value2);
+    case "boolean":
+      return value2 ? "true" : "false";
+    case "undefined":
+      throw new Error("undefined cannot be part of a cache key, except as an object property");
+    case "object":
+      break;
+    default:
+      throw new Error(`a ${typeof value2} cannot be part of a cache key`);
+  }
+  if (value2 === null)
+    return "null";
+  if (depth === MAX_DEPTH)
+    throw new Error(`an input nested more than ${MAX_DEPTH} levels deep, or circular`);
+  depth++;
+  if (Array.isArray(value2)) {
+    let out2 = "[";
+    for (let i = 0; i < value2.length; i++)
+      out2 += `${i ? "," : ""}${serialize(value2[i], depth)}`;
+    return `${out2}]`;
+  }
+  const proto = Object.getPrototypeOf(value2);
+  if (proto !== Object.prototype && proto !== null) {
+    const name = proto.constructor?.name || "class instance";
+    throw new Error(`a ${name} cannot be part of a cache key: only JSON data can`);
+  }
+  const record3 = value2;
+  const keys = Object.keys(record3).sort();
+  let out = "";
+  for (const key of keys) {
+    const v = record3[key];
+    if (v !== void 0)
+      out += `${out ? "," : ""}${JSON.stringify(key)}:${serialize(v, depth)}`;
+  }
+  return `{${out}}`;
+}
+
+// node_modules/.pnpm/yes@0.1.0/node_modules/yes/dist/index.js
 var VOID_KEY = "~void";
 function getCacheKeyString(value2) {
   if (value2 === void 0)
@@ -180671,12 +180386,7 @@ function getCacheKeyString(value2) {
     throw new Error("cache key cannot be null");
   }
   try {
-    if (typeof value2 === "string")
-      return value2;
-    return (0, import_object_hash.default)(value2, {
-      unorderedObjects: true,
-      unorderedArrays: true
-    });
+    return hashKey(value2);
   } catch (error49) {
     throw new Error(`cache key cannot be hashed: ${error49 instanceof Error ? error49.message : String(error49)}`);
   }
@@ -180738,15 +180448,21 @@ async function assertSchema(schema2, value2) {
 var log2 = {
   info: (...args2) => console.log(...args2),
   error: (...args2) => console.error(...args2),
-  debug: (...args2) => {
-    if (process.env.LOG_LEVEL === "debug")
-      console.log(...args2);
-  },
   prod: (...args2) => {
     if (process.env.NODE_ENV === "production")
       console.log(...args2);
   }
 };
+function debugTrace(namePrefix, key) {
+  if (process.env.LOG_LEVEL !== "debug")
+    return void 0;
+  const prefix = `${namePrefix}[${(/* @__PURE__ */ new Date()).toISOString()}]`;
+  return {
+    start: performance.now(),
+    log: (message, data) => console.log(`${prefix} ${message}`, { key, ...data }),
+    since: (start) => `${Math.round(performance.now() - start)}ms`
+  };
+}
 function op(fnOrOptions, options) {
   if (typeof fnOrOptions === "function") {
     return _op(fnOrOptions, options ?? {});
@@ -180754,16 +180470,110 @@ function op(fnOrOptions, options) {
   const { input: inputSchema, output: outputSchema, run, ...opOptions } = fnOrOptions;
   return _op(run, opOptions, { input: inputSchema, output: outputSchema });
 }
+var isThenable = (value2) => typeof value2?.then === "function";
+function freshEntry(value2) {
+  if (value2 === null || typeof value2 !== "object" || !("value" in value2))
+    return void 0;
+  const expires = value2.expires;
+  return typeof expires === "number" && expires > Date.now() ? value2 : void 0;
+}
+var adapterMethods = ["get", "set", "delete", "list"];
+function callAdapter(method, key, run) {
+  let result;
+  try {
+    result = run();
+  } catch (error49) {
+    throw new AdapterError(method, key, error49);
+  }
+  if (!isThenable(result))
+    return result;
+  return result.then(void 0, (error49) => {
+    throw new AdapterError(method, key, error49);
+  });
+}
+var DELETE_BATCH = 1e3;
+function sweep(store, prefix, match3) {
+  const now = Date.now();
+  const keys = [];
+  let count = 0;
+  let matchError;
+  const take = ([key, entry]) => {
+    if (!(entry.expires > now))
+      return void keys.push(key);
+    let matched;
+    try {
+      matched = match3(entry.input);
+    } catch (error49) {
+      matchError = { error: error49 };
+      throw error49;
+    }
+    if (matched) {
+      keys.push(key);
+      count++;
+    }
+  };
+  const fail = (error49) => {
+    throw matchError ? matchError.error : new AdapterError("list", prefix, error49);
+  };
+  const deleteFrom = (from) => {
+    for (let i = from; i < keys.length; i += DELETE_BATCH) {
+      const batch = keys.slice(i, i + DELETE_BATCH);
+      const deleted = callAdapter("delete", prefix, () => store.delete(batch));
+      if (isThenable(deleted))
+        return Promise.resolve(deleted).then(() => deleteFrom(i + DELETE_BATCH));
+    }
+    return count;
+  };
+  let listed;
+  try {
+    listed = store.list(prefix);
+  } catch (error49) {
+    return fail(error49);
+  }
+  if (!isThenable(listed) && Symbol.iterator in Object(listed)) {
+    try {
+      for (const item of listed)
+        take(item);
+    } catch (error49) {
+      fail(error49);
+    }
+    return deleteFrom(0);
+  }
+  return (async () => {
+    try {
+      for await (const item of await listed)
+        take(item);
+    } catch (error49) {
+      fail(error49);
+    }
+    return deleteFrom(0);
+  })();
+}
 function _op(fn2, options, schemas = {}) {
-  const shouldCache = options.ttl !== void 0;
-  const lruCache = shouldCache ? new I({
-    max: options.maxItems ?? 1e3,
-    ttl: options.ttl
-  }) : null;
-  const keyMap = shouldCache ? new I({
-    max: options.maxItems ?? 1e3,
-    ttl: options.ttl
-  }) : null;
+  const { ttl, cache: adapter } = options;
+  const shouldCache = ttl !== void 0;
+  if (shouldCache && !(ttl > 0 && Number.isFinite(ttl))) {
+    throw new Error(`ttl must be a positive number of milliseconds, got ${ttl}`);
+  }
+  if (adapter) {
+    if (!options.name)
+      throw new Error(`an op with a cache adapter needs a name: its keys are "yes:<name>:<hash>"`);
+    if (options.name.includes(":")) {
+      throw new Error(`op name "${options.name}" cannot contain ":" with a cache adapter: its keys would overlap another op's`);
+    }
+    if (!shouldCache)
+      throw new Error(`${options.name}: a cache adapter does nothing without a ttl`);
+    if (options.maxItems !== void 0) {
+      throw new Error(`${options.name}: maxItems sizes the default memory store; size the adapter instead`);
+    }
+    const missing = adapterMethods.filter((method) => typeof adapter[method] !== "function");
+    if (missing.length) {
+      throw new Error(`${options.name}: cache is missing ${missing.join(", ")}; an adapter has get, set, delete and list (a Map or a Keyv is not one)`);
+    }
+  }
+  const defaultStore = shouldCache && !adapter ? memory({ maxItems: options.maxItems }) : void 0;
+  const store = adapter ?? defaultStore;
+  const prefix = adapter ? `yes:${options.name}:` : "";
   const inFlightPromises = /* @__PURE__ */ new Map();
   const namePrefix = options.name ? `[${options.name}] ` : "";
   const defaultCacheHit = options.cacheHit === null ? () => {
@@ -180776,11 +180586,21 @@ function _op(fn2, options, schemas = {}) {
     if (options.name && shouldCache)
       log2.prod(`${namePrefix}cache miss`);
   });
-  const keyInput = (value2) => {
+  const methodKey = (value2, method) => {
+    const toKey = (input) => {
+      try {
+        return prefix + getCacheKeyString(input);
+      } catch (error49) {
+        const errorMessage = error49 instanceof Error ? error49.message : String(error49);
+        throw new Error(`failed to hash cache key for ${method}()${namePrefix ? ` in ${options.name}` : ""}: ${errorMessage}`);
+      }
+    };
     if (!schemas.input)
-      return value2;
+      return toKey(value2);
     const result = schemas.input["~standard"].validate(value2);
-    return result instanceof Promise || result.issues ? value2 : result.value;
+    if (result instanceof Promise)
+      return result.then((r) => toKey(r.issues ? value2 : r.value));
+    return toKey(result.issues ? value2 : result.value);
   };
   const cachedFn = async (rawInput, ctx) => {
     const input = schemas.input ? await assertSchema(schemas.input, rawInput) : rawInput;
@@ -180791,54 +180611,57 @@ function _op(fn2, options, schemas = {}) {
       const errorMessage = error49 instanceof Error ? error49.message : String(error49);
       throw new Error(`failed to create cache key${namePrefix ? ` for ${options.name}` : ""}: ${errorMessage}`);
     }
-    const startTime = performance8.now();
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    log2.debug(`${namePrefix}[${timestamp}] cache lookup started`, { key });
-    if (shouldCache && lruCache) {
-      const cached4 = lruCache.get(key);
-      if (cached4 !== void 0) {
-        if (keyMap?.get(key) === void 0)
-          keyMap?.set(key, input);
-        const runtime = performance8.now() - startTime;
-        log2.debug(`${namePrefix}[${timestamp}] cache hit (from lru)`, {
-          key,
-          runtime: `${Math.round(runtime)}ms`
-        });
-        defaultCacheHit(key);
-        return cached4;
-      }
-    }
+    const trace = debugTrace(namePrefix, key);
+    trace?.log("cache lookup started");
     const inFlight = inFlightPromises.get(key);
     if (inFlight) {
-      log2.debug(`${namePrefix}[${timestamp}] cache hit (in-flight)`, { key });
+      trace?.log("cache hit (in-flight)");
       defaultCacheHit(key);
       return inFlight;
     }
-    log2.debug(`${namePrefix}[${timestamp}] cache miss, executing function`, {
-      key
-    });
-    defaultCacheMiss(key);
+    const fullKey = store ? prefix + key : "";
+    let pendingRead;
+    if (store) {
+      let read2;
+      try {
+        read2 = store.get(fullKey);
+      } catch (error49) {
+        throw new AdapterError("get", fullKey, error49);
+      }
+      if (isThenable(read2)) {
+        pendingRead = read2.then(void 0, (error49) => {
+          throw new AdapterError("get", fullKey, error49);
+        });
+      } else {
+        const entry = store === defaultStore ? read2 : freshEntry(read2);
+        if (entry) {
+          trace?.log("cache hit (from store)", { runtime: trace.since(trace.start) });
+          defaultCacheHit(key);
+          return entry.value;
+        }
+      }
+    }
     const retries = options.retries ?? [];
-    let lastError;
-    const execStartTime = performance8.now();
+    const execStart = trace ? performance.now() : 0;
     const promise2 = (async () => {
-      for (let attempt = 0; attempt <= retries.length; attempt++) {
+      if (pendingRead) {
+        const entry = freshEntry(await pendingRead);
+        if (entry) {
+          trace?.log("cache hit (from store)", { runtime: trace.since(trace.start) });
+          defaultCacheHit(key);
+          return entry.value;
+        }
+      }
+      trace?.log("cache miss, executing function");
+      defaultCacheMiss(key);
+      let result;
+      let lastError;
+      let attempt = 0;
+      for (; attempt <= retries.length; attempt++) {
         try {
           const returned = await fn2(input, ctx);
-          const result = schemas.output ? await assertSchema(schemas.output, returned) : returned;
-          const execRuntime2 = performance8.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);
-          }
-          log2.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;
+          result = schemas.output ? await assertSchema(schemas.output, returned) : returned;
+          break;
         } catch (error49) {
           if (error49 instanceof ValidationError || options.rethrow?.(error49))
             throw error49;
@@ -180874,14 +180697,31 @@ function _op(fn2, options, schemas = {}) {
           }
         }
       }
-      const execRuntime = performance8.now() - execStartTime;
-      log2.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;
+      if (attempt > retries.length) {
+        trace?.log("function failed after all retries", {
+          runtime: trace.since(execStart),
+          attempts: retries.length + 1,
+          error: lastError instanceof Error ? lastError.message : lastError
+        });
+        throw lastError;
+      }
+      const skip = options.skipCache ? options.skipCache(result) : false;
+      const storable = store !== void 0 && result !== null && result !== void 0 && !(result instanceof Error) && !skip;
+      let cached4 = false;
+      if (storable) {
+        const created = Date.now();
+        const entry = { value: result, created, expires: created + ttl, input };
+        try {
+          const written = callAdapter("set", fullKey, () => store.set(fullKey, entry, ttl));
+          if (isThenable(written))
+            await written;
+          cached4 = true;
+        } catch (error49) {
+          log2.error(`${namePrefix}cache write failed, returning the result uncached`, error49);
+        }
+      }
+      trace?.log("function executed successfully", { runtime: trace.since(execStart), attempt: attempt + 1, cached: cached4 });
+      return result;
     })();
     inFlightPromises.set(key, promise2);
     try {
@@ -180890,47 +180730,35 @@ function _op(fn2, options, schemas = {}) {
       inFlightPromises.delete(key);
     }
   };
-  cachedFn.clear = (key) => {
-    if (shouldCache && lruCache) {
-      if (key !== void 0) {
-        let stringKey;
-        try {
-          stringKey = getCacheKeyString(keyInput(key));
-        } catch (error49) {
-          const errorMessage = error49 instanceof Error ? error49.message : String(error49);
-          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.clear = async (key) => {
+    if (!store)
+      return;
+    if (key === void 0) {
+      await sweep(store, prefix, () => true);
+      return;
     }
+    let fullKey = methodKey(key, "clear");
+    if (typeof fullKey !== "string")
+      fullKey = await fullKey;
+    const target = fullKey;
+    await callAdapter("delete", target, () => store.delete([target]));
   };
-  cachedFn.has = (key) => {
-    if (!shouldCache || !lruCache)
+  cachedFn.has = async (key) => {
+    if (!store)
       return false;
-    try {
-      const stringKey = getCacheKeyString(keyInput(key));
-      return lruCache.has(stringKey);
-    } catch (error49) {
-      const errorMessage = error49 instanceof Error ? error49.message : String(error49);
-      throw new Error(`failed to hash cache key for has()${namePrefix ? ` in ${options.name}` : ""}: ${errorMessage}`);
-    }
+    let fullKey = methodKey(key, "has");
+    if (typeof fullKey !== "string")
+      fullKey = await fullKey;
+    const target = fullKey;
+    const memoryStore = store;
+    const read2 = callAdapter("get", target, () => memoryStore.peek ? memoryStore.peek(target) : store.get(target));
+    return freshEntry(await read2) !== void 0;
   };
   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;
+    if (!store)
+      return Promise.resolve(0);
+    const count = sweep(store, prefix, predicate);
+    return typeof count === "number" ? Promise.resolve(count) : count;
   };
   return cachedFn;
 }
@@ -191167,7 +190995,7 @@ function ReopenCurrentTool(ctx) {
 }
 
 // prep/index.ts
-import { performance as performance9 } from "node:perf_hooks";
+import { performance as performance8 } from "node:perf_hooks";
 
 // prep/installNodeDependencies.ts
 import { existsSync as existsSync8 } from "node:fs";
@@ -191626,7 +191454,7 @@ var installPythonDependencies = {
 var prepSteps = [installNodeDependencies, installPythonDependencies];
 async function runPrepPhase(options) {
   log.debug("\xBB starting prep phase...");
-  const startTime = performance9.now();
+  const startTime = performance8.now();
   const results = [];
   const preDirty = await dirtyTrackedPaths();
   try {
@@ -191648,7 +191476,7 @@ async function runPrepPhase(options) {
   } finally {
     await restoreDirtiedSince({ before: preDirty, actor: "prep" });
   }
-  const totalDurationMs = performance9.now() - startTime;
+  const totalDurationMs = performance8.now() - startTime;
   log.debug(`\xBB prep phase completed (${Math.round(totalDurationMs)}ms)`);
   return results;
 }