create-cloudflare 2.68.3 → 2.69.0

package/dist/cli.js

@@ -13533,7 +13533,7 @@ var require_snapshot_recorder = __commonJS({
     "use strict";
     var { writeFile: writeFile4, readFile: readFile2, mkdir } = require("node:fs/promises");
     var { dirname: dirname7, resolve: resolve12 } = require("node:path");
-    var { setTimeout: setTimeout5, clearTimeout: clearTimeout2 } = require("node:timers");
+    var { setTimeout: setTimeout6, clearTimeout: clearTimeout2 } = require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
     function formatRequestKey(opts, headerFilters, matchOptions = {}) {
@@ -13867,7 +13867,7 @@ var require_snapshot_recorder = __commonJS({
        * Schedules a flush (debounced to avoid excessive writes)
        */
       #scheduleFlush() {
-        this.#flushTimeout = setTimeout5(() => {
+        this.#flushTimeout = setTimeout6(() => {
           this.saveSnapshots().catch(() => {
           });
           if (this.#autoFlush) {
@@ -25398,7 +25398,7 @@ var require_onetime = __commonJS({
 });
 
 // ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
-var require_signals = __commonJS({
+var require_signals2 = __commonJS({
   "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
     module2.exports = [
       "SIGABRT",
@@ -25435,7 +25435,7 @@ var require_signals = __commonJS({
 });
 
 // ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
-var require_signal_exit = __commonJS({
+var require_signal_exit2 = __commonJS({
   "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
     var process13 = global.process;
     var processOk = function(process14) {
@@ -25448,7 +25448,7 @@ var require_signal_exit = __commonJS({
       };
     } else {
       assert7 = require("assert");
-      signals = require_signals();
+      signals = require_signals2();
       isWin = /^win/i.test(process13.platform);
       EE = require("events");
       if (typeof EE !== "function") {
@@ -52043,7 +52043,7 @@ var require_tiny_invariant_cjs = __commonJS({
 });
 
 // ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js
-var require_base64 = __commonJS({
+var require_base642 = __commonJS({
   "../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js"(exports2) {
     var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
     exports2.encode = function(number) {
@@ -52086,7 +52086,7 @@ var require_base64 = __commonJS({
 // ../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js
 var require_base64_vlq = __commonJS({
   "../../node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js"(exports2) {
-    var base64 = require_base64();
+    var base64 = require_base642();
     var VLQ_BASE_SHIFT = 5;
     var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
     var VLQ_BASE_MASK = VLQ_BASE - 1;
@@ -74459,7 +74459,7 @@ var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__
   mod
 ));
 
-// ../workers-utils/dist/chunk-BLWXWFJK.mjs
+// ../workers-utils/dist/chunk-AKFE3ND4.mjs
 var import_node_assert = __toESM(require("node:assert"), 1);
 function isCompatDate(str) {
   return /^\d{4}-\d{2}-\d{2}$/.test(str);
@@ -74755,6 +74755,23 @@ function mapWorkerMetadataBindings(bindings) {
           }
         ];
         break;
+      case "web_search":
+        {
+          configObj.web_search = {
+            binding: binding.name
+          };
+        }
+        break;
+      case "agent_memory": {
+        configObj.agent_memory = [
+          ...configObj.agent_memory ?? [],
+          {
+            binding: binding.name,
+            namespace: binding.namespace
+          }
+        ];
+        break;
+      }
       case "hyperdrive":
         configObj.hyperdrive = [
           ...configObj.hyperdrive ?? [],
@@ -74778,7 +74795,9 @@ function mapWorkerMetadataBindings(bindings) {
           ...configObj.pipelines ?? [],
           {
             binding: binding.name,
-            pipeline: binding.pipeline
+            // NOTE: stream is the primary field, but we also support pipeline for backward compatibility
+            ...binding.stream && { stream: binding.stream },
+            ...binding.pipeline && { pipeline: binding.pipeline }
           }
         ];
         break;
@@ -74957,55 +74976,6 @@ function constructWranglerConfig(workerOrWorkers) {
 }
 __name(constructWranglerConfig, "constructWranglerConfig");
 
-// ../workers-utils/dist/chunk-O4YGOZSW.mjs
-var MetricsRegistry = class {
-  static {
-    __name(this, "MetricsRegistry");
-  }
-  counters = [];
-  /**
-   * Create and register a new counter metric.
-   *
-   * @param name - The metric name (e.g. "service_request_total")
-   * @param help - A human-readable description of the metric
-   * @returns A Counter that can be incremented
-   */
-  createCounter(name3, help) {
-    const entry = { name: name3, help, value: 0 };
-    this.counters.push(entry);
-    return {
-      inc: /* @__PURE__ */ __name(() => {
-        entry.value++;
-      }, "inc"),
-      add: /* @__PURE__ */ __name((amount) => {
-        if (amount < 0) {
-          throw new Error("Counter value cannot decrease");
-        }
-        entry.value += amount;
-      }, "add")
-    };
-  }
-  /**
-   * Serialize all registered metrics in Prometheus text exposition format.
-   *
-   * @see https://prometheus.io/docs/instrumenting/exposition_formats/#text-based-format
-   */
-  metrics() {
-    return this.counters.map((c2) => {
-      let result = "";
-      if (c2.help.length > 0) {
-        result += `# HELP ${c2.name} ${c2.help}
-`;
-      }
-      result += `# TYPE ${c2.name} counter
-`;
-      result += `${c2.name} ${c2.value}
-`;
-      return result;
-    }).join("");
-  }
-};
-
 // ../workers-utils/dist/chunk-GMTGAG26.mjs
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
@@ -77869,6 +77839,7 @@ var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 var import_undici = __toESM(require_undici(), 1);
+var timersPromises = __toESM(require("node:timers/promises"), 1);
 var require_XDGAppPaths = __commonJS2({
   "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js"(exports2) {
     exports2.__esModule = true;
@@ -77890,7 +77861,7 @@ var require_XDGAppPaths = __commonJS2({
     }
     __name(typeOf, "typeOf");
     function Adapt(adapter_) {
-      var meta = adapter_.meta, path42 = adapter_.path, xdg = adapter_.xdg;
+      var meta = adapter_.meta, path52 = adapter_.path, xdg = adapter_.xdg;
       var XDGAppPaths_ = /* @__PURE__ */ (function() {
         function XDGAppPaths_2(options_) {
           if (options_ === void 0) {
@@ -77913,7 +77884,7 @@ var require_XDGAppPaths = __commonJS2({
             meta.mainFilename()
           ];
           var nameFallback = "$eval";
-          var name3 = path42.parse(((_c2 = namePriorityList.find(function(e2) {
+          var name3 = path52.parse(((_c2 = namePriorityList.find(function(e2) {
             return isString2(e2);
           })) !== null && _c2 !== void 0 ? _c2 : nameFallback) + suffix).name;
           XDGAppPaths.$name = /* @__PURE__ */ __name(function $name() {
@@ -77934,28 +77905,28 @@ var require_XDGAppPaths = __commonJS2({
           }
           __name(finalPathSegment, "finalPathSegment");
           XDGAppPaths.cache = /* @__PURE__ */ __name(function cache(dirOptions) {
-            return path42.join(xdg.cache(), finalPathSegment(dirOptions));
+            return path52.join(xdg.cache(), finalPathSegment(dirOptions));
           }, "cache");
           XDGAppPaths.config = /* @__PURE__ */ __name(function config49(dirOptions) {
-            return path42.join(xdg.config(), finalPathSegment(dirOptions));
+            return path52.join(xdg.config(), finalPathSegment(dirOptions));
           }, "config");
           XDGAppPaths.data = /* @__PURE__ */ __name(function data(dirOptions) {
-            return path42.join(xdg.data(), finalPathSegment(dirOptions));
+            return path52.join(xdg.data(), finalPathSegment(dirOptions));
           }, "data");
           XDGAppPaths.runtime = /* @__PURE__ */ __name(function runtime(dirOptions) {
-            return xdg.runtime() ? path42.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
+            return xdg.runtime() ? path52.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
           }, "runtime");
           XDGAppPaths.state = /* @__PURE__ */ __name(function state(dirOptions) {
-            return path42.join(xdg.state(), finalPathSegment(dirOptions));
+            return path52.join(xdg.state(), finalPathSegment(dirOptions));
           }, "state");
           XDGAppPaths.configDirs = /* @__PURE__ */ __name(function configDirs(dirOptions) {
             return xdg.configDirs().map(function(s) {
-              return path42.join(s, finalPathSegment(dirOptions));
+              return path52.join(s, finalPathSegment(dirOptions));
             });
           }, "configDirs");
           XDGAppPaths.dataDirs = /* @__PURE__ */ __name(function dataDirs(dirOptions) {
             return xdg.dataDirs().map(function(s) {
-              return path42.join(s, finalPathSegment(dirOptions));
+              return path52.join(s, finalPathSegment(dirOptions));
             });
           }, "dataDirs");
           return XDGAppPaths;
@@ -77979,7 +77950,7 @@ var require_XDG = __commonJS2({
     exports2.__esModule = true;
     exports2.Adapt = void 0;
     function Adapt(adapter_) {
-      var env3 = adapter_.env, osPaths = adapter_.osPaths, path42 = adapter_.path;
+      var env3 = adapter_.env, osPaths = adapter_.osPaths, path52 = adapter_.path;
       var isMacOS = /^darwin$/i.test(adapter_.process.platform);
       var isWinOS = /^win/i.test(adapter_.process.platform);
       function baseDir() {
@@ -77987,7 +77958,7 @@ var require_XDG = __commonJS2({
       }
       __name(baseDir, "baseDir");
       function valOrPath(val, pathSegments) {
-        return val || path42.join.apply(path42, pathSegments);
+        return val || path52.join.apply(path52, pathSegments);
       }
       __name(valOrPath, "valOrPath");
       var linux = /* @__PURE__ */ __name(function() {
@@ -78066,11 +78037,11 @@ var require_XDG = __commonJS2({
           XDG.state = extension.state;
           XDG.configDirs = /* @__PURE__ */ __name(function configDirs() {
             var pathList = env3.get("XDG_CONFIG_DIRS");
-            return __spreadArray2([extension.config()], pathList ? pathList.split(path42.delimiter) : []);
+            return __spreadArray2([extension.config()], pathList ? pathList.split(path52.delimiter) : []);
           }, "configDirs");
           XDG.dataDirs = /* @__PURE__ */ __name(function dataDirs() {
             var pathList = env3.get("XDG_DATA_DIRS");
-            return __spreadArray2([extension.data()], pathList ? pathList.split(path42.delimiter) : []);
+            return __spreadArray2([extension.data()], pathList ? pathList.split(path52.delimiter) : []);
           }, "dataDirs");
           return XDG;
         }
@@ -78097,7 +78068,7 @@ var require_OSPaths = __commonJS2({
     }
     __name(isEmpty, "isEmpty");
     function Adapt(adapter_) {
-      var env3 = adapter_.env, os22 = adapter_.os, path42 = adapter_.path;
+      var env3 = adapter_.env, os22 = adapter_.os, path52 = adapter_.path;
       var isWinOS = /^win/i.test(adapter_.process.platform);
       function normalizePath(path_) {
         return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
@@ -78112,7 +78083,7 @@ var require_OSPaths = __commonJS2({
             typeof os22.homedir === "function" ? os22.homedir() : void 0,
             env3.get("USERPROFILE"),
             env3.get("HOME"),
-            env3.get("HOMEDRIVE") || env3.get("HOMEPATH") ? path42.join(env3.get("HOMEDRIVE") || "", env3.get("HOMEPATH") || "") : void 0
+            env3.get("HOMEDRIVE") || env3.get("HOMEPATH") ? path52.join(env3.get("HOMEDRIVE") || "", env3.get("HOMEPATH") || "") : void 0
           ];
           return normalizePath(priorityList.find(function(v) {
             return !isEmpty(v);
@@ -78123,7 +78094,7 @@ var require_OSPaths = __commonJS2({
       __name(home, "home");
       function temp() {
         function joinPathToBase(base, segments) {
-          return base ? path42.join.apply(path42, __spreadArray2([base], segments)) : void 0;
+          return base ? path52.join.apply(path52, __spreadArray2([base], segments)) : void 0;
         }
         __name(joinPathToBase, "joinPathToBase");
         function posix() {
@@ -78226,7 +78197,7 @@ var require_node = __commonJS2({
     exports2.__esModule = true;
     exports2.adapter = void 0;
     var os22 = __importStar2(__require("os"));
-    var path42 = __importStar2(__require("path"));
+    var path52 = __importStar2(__require("path"));
     exports2.adapter = {
       atImportPermissions: { env: true },
       env: {
@@ -78235,7 +78206,7 @@ var require_node = __commonJS2({
         }, "get")
       },
       os: os22,
-      path: path42,
+      path: path52,
       process
     };
   }
@@ -78277,7 +78248,7 @@ var require_node2 = __commonJS2({
     };
     exports2.__esModule = true;
     exports2.adapter = void 0;
-    var path42 = __importStar2(__require("path"));
+    var path52 = __importStar2(__require("path"));
     var os_paths_1 = __importDefault2(require_mod_cjs());
     exports2.adapter = {
       atImportPermissions: { env: true },
@@ -78287,7 +78258,7 @@ var require_node2 = __commonJS2({
         }, "get")
       },
       osPaths: os_paths_1["default"],
-      path: path42,
+      path: path52,
       process
     };
   }
@@ -78329,7 +78300,7 @@ var require_node3 = __commonJS2({
     };
     exports2.__esModule = true;
     exports2.adapter = void 0;
-    var path42 = __importStar2(__require("path"));
+    var path52 = __importStar2(__require("path"));
     var xdg_portable_1 = __importDefault2(require_mod_cjs2());
     exports2.adapter = {
       atImportPermissions: { env: true, read: true },
@@ -78344,7 +78315,7 @@ var require_node3 = __commonJS2({
           return process.pkg ? process.execPath : void 0;
         }, "pkgMainFilename")
       },
-      path: path42,
+      path: path52,
       process,
       xdg: xdg_portable_1["default"]
     };
@@ -78357,15 +78328,207 @@ var require_mod_cjs3 = __commonJS2({
     module2.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
   }
 });
+var require_signals = __commonJS2({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
+    module2.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module2.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module2.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+var require_signal_exit = __commonJS2({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
+    var process22 = global.process;
+    var processOk = /* @__PURE__ */ __name(function(process32) {
+      return process32 && typeof process32 === "object" && typeof process32.removeListener === "function" && typeof process32.emit === "function" && typeof process32.reallyExit === "function" && typeof process32.listeners === "function" && typeof process32.kill === "function" && typeof process32.pid === "number" && typeof process32.on === "function";
+    }, "processOk");
+    if (!processOk(process22)) {
+      module2.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert22 = __require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process22.platform);
+      EE = __require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process22.__signal_exit_emitter__) {
+        emitter = process22.__signal_exit_emitter__;
+      } else {
+        emitter = process22.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module2.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert22.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = /* @__PURE__ */ __name(function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        }, "remove");
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = /* @__PURE__ */ __name(function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process22.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process22.emit = originalProcessEmit;
+        process22.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      }, "unload");
+      module2.exports.unload = unload;
+      emit = /* @__PURE__ */ __name(function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      }, "emit");
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = /* @__PURE__ */ __name(function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process22.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process22.kill(process22.pid, sig);
+          }
+        }, "listener");
+      });
+      module2.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = /* @__PURE__ */ __name(function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process22.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process22.emit = processEmit;
+        process22.reallyExit = processReallyExit;
+      }, "load");
+      module2.exports.load = load;
+      originalProcessReallyExit = process22.reallyExit;
+      processReallyExit = /* @__PURE__ */ __name(function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process22.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process22.exitCode, null);
+        emit("afterexit", process22.exitCode, null);
+        originalProcessReallyExit.call(process22, process22.exitCode);
+      }, "processReallyExit");
+      originalProcessEmit = process22.emit;
+      processEmit = /* @__PURE__ */ __name(function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process22.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process22.exitCode, null);
+          emit("afterexit", process22.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      }, "processEmit");
+    }
+    var assert22;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
 var require_command_exists = __commonJS2({
   "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports2, module2) {
     var exec4 = __require("child_process").exec;
     var execSync = __require("child_process").execSync;
-    var fs22 = __require("fs");
-    var path42 = __require("path");
-    var access = fs22.access;
-    var accessSync2 = fs22.accessSync;
-    var constants2 = fs22.constants || fs22;
+    var fs32 = __require("fs");
+    var path52 = __require("path");
+    var access = fs32.access;
+    var accessSync2 = fs32.accessSync;
+    var constants2 = fs32.constants || fs32;
     var isUsingWindows = process.platform == "win32";
     var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
       access(
@@ -78466,8 +78629,8 @@ var require_command_exists = __commonJS2({
       cleanInput = /* @__PURE__ */ __name(function(s) {
         var isPathName = /[\\]/.test(s);
         if (isPathName) {
-          var dirname22 = '"' + path42.dirname(s) + '"';
-          var basename5 = '"' + path42.basename(s) + '"';
+          var dirname22 = '"' + path52.dirname(s) + '"';
+          var basename5 = '"' + path52.basename(s) + '"';
           return dirname22 + ":" + basename5;
         }
         return '"' + s + '"';
@@ -78507,6 +78670,975 @@ var require_command_exists2 = __commonJS2({
     module2.exports = require_command_exists();
   }
 });
+var require_ini = __commonJS2({
+  "../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js"(exports2) {
+    exports2.parse = exports2.decode = decode;
+    exports2.stringify = exports2.encode = encode;
+    exports2.safe = safe;
+    exports2.unsafe = unsafe;
+    var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+    function encode(obj, opt) {
+      var children = [];
+      var out = "";
+      if (typeof opt === "string") {
+        opt = {
+          section: opt,
+          whitespace: false
+        };
+      } else {
+        opt = opt || {};
+        opt.whitespace = opt.whitespace === true;
+      }
+      var separator = opt.whitespace ? " = " : "=";
+      Object.keys(obj).forEach(function(k, _2, __) {
+        var val = obj[k];
+        if (val && Array.isArray(val)) {
+          val.forEach(function(item) {
+            out += safe(k + "[]") + separator + safe(item) + "\n";
+          });
+        } else if (val && typeof val === "object")
+          children.push(k);
+        else
+          out += safe(k) + separator + safe(val) + eol;
+      });
+      if (opt.section && out.length)
+        out = "[" + safe(opt.section) + "]" + eol + out;
+      children.forEach(function(k, _2, __) {
+        var nk = dotSplit(k).join("\\.");
+        var section = (opt.section ? opt.section + "." : "") + nk;
+        var child = encode(obj[k], {
+          section,
+          whitespace: opt.whitespace
+        });
+        if (out.length && child.length)
+          out += eol;
+        out += child;
+      });
+      return out;
+    }
+    __name(encode, "encode");
+    function dotSplit(str) {
+      return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "
").split(/\./).map(function(part) {
+        return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "
");
+      });
+    }
+    __name(dotSplit, "dotSplit");
+    function decode(str) {
+      var out = {};
+      var p2 = out;
+      var section = null;
+      var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+      var lines = str.split(/[\r\n]+/g);
+      lines.forEach(function(line, _2, __) {
+        if (!line || line.match(/^\s*[;#]/))
+          return;
+        var match = line.match(re);
+        if (!match)
+          return;
+        if (match[1] !== void 0) {
+          section = unsafe(match[1]);
+          if (section === "__proto__") {
+            p2 = {};
+            return;
+          }
+          p2 = out[section] = out[section] || {};
+          return;
+        }
+        var key = unsafe(match[2]);
+        if (key === "__proto__")
+          return;
+        var value = match[3] ? unsafe(match[4]) : true;
+        switch (value) {
+          case "true":
+          case "false":
+          case "null":
+            value = JSON.parse(value);
+        }
+        if (key.length > 2 && key.slice(-2) === "[]") {
+          key = key.substring(0, key.length - 2);
+          if (key === "__proto__")
+            return;
+          if (!p2[key])
+            p2[key] = [];
+          else if (!Array.isArray(p2[key]))
+            p2[key] = [p2[key]];
+        }
+        if (Array.isArray(p2[key]))
+          p2[key].push(value);
+        else
+          p2[key] = value;
+      });
+      Object.keys(out).filter(function(k, _2, __) {
+        if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k]))
+          return false;
+        var parts = dotSplit(k);
+        var p22 = out;
+        var l = parts.pop();
+        var nl = l.replace(/\\\./g, ".");
+        parts.forEach(function(part, _3, __2) {
+          if (part === "__proto__")
+            return;
+          if (!p22[part] || typeof p22[part] !== "object")
+            p22[part] = {};
+          p22 = p22[part];
+        });
+        if (p22 === out && nl === l)
+          return false;
+        p22[nl] = out[k];
+        return true;
+      }).forEach(function(del, _2, __) {
+        delete out[del];
+      });
+      return out;
+    }
+    __name(decode, "decode");
+    function isQuoted(val) {
+      return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
+    }
+    __name(isQuoted, "isQuoted");
+    function safe(val) {
+      return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
+    }
+    __name(safe, "safe");
+    function unsafe(val, doUnesc) {
+      val = (val || "").trim();
+      if (isQuoted(val)) {
+        if (val.charAt(0) === "'")
+          val = val.substr(1, val.length - 2);
+        try {
+          val = JSON.parse(val);
+        } catch (_2) {
+        }
+      } else {
+        var esc = false;
+        var unesc = "";
+        for (var i = 0, l = val.length; i < l; i++) {
+          var c2 = val.charAt(i);
+          if (esc) {
+            if ("\\;#".indexOf(c2) !== -1)
+              unesc += c2;
+            else
+              unesc += "\\" + c2;
+            esc = false;
+          } else if (";#".indexOf(c2) !== -1)
+            break;
+          else if (c2 === "\\")
+            esc = true;
+          else
+            unesc += c2;
+        }
+        if (esc)
+          unesc += "\\";
+        return unesc.trim();
+      }
+      return val;
+    }
+    __name(unsafe, "unsafe");
+  }
+});
+var require_strip_json_comments = __commonJS2({
+  "../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js"(exports2, module2) {
+    var singleComment = 1;
+    var multiComment = 2;
+    function stripWithoutWhitespace() {
+      return "";
+    }
+    __name(stripWithoutWhitespace, "stripWithoutWhitespace");
+    function stripWithWhitespace(str, start, end) {
+      return str.slice(start, end).replace(/\S/g, " ");
+    }
+    __name(stripWithWhitespace, "stripWithWhitespace");
+    module2.exports = function(str, opts) {
+      opts = opts || {};
+      var currentChar;
+      var nextChar;
+      var insideString = false;
+      var insideComment = false;
+      var offset = 0;
+      var ret = "";
+      var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      for (var i = 0; i < str.length; i++) {
+        currentChar = str[i];
+        nextChar = str[i + 1];
+        if (!insideComment && currentChar === '"') {
+          var escaped = str[i - 1] === "\\" && str[i - 2] !== "\\";
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentChar + nextChar === "//") {
+          ret += str.slice(offset, i);
+          offset = i;
+          insideComment = singleComment;
+          i++;
+        } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
+          i++;
+          insideComment = false;
+          ret += strip(str, offset, i);
+          offset = i;
+          continue;
+        } else if (insideComment === singleComment && currentChar === "\n") {
+          insideComment = false;
+          ret += strip(str, offset, i);
+          offset = i;
+        } else if (!insideComment && currentChar + nextChar === "/*") {
+          ret += str.slice(offset, i);
+          offset = i;
+          insideComment = multiComment;
+          i++;
+          continue;
+        } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
+          i++;
+          insideComment = false;
+          ret += strip(str, offset, i + 1);
+          offset = i + 1;
+          continue;
+        }
+      }
+      return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
+    };
+  }
+});
+var require_utils2 = __commonJS2({
+  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports2) {
+    var fs32 = __require("fs");
+    var ini = require_ini();
+    var path52 = __require("path");
+    var stripJsonComments = require_strip_json_comments();
+    var parse10 = exports2.parse = function(content) {
+      if (/^\s*{/.test(content))
+        return JSON.parse(stripJsonComments(content));
+      return ini.parse(content);
+    };
+    var file2 = exports2.file = function() {
+      var args = [].slice.call(arguments).filter(function(arg) {
+        return arg != null;
+      });
+      for (var i in args)
+        if ("string" !== typeof args[i])
+          return;
+      var file22 = path52.join.apply(null, args);
+      try {
+        return fs32.readFileSync(file22, "utf-8");
+      } catch (err) {
+        return;
+      }
+    };
+    exports2.json = function() {
+      var content = file2.apply(null, arguments);
+      return content ? parse10(content) : null;
+    };
+    exports2.env = function(prefix, env22) {
+      env22 = env22 || process.env;
+      var obj = {};
+      var l = prefix.length;
+      for (var k in env22) {
+        if (k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+          var keypath = k.substring(l).split("__");
+          var _emptyStringIndex;
+          while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
+            keypath.splice(_emptyStringIndex, 1);
+          }
+          var cursor = obj;
+          keypath.forEach(/* @__PURE__ */ __name(function _buildSubObj(_subkey, i) {
+            if (!_subkey || typeof cursor !== "object")
+              return;
+            if (i === keypath.length - 1)
+              cursor[_subkey] = env22[k];
+            if (cursor[_subkey] === void 0)
+              cursor[_subkey] = {};
+            cursor = cursor[_subkey];
+          }, "_buildSubObj"));
+        }
+      }
+      return obj;
+    };
+    exports2.find = function() {
+      var rel = path52.join.apply(null, [].slice.call(arguments));
+      function find2(start, rel2) {
+        var file22 = path52.join(start, rel2);
+        try {
+          fs32.statSync(file22);
+          return file22;
+        } catch (err) {
+          if (path52.dirname(start) !== start)
+            return find2(path52.dirname(start), rel2);
+        }
+      }
+      __name(find2, "find");
+      return find2(process.cwd(), rel);
+    };
+  }
+});
+var require_deep_extend = __commonJS2({
+  "../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js"(exports2, module2) {
+    function isSpecificValue(val) {
+      return val instanceof Buffer || val instanceof Date || val instanceof RegExp ? true : false;
+    }
+    __name(isSpecificValue, "isSpecificValue");
+    function cloneSpecificValue(val) {
+      if (val instanceof Buffer) {
+        var x = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length);
+        val.copy(x);
+        return x;
+      } else if (val instanceof Date) {
+        return new Date(val.getTime());
+      } else if (val instanceof RegExp) {
+        return new RegExp(val);
+      } else {
+        throw new Error("Unexpected situation");
+      }
+    }
+    __name(cloneSpecificValue, "cloneSpecificValue");
+    function deepCloneArray(arr) {
+      var clone = [];
+      arr.forEach(function(item, index) {
+        if (typeof item === "object" && item !== null) {
+          if (Array.isArray(item)) {
+            clone[index] = deepCloneArray(item);
+          } else if (isSpecificValue(item)) {
+            clone[index] = cloneSpecificValue(item);
+          } else {
+            clone[index] = deepExtend({}, item);
+          }
+        } else {
+          clone[index] = item;
+        }
+      });
+      return clone;
+    }
+    __name(deepCloneArray, "deepCloneArray");
+    function safeGetProperty(object, property) {
+      return property === "__proto__" ? void 0 : object[property];
+    }
+    __name(safeGetProperty, "safeGetProperty");
+    var deepExtend = module2.exports = function() {
+      if (arguments.length < 1 || typeof arguments[0] !== "object") {
+        return false;
+      }
+      if (arguments.length < 2) {
+        return arguments[0];
+      }
+      var target = arguments[0];
+      var args = Array.prototype.slice.call(arguments, 1);
+      var val, src;
+      args.forEach(function(obj) {
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+          return;
+        }
+        Object.keys(obj).forEach(function(key) {
+          src = safeGetProperty(target, key);
+          val = safeGetProperty(obj, key);
+          if (val === target) {
+            return;
+          } else if (typeof val !== "object" || val === null) {
+            target[key] = val;
+            return;
+          } else if (Array.isArray(val)) {
+            target[key] = deepCloneArray(val);
+            return;
+          } else if (isSpecificValue(val)) {
+            target[key] = cloneSpecificValue(val);
+            return;
+          } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
+            target[key] = deepExtend({}, val);
+            return;
+          } else {
+            target[key] = deepExtend(src, val);
+            return;
+          }
+        });
+      });
+      return target;
+    };
+  }
+});
+var require_minimist = __commonJS2({
+  "../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js"(exports2, module2) {
+    module2.exports = function(args, opts) {
+      if (!opts) opts = {};
+      var flags = { bools: {}, strings: {}, unknownFn: null };
+      if (typeof opts["unknown"] === "function") {
+        flags.unknownFn = opts["unknown"];
+      }
+      if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
+        flags.allBools = true;
+      } else {
+        [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
+          flags.bools[key2] = true;
+        });
+      }
+      var aliases = {};
+      Object.keys(opts.alias || {}).forEach(function(key2) {
+        aliases[key2] = [].concat(opts.alias[key2]);
+        aliases[key2].forEach(function(x) {
+          aliases[x] = [key2].concat(aliases[key2].filter(function(y2) {
+            return x !== y2;
+          }));
+        });
+      });
+      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+        flags.strings[key2] = true;
+        if (aliases[key2]) {
+          flags.strings[aliases[key2]] = true;
+        }
+      });
+      var defaults = opts["default"] || {};
+      var argv = { _: [] };
+      Object.keys(flags.bools).forEach(function(key2) {
+        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+      });
+      var notFlags = [];
+      if (args.indexOf("--") !== -1) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+      }
+      function argDefined(key2, arg2) {
+        return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
+      }
+      __name(argDefined, "argDefined");
+      function setArg(key2, val, arg2) {
+        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+          if (flags.unknownFn(arg2) === false) return;
+        }
+        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+        setKey(argv, key2.split("."), value2);
+        (aliases[key2] || []).forEach(function(x) {
+          setKey(argv, x.split("."), value2);
+        });
+      }
+      __name(setArg, "setArg");
+      function setKey(obj, keys, value2) {
+        var o = obj;
+        for (var i2 = 0; i2 < keys.length - 1; i2++) {
+          var key2 = keys[i2];
+          if (isConstructorOrProto(o, key2)) return;
+          if (o[key2] === void 0) o[key2] = {};
+          if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype) o[key2] = {};
+          if (o[key2] === Array.prototype) o[key2] = [];
+          o = o[key2];
+        }
+        var key2 = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key2)) return;
+        if (o === Object.prototype || o === Number.prototype || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key2] === void 0 || flags.bools[key2] || typeof o[key2] === "boolean") {
+          o[key2] = value2;
+        } else if (Array.isArray(o[key2])) {
+          o[key2].push(value2);
+        } else {
+          o[key2] = [o[key2], value2];
+        }
+      }
+      __name(setKey, "setKey");
+      function aliasIsBoolean(key2) {
+        return aliases[key2].some(function(x) {
+          return flags.bools[x];
+        });
+      }
+      __name(aliasIsBoolean, "aliasIsBoolean");
+      for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        if (/^--.+=/.test(arg)) {
+          var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+          var key = m[1];
+          var value = m[2];
+          if (flags.bools[key]) {
+            value = value !== "false";
+          }
+          setArg(key, value, arg);
+        } else if (/^--no-.+/.test(arg)) {
+          var key = arg.match(/^--no-(.+)/)[1];
+          setArg(key, false, arg);
+        } else if (/^--.+/.test(arg)) {
+          var key = arg.match(/^--(.+)/)[1];
+          var next = args[i + 1];
+          if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+            setArg(key, next, arg);
+            i++;
+          } else if (/^(true|false)$/.test(next)) {
+            setArg(key, next === "true", arg);
+            i++;
+          } else {
+            setArg(key, flags.strings[key] ? "" : true, arg);
+          }
+        } else if (/^-[^-]+/.test(arg)) {
+          var letters = arg.slice(1, -1).split("");
+          var broken = false;
+          for (var j2 = 0; j2 < letters.length; j2++) {
+            var next = arg.slice(j2 + 2);
+            if (next === "-") {
+              setArg(letters[j2], next, arg);
+              continue;
+            }
+            if (/[A-Za-z]/.test(letters[j2]) && /=/.test(next)) {
+              setArg(letters[j2], next.split("=")[1], arg);
+              broken = true;
+              break;
+            }
+            if (/[A-Za-z]/.test(letters[j2]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+              setArg(letters[j2], next, arg);
+              broken = true;
+              break;
+            }
+            if (letters[j2 + 1] && letters[j2 + 1].match(/\W/)) {
+              setArg(letters[j2], arg.slice(j2 + 2), arg);
+              broken = true;
+              break;
+            } else {
+              setArg(letters[j2], flags.strings[letters[j2]] ? "" : true, arg);
+            }
+          }
+          var key = arg.slice(-1)[0];
+          if (!broken && key !== "-") {
+            if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+              setArg(key, args[i + 1], arg);
+              i++;
+            } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+              setArg(key, args[i + 1] === "true", arg);
+              i++;
+            } else {
+              setArg(key, flags.strings[key] ? "" : true, arg);
+            }
+          }
+        } else {
+          if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+            argv._.push(
+              flags.strings["_"] || !isNumber(arg) ? arg : Number(arg)
+            );
+          }
+          if (opts.stopEarly) {
+            argv._.push.apply(argv._, args.slice(i + 1));
+            break;
+          }
+        }
+      }
+      Object.keys(defaults).forEach(function(key2) {
+        if (!hasKey(argv, key2.split("."))) {
+          setKey(argv, key2.split("."), defaults[key2]);
+          (aliases[key2] || []).forEach(function(x) {
+            setKey(argv, x.split("."), defaults[key2]);
+          });
+        }
+      });
+      if (opts["--"]) {
+        argv["--"] = new Array();
+        notFlags.forEach(function(key2) {
+          argv["--"].push(key2);
+        });
+      } else {
+        notFlags.forEach(function(key2) {
+          argv._.push(key2);
+        });
+      }
+      return argv;
+    };
+    function hasKey(obj, keys) {
+      var o = obj;
+      keys.slice(0, -1).forEach(function(key2) {
+        o = o[key2] || {};
+      });
+      var key = keys[keys.length - 1];
+      return key in o;
+    }
+    __name(hasKey, "hasKey");
+    function isNumber(x) {
+      if (typeof x === "number") return true;
+      if (/^0x[0-9a-f]+$/i.test(x)) return true;
+      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+    }
+    __name(isNumber, "isNumber");
+    function isConstructorOrProto(obj, key) {
+      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    }
+    __name(isConstructorOrProto, "isConstructorOrProto");
+  }
+});
+var require_rc = __commonJS2({
+  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports2, module2) {
+    var cc = require_utils2();
+    var join22 = __require("path").join;
+    var deepExtend = require_deep_extend();
+    var etc = "/etc";
+    var win = process.platform === "win32";
+    var home = win ? process.env.USERPROFILE : process.env.HOME;
+    module2.exports = function(name3, defaults, argv, parse10) {
+      if ("string" !== typeof name3)
+        throw new Error("rc(name): name *must* be string");
+      if (!argv)
+        argv = require_minimist()(process.argv.slice(2));
+      defaults = ("string" === typeof defaults ? cc.json(defaults) : defaults) || {};
+      parse10 = parse10 || cc.parse;
+      var env3 = cc.env(name3 + "_");
+      var configs = [defaults];
+      var configFiles = [];
+      function addConfigFile(file2) {
+        if (configFiles.indexOf(file2) >= 0) return;
+        var fileConfig = cc.file(file2);
+        if (fileConfig) {
+          configs.push(parse10(fileConfig));
+          configFiles.push(file2);
+        }
+      }
+      __name(addConfigFile, "addConfigFile");
+      if (!win)
+        [
+          join22(etc, name3, "config"),
+          join22(etc, name3 + "rc")
+        ].forEach(addConfigFile);
+      if (home)
+        [
+          join22(home, ".config", name3, "config"),
+          join22(home, ".config", name3),
+          join22(home, "." + name3, "config"),
+          join22(home, "." + name3 + "rc")
+        ].forEach(addConfigFile);
+      addConfigFile(cc.find("." + name3 + "rc"));
+      if (env3.config) addConfigFile(env3.config);
+      if (argv.config) addConfigFile(argv.config);
+      return deepExtend.apply(null, configs.concat([
+        env3,
+        argv,
+        configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
+      ]));
+    };
+  }
+});
+var require_registry_url = __commonJS2({
+  "../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js"(exports2, module2) {
+    module2.exports = function(scope) {
+      var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      var url = rc[scope + ":registry"] || rc.registry;
+      return url.slice(-1) === "/" ? url : url + "/";
+    };
+  }
+});
+var require_safe_buffer = __commonJS2({
+  "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module2) {
+    var buffer = __require("buffer");
+    var Buffer22 = buffer.Buffer;
+    function copyProps(src, dst) {
+      for (var key in src) {
+        dst[key] = src[key];
+      }
+    }
+    __name(copyProps, "copyProps");
+    if (Buffer22.from && Buffer22.alloc && Buffer22.allocUnsafe && Buffer22.allocUnsafeSlow) {
+      module2.exports = buffer;
+    } else {
+      copyProps(buffer, exports2);
+      exports2.Buffer = SafeBuffer;
+    }
+    function SafeBuffer(arg, encodingOrOffset, length) {
+      return Buffer22(arg, encodingOrOffset, length);
+    }
+    __name(SafeBuffer, "SafeBuffer");
+    SafeBuffer.prototype = Object.create(Buffer22.prototype);
+    copyProps(Buffer22, SafeBuffer);
+    SafeBuffer.from = function(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        throw new TypeError("Argument must not be a number");
+      }
+      return Buffer22(arg, encodingOrOffset, length);
+    };
+    SafeBuffer.alloc = function(size, fill, encoding) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      var buf = Buffer22(size);
+      if (fill !== void 0) {
+        if (typeof encoding === "string") {
+          buf.fill(fill, encoding);
+        } else {
+          buf.fill(fill);
+        }
+      } else {
+        buf.fill(0);
+      }
+      return buf;
+    };
+    SafeBuffer.allocUnsafe = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return Buffer22(size);
+    };
+    SafeBuffer.allocUnsafeSlow = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return buffer.SlowBuffer(size);
+    };
+  }
+});
+var require_base64 = __commonJS2({
+  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js"(exports2, module2) {
+    var safeBuffer = require_safe_buffer().Buffer;
+    function decodeBase64(base64) {
+      return safeBuffer.from(base64, "base64").toString("utf8");
+    }
+    __name(decodeBase64, "decodeBase64");
+    function encodeBase64(string) {
+      return safeBuffer.from(string, "utf8").toString("base64");
+    }
+    __name(encodeBase64, "encodeBase64");
+    module2.exports = {
+      decodeBase64,
+      encodeBase64
+    };
+  }
+});
+var require_registry_auth_token = __commonJS2({
+  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js"(exports2, module2) {
+    var url = __require("url");
+    var base64 = require_base64();
+    var decodeBase64 = base64.decodeBase64;
+    var encodeBase64 = base64.encodeBase64;
+    var tokenKey = ":_authToken";
+    var userKey = ":username";
+    var passwordKey = ":_password";
+    module2.exports = function() {
+      var checkUrl;
+      var options;
+      if (arguments.length >= 2) {
+        checkUrl = arguments[0];
+        options = arguments[1];
+      } else if (typeof arguments[0] === "string") {
+        checkUrl = arguments[0];
+      } else {
+        options = arguments[0];
+      }
+      options = options || {};
+      options.npmrc = options.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      checkUrl = checkUrl || options.npmrc.registry;
+      return getRegistryAuthInfo(checkUrl, options) || getLegacyAuthInfo(options.npmrc);
+    };
+    function getRegistryAuthInfo(checkUrl, options) {
+      var parsed = url.parse(checkUrl, false, true);
+      var pathname;
+      while (pathname !== "/" && parsed.pathname !== pathname) {
+        pathname = parsed.pathname || "/";
+        var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
+        var authInfo = getAuthInfoForUrl(regUrl, options.npmrc);
+        if (authInfo) {
+          return authInfo;
+        }
+        if (!options.recursive) {
+          return /\/$/.test(checkUrl) ? void 0 : getRegistryAuthInfo(url.resolve(checkUrl, "."), options);
+        }
+        parsed.pathname = url.resolve(normalizePath(pathname), "..") || "/";
+      }
+      return void 0;
+    }
+    __name(getRegistryAuthInfo, "getRegistryAuthInfo");
+    function getLegacyAuthInfo(npmrc) {
+      if (npmrc._auth) {
+        return { token: npmrc._auth, type: "Basic" };
+      }
+      return void 0;
+    }
+    __name(getLegacyAuthInfo, "getLegacyAuthInfo");
+    function normalizePath(path52) {
+      return path52[path52.length - 1] === "/" ? path52 : path52 + "/";
+    }
+    __name(normalizePath, "normalizePath");
+    function getAuthInfoForUrl(regUrl, npmrc) {
+      var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
+      if (bearerAuth) {
+        return bearerAuth;
+      }
+      var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
+      var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
+      var basicAuth = getTokenForUsernameAndPassword(username, password);
+      if (basicAuth) {
+        return basicAuth;
+      }
+      return void 0;
+    }
+    __name(getAuthInfoForUrl, "getAuthInfoForUrl");
+    function getBearerToken(tok) {
+      if (!tok) {
+        return void 0;
+      }
+      var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      });
+      return { token, type: "Bearer" };
+    }
+    __name(getBearerToken, "getBearerToken");
+    function getTokenForUsernameAndPassword(username, password) {
+      if (!username || !password) {
+        return void 0;
+      }
+      var pass = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      }));
+      var token = encodeBase64(username + ":" + pass);
+      return {
+        token,
+        type: "Basic",
+        password: pass,
+        username
+      };
+    }
+    __name(getTokenForUsernameAndPassword, "getTokenForUsernameAndPassword");
+  }
+});
+var require_update_check = __commonJS2({
+  "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports2, module2) {
+    var { URL: URL2 } = __require("url");
+    var { join: join22 } = __require("path");
+    var fs32 = __require("fs");
+    var { promisify: promisify7 } = __require("util");
+    var { tmpdir: tmpdir4 } = __require("os");
+    var registryUrl = require_registry_url();
+    var writeFile4 = promisify7(fs32.writeFile);
+    var mkdir = promisify7(fs32.mkdir);
+    var readFile2 = promisify7(fs32.readFile);
+    var compareVersions = /* @__PURE__ */ __name((a, b2) => a.localeCompare(b2, "en-US", { numeric: true }), "compareVersions");
+    var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
+    var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
+      const rootDir = tmpdir4();
+      const subDir = join22(rootDir, "update-check");
+      if (!fs32.existsSync(subDir)) {
+        await mkdir(subDir);
+      }
+      let name3 = `${details.name}-${distTag}.json`;
+      if (details.scope) {
+        name3 = `${details.scope}-${name3}`;
+      }
+      return join22(subDir, name3);
+    }, "getFile");
+    var evaluateCache = /* @__PURE__ */ __name(async (file2, time, interval) => {
+      if (fs32.existsSync(file2)) {
+        const content = await readFile2(file2, "utf8");
+        const { lastUpdate, latest } = JSON.parse(content);
+        const nextCheck = lastUpdate + interval;
+        if (nextCheck > time) {
+          return {
+            shouldCheck: false,
+            latest
+          };
+        }
+      }
+      return {
+        shouldCheck: true,
+        latest: null
+      };
+    }, "evaluateCache");
+    var updateCache = /* @__PURE__ */ __name(async (file2, latest, lastUpdate) => {
+      const content = JSON.stringify({
+        latest,
+        lastUpdate
+      });
+      await writeFile4(file2, content, "utf8");
+    }, "updateCache");
+    var loadPackage = /* @__PURE__ */ __name((url, authInfo) => new Promise((resolve12, reject) => {
+      const options = {
+        host: url.hostname,
+        path: url.pathname,
+        port: url.port,
+        headers: {
+          accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+        },
+        timeout: 2e3
+      };
+      if (authInfo) {
+        options.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+      }
+      const { get } = url.protocol === "https:" ? __require("https") : __require("http");
+      get(options, (response) => {
+        const { statusCode } = response;
+        if (statusCode !== 200) {
+          const error2 = new Error(`Request failed with code ${statusCode}`);
+          error2.code = statusCode;
+          reject(error2);
+          response.resume();
+          return;
+        }
+        let rawData = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          rawData += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsedData = JSON.parse(rawData);
+            resolve12(parsedData);
+          } catch (e2) {
+            reject(e2);
+          }
+        });
+      }).on("error", reject).on("timeout", reject);
+    }), "loadPackage");
+    var getMostRecent = /* @__PURE__ */ __name(async ({ full, scope }, distTag) => {
+      const regURL = registryUrl(scope);
+      const url = new URL2(full, regURL);
+      let spec = null;
+      try {
+        spec = await loadPackage(url);
+      } catch (err) {
+        if (err.code && String(err.code).startsWith(4)) {
+          const registryAuthToken = require_registry_auth_token();
+          const authInfo = registryAuthToken(regURL, { recursive: true });
+          spec = await loadPackage(url, authInfo);
+        } else {
+          throw err;
+        }
+      }
+      const version3 = spec["dist-tags"][distTag];
+      if (!version3) {
+        throw new Error(`Distribution tag ${distTag} is not available`);
+      }
+      return version3;
+    }, "getMostRecent");
+    var defaultConfig = {
+      interval: 36e5,
+      distTag: "latest"
+    };
+    var getDetails = /* @__PURE__ */ __name((name3) => {
+      const spec = {
+        full: encode(name3)
+      };
+      if (name3.includes("/")) {
+        const parts = name3.split("/");
+        spec.scope = parts[0];
+        spec.name = parts[1];
+      } else {
+        spec.scope = null;
+        spec.name = name3;
+      }
+      return spec;
+    }, "getDetails");
+    module2.exports = async (pkg, config49) => {
+      if (typeof pkg !== "object") {
+        throw new Error("The first parameter should be your package.json file content");
+      }
+      const details = getDetails(pkg.name);
+      const time = Date.now();
+      const { distTag, interval } = Object.assign({}, defaultConfig, config49);
+      const file2 = await getFile(details, distTag);
+      let latest = null;
+      let shouldCheck = true;
+      ({ shouldCheck, latest } = await evaluateCache(file2, time, interval));
+      if (shouldCheck) {
+        latest = await getMostRecent(details, distTag);
+        await updateCache(file2, latest, time);
+      }
+      const comparision = compareVersions(pkg.version, latest);
+      if (comparision === -1) {
+        return {
+          latest,
+          fromCache: !shouldCheck
+        };
+      }
+      return null;
+    };
+  }
+});
 var defaultWranglerConfig = {
   /* COMPUTED_FIELDS */
   configPath: void 0,
@@ -78556,6 +79688,8 @@ var defaultWranglerConfig = {
   vectorize: [],
   ai_search_namespaces: [],
   ai_search: [],
+  web_search: void 0,
+  agent_memory: [],
   hyperdrive: [],
   workflows: [],
   secrets_store_secrets: [],
@@ -78990,8 +80124,8 @@ function getErrorMap() {
 }
 __name(getErrorMap, "getErrorMap");
 var makeIssue = /* @__PURE__ */ __name((params) => {
-  const { data, path: path42, errorMaps, issueData } = params;
-  const fullPath = [...path42, ...issueData.path || []];
+  const { data, path: path52, errorMaps, issueData } = params;
+  const fullPath = [...path52, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -79097,11 +80231,11 @@ var ParseInputLazyPath = class {
   static {
     __name(this, "ParseInputLazyPath");
   }
-  constructor(parent, value, path42, key) {
+  constructor(parent, value, path52, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path42;
+    this._path = path52;
     this._key = key;
   }
   get path() {
@@ -82594,7 +83728,8 @@ var getWranglerSendMetricsFromEnv = getBooleanEnvironmentVariableFactory({
   variableName: "WRANGLER_SEND_METRICS"
 });
 var getWranglerSendErrorReportsFromEnv = getBooleanEnvironmentVariableFactory({
-  variableName: "WRANGLER_SEND_ERROR_REPORTS"
+  variableName: "WRANGLER_SEND_ERROR_REPORTS",
+  defaultValue: false
 });
 var getCloudflareApiEnvironmentFromEnv = getEnvironmentVariableFactory(
   {
@@ -82883,9 +84018,9 @@ Please add "${field}" to "env.${envName}".`
   return rawEnv[field] ?? defaultValue;
 }
 __name(notInheritable, "notInheritable");
-function unwindPropertyPath(root, path42) {
+function unwindPropertyPath(root, path52) {
   let container = root;
-  const parts = path42.split(".");
+  const parts = path52.split(".");
   for (let i = 0; i < parts.length - 1; i++) {
     if (!hasProperty(container, parts[i])) {
       return;
@@ -83157,6 +84292,8 @@ var friendlyBindingNames = {
   vectorize: "Vectorize Index",
   ai_search_namespaces: "AI Search Namespace",
   ai_search: "AI Search Instance",
+  web_search: "Web Search",
+  agent_memory: "Agent Memory",
   hyperdrive: "Hyperdrive Config",
   r2_buckets: "R2 Bucket",
   logfwdr: "logfwdr",
@@ -83209,6 +84346,8 @@ var bindingTypeFriendlyNames = {
   vectorize: "Vectorize Index",
   ai_search_namespace: "AI Search Namespace",
   ai_search: "AI Search Instance",
+  web_search: "Web Search",
+  agent_memory: "Agent Memory",
   hyperdrive: "Hyperdrive Config",
   service: "Worker",
   fetcher: "Service Binding",
@@ -84403,6 +85542,26 @@ function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, isDisp
       validateBindingArray(envName, validateAISearchBinding),
       []
     ),
+    web_search: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "web_search",
+      validateNamedSimpleBinding(envName),
+      void 0
+    ),
+    agent_memory: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "agent_memory",
+      validateBindingArray(envName, validateAgentMemoryBinding),
+      []
+    ),
     hyperdrive: notInheritable(
       diagnostics,
       topLevelEnv,
@@ -85199,6 +86358,42 @@ var validateWorkflowBinding = /* @__PURE__ */ __name((diagnostics, field, value)
     );
     isValid2 = false;
   }
+  if (hasProperty(value, "schedules") && value.schedules !== void 0) {
+    if (typeof value.schedules === "string") {
+      if (value.schedules.length === 0) {
+        diagnostics.errors.push(
+          `"${field}" bindings "schedules" field must not be an empty string.`
+        );
+        isValid2 = false;
+      }
+    } else if (Array.isArray(value.schedules)) {
+      if (value.schedules.length === 0) {
+        diagnostics.errors.push(
+          `"${field}" bindings "schedules" field must not be an empty array.`
+        );
+        isValid2 = false;
+      } else if (!value.schedules.every((s) => typeof s === "string")) {
+        diagnostics.errors.push(
+          `"${field}" bindings should, optionally, have a string or array of strings "schedules" field but got ${JSON.stringify(
+            value
+          )}.`
+        );
+        isValid2 = false;
+      } else if (value.schedules.some((s) => s === "")) {
+        diagnostics.errors.push(
+          `"${field}" bindings "schedules" field must not contain empty strings.`
+        );
+        isValid2 = false;
+      }
+    } else {
+      diagnostics.errors.push(
+        `"${field}" bindings should, optionally, have a string or array of strings "schedules" field but got ${JSON.stringify(
+          value
+        )}.`
+      );
+      isValid2 = false;
+    }
+  }
   if (hasProperty(value, "limits") && value.limits !== void 0) {
     if (typeof value.limits !== "object" || value.limits === null || Array.isArray(value.limits)) {
       diagnostics.errors.push(
@@ -85237,7 +86432,8 @@ var validateWorkflowBinding = /* @__PURE__ */ __name((diagnostics, field, value)
     "class_name",
     "script_name",
     "remote",
-    "limits"
+    "limits",
+    "schedules"
   ]);
   return isValid2;
 }, "validateWorkflowBinding");
@@ -85449,6 +86645,8 @@ var validateUnsafeBinding = /* @__PURE__ */ __name((diagnostics, field, value) =
       "ai",
       "ai_search_namespace",
       "ai_search",
+      "web_search",
+      "agent_memory",
       "kv_namespace",
       "durable_object_namespace",
       "d1_database",
@@ -86364,6 +87562,36 @@ var validateAISearchBinding = /* @__PURE__ */ __name((diagnostics, field, value)
   ]);
   return isValid2;
 }, "validateAISearchBinding");
+var validateAgentMemoryBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+  if (typeof value !== "object" || value === null) {
+    diagnostics.errors.push(
+      `"agent_memory" bindings should be objects, but got ${JSON.stringify(value)}`
+    );
+    return false;
+  }
+  let isValid2 = true;
+  if (!isRequiredProperty(value, "binding", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(value)}.`
+    );
+    isValid2 = false;
+  }
+  if (!isRequiredProperty(value, "namespace", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings must have a "namespace" field but got ${JSON.stringify(value)}.`
+    );
+    isValid2 = false;
+  }
+  if (!isRemoteValid(value, field, diagnostics)) {
+    isValid2 = false;
+  }
+  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+    "binding",
+    "namespace",
+    "remote"
+  ]);
+  return isValid2;
+}, "validateAgentMemoryBinding");
 var validateHyperdriveBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
   if (typeof value !== "object" || value === null) {
     diagnostics.errors.push(
@@ -86863,9 +88091,17 @@ var validatePipelineBinding = /* @__PURE__ */ __name((diagnostics, field, value)
     );
     isValid2 = false;
   }
-  if (!isRequiredProperty(value, "pipeline", "string")) {
+  const hasStream = isOptionalProperty(value, "stream", "string");
+  const hasPipeline = isOptionalProperty(value, "pipeline", "string");
+  const v = value;
+  if (hasStream && v.stream) ;
+  else if (hasPipeline && v.pipeline) {
+    diagnostics.warnings.push(
+      `The "pipeline" field in "${field}" bindings is deprecated. Use "stream" instead.`
+    );
+  } else {
     diagnostics.errors.push(
-      `"${field}" bindings must have a string "pipeline" field but got ${JSON.stringify(
+      `"${field}" bindings must have a string "stream" field but got ${JSON.stringify(
         value
       )}.`
     );
@@ -86876,6 +88112,7 @@ var validatePipelineBinding = /* @__PURE__ */ __name((diagnostics, field, value)
   }
   validateAdditionalProperties(diagnostics, field, Object.keys(value), [
     "binding",
+    "stream",
     "pipeline",
     "remote"
   ]);
@@ -87773,6 +89010,59 @@ function isDockerfile(imagePath, configPath) {
   return false;
 }
 __name(isDockerfile, "isDockerfile");
+var BINDING_LOCAL_SUPPORT = {
+  plain_text: "local-only",
+  secret_text: "local-only",
+  json: "local-only",
+  wasm_module: "local-only",
+  text_blob: "local-only",
+  data_blob: "local-only",
+  version_metadata: "local-only",
+  inherit: "local-only",
+  logfwdr: "local-only",
+  assets: "local-only",
+  unsafe_hello_world: "local-only",
+  durable_object_namespace: "local-only",
+  hyperdrive: "local-only",
+  fetcher: "local-only",
+  analytics_engine: "local-only",
+  secrets_store_secret: "local-only",
+  ratelimit: "local-only",
+  worker_loader: "local-only",
+  kv_namespace: "local-and-remote",
+  r2_bucket: "local-and-remote",
+  d1: "local-and-remote",
+  workflow: "local-and-remote",
+  browser: "local-and-remote",
+  images: "local-and-remote",
+  stream: "local-and-remote",
+  send_email: "local-and-remote",
+  pipeline: "local-and-remote",
+  service: "local-and-remote",
+  // TODO: Miniflare currently ignores `remote: true` on queues, tracked in #13727.
+  queue: "local-and-remote",
+  vectorize: "remote",
+  mtls_certificate: "remote",
+  dispatch_namespace: "remote",
+  // Reach out to the @cloudflare/wrangler team before adding anything here
+  ai: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  ai_search: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  ai_search_namespace: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  media: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  artifacts: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  flagship: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  vpc_service: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  vpc_network: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  web_search: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  agent_memory: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator"
+};
+function getBindingLocalSupport(type) {
+  if (type in BINDING_LOCAL_SUPPORT) {
+    return BINDING_LOCAL_SUPPORT[type];
+  }
+  return "local-only";
+}
+__name(getBindingLocalSupport, "getBindingLocalSupport");
 var supportedPagesConfigFields = [
   "pages_build_output_dir",
   "name",
@@ -87902,6 +89192,64 @@ Pages requires Durable Object bindings to specify the name of the Worker where t
   }
 }
 __name(validateDurableObjectBinding2, "validateDurableObjectBinding");
+var import_signal_exit = __toESM2(require_signal_exit());
+function getWranglerHiddenDirPath(projectRoot) {
+  projectRoot ??= process.cwd();
+  return import_node_path2.default.join(projectRoot, ".wrangler");
+}
+__name(getWranglerHiddenDirPath, "getWranglerHiddenDirPath");
+var STALE_WRANGLER_TMP_DIR_MS = 24 * 60 * 60 * 1e3;
+var sweptTmpRoots = /* @__PURE__ */ new Set();
+function sweepStaleWranglerTmpDirs(tmpRoot) {
+  if (sweptTmpRoots.has(tmpRoot)) {
+    return;
+  }
+  sweptTmpRoots.add(tmpRoot);
+  let entries;
+  try {
+    entries = import_node_fs2.default.readdirSync(tmpRoot, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - STALE_WRANGLER_TMP_DIR_MS;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const entryPath = import_node_path2.default.join(tmpRoot, entry.name);
+    try {
+      if (import_node_fs2.default.statSync(entryPath).mtimeMs < cutoff) {
+        removeDirSync(entryPath);
+      }
+    } catch {
+    }
+  }
+}
+__name(sweepStaleWranglerTmpDirs, "sweepStaleWranglerTmpDirs");
+function getWranglerTmpDir(projectRoot, prefix, cleanup = true) {
+  const tmpRoot = import_node_path2.default.join(getWranglerHiddenDirPath(projectRoot), "tmp");
+  import_node_fs2.default.mkdirSync(tmpRoot, { recursive: true });
+  sweepStaleWranglerTmpDirs(tmpRoot);
+  const tmpPrefix = import_node_path2.default.join(tmpRoot, `${prefix}-`);
+  const tmpDir = import_node_fs2.default.realpathSync(import_node_fs2.default.mkdtempSync(tmpPrefix));
+  const cleanupDir = /* @__PURE__ */ __name(() => {
+    if (cleanup) {
+      try {
+        removeDirSync(tmpDir);
+      } catch {
+      }
+    }
+  }, "cleanupDir");
+  const removeExitListener = (0, import_signal_exit.default)(cleanupDir);
+  return {
+    path: tmpDir,
+    remove() {
+      removeExitListener();
+      cleanupDir();
+    }
+  };
+}
+__name(getWranglerTmpDir, "getWranglerTmpDir");
 var import_command_exists = __toESM2(require_command_exists2());
 var UPDATE_SERVICE_URL = "https://update.argotunnel.com";
 var CLOUDFLARED_VERSION_PATTERN = /^\d{4}\.\d+\.\d+$/;
@@ -88275,18 +89623,6 @@ __name(downloadCloudflared, "downloadCloudflared");
 async function downloadAndExtractTarball(response, expectedChecksum, binPath, cacheDir) {
   const tempTarPath = (0, import_node_path2.join)(cacheDir, "cloudflared.tgz");
   const buffer = Buffer.from(await response.arrayBuffer());
-  if (expectedChecksum) {
-    const actualSha256 = sha256Hex(buffer);
-    if (actualSha256 !== expectedChecksum) {
-      throw new UserError(
-        `[cloudflared] SHA256 mismatch for downloaded cloudflared tarball.
-
-Expected: ${expectedChecksum}
-Actual:   ${actualSha256}`,
-        { telemetryMessage: "tunnel cloudflared tarball checksum mismatch" }
-      );
-    }
-  }
   (0, import_node_fs2.writeFileSync)(tempTarPath, buffer);
   try {
     (0, import_node_child_process.execFileSync)("tar", ["-xzf", tempTarPath, "-C", cacheDir], {
@@ -88296,6 +89632,21 @@ Actual:   ${actualSha256}`,
     if (extractedPath !== binPath && (0, import_node_fs2.existsSync)(extractedPath)) {
       (0, import_node_fs2.renameSync)(extractedPath, binPath);
     }
+    if (expectedChecksum) {
+      const extractedBinary = (0, import_node_fs2.readFileSync)(binPath);
+      const actualSha256 = sha256Hex(extractedBinary);
+      if (actualSha256 !== expectedChecksum) {
+        throw new UserError(
+          `[cloudflared] SHA256 mismatch for downloaded cloudflared binary.
+
+Expected: ${expectedChecksum}
+Actual:   ${actualSha256}`,
+          {
+            telemetryMessage: "tunnel cloudflared extracted binary checksum mismatch"
+          }
+        );
+      }
+    }
   } finally {
     try {
       if ((0, import_node_fs2.existsSync)(tempTarPath)) {
@@ -88651,6 +90002,35 @@ The local dev server started at ${origin.href}.
   return new Error(errorMessage);
 }
 __name(createTunnelStartupError, "createTunnelStartupError");
+var import_update_check = __toESM2(require_update_check());
+var UPDATE_CHECK_TIMEOUT_MS = 3e3;
+var TIMED_OUT = /* @__PURE__ */ Symbol("timed_out");
+async function fetchLatestNpmVersion(name3, version3) {
+  let result = null;
+  try {
+    result = await Promise.race([
+      (0, import_update_check.default)(
+        { name: name3, version: version3 },
+        {
+          distTag: version3.startsWith("0.0.0") ? "beta" : "latest"
+        }
+      ),
+      timersPromises.setTimeout(UPDATE_CHECK_TIMEOUT_MS, TIMED_OUT, {
+        ref: false
+      })
+    ]);
+  } catch {
+    return { status: "failed" };
+  }
+  if (result === TIMED_OUT) {
+    return { status: "failed" };
+  }
+  if (result === null) {
+    return { status: "up-to-date" };
+  }
+  return { status: "update-available", latest: result.latest };
+}
+__name(fetchLatestNpmVersion, "fetchLatestNpmVersion");
 
 // ../cli/dist/check-macos-version.mjs
 var import_ci_info = __toESM(require_ci_info(), 1);
@@ -89633,9 +91013,9 @@ var import_node_process5 = __toESM(require("node:process"), 1);
 // ../../node_modules/.pnpm/restore-cursor@4.0.0/node_modules/restore-cursor/index.js
 var import_node_process4 = __toESM(require("node:process"), 1);
 var import_onetime = __toESM(require_onetime(), 1);
-var import_signal_exit = __toESM(require_signal_exit(), 1);
+var import_signal_exit2 = __toESM(require_signal_exit2(), 1);
 var restoreCursor = (0, import_onetime.default)(() => {
-  (0, import_signal_exit.default)(() => {
+  (0, import_signal_exit2.default)(() => {
     import_node_process4.default.stderr.write("\x1B[?25h");
   }, { alwaysLast: true });
 });
@@ -95618,7 +96998,7 @@ var Yargs = YargsFactory(esm_default2);
 var yargs_default = Yargs;
 
 // package.json
-var version = "2.68.3";
+var version = "2.69.0";
 
 // src/metrics.ts
 var import_node_async_hooks = require("node:async_hooks");
@@ -97829,14 +99209,14 @@ __name2(getPropertyName, "getPropertyName");
 var package_default = {
   name: "frameworks_clis_info",
   dependencies: {
-    "@angular/create": "21.2.11",
-    "@tanstack/create-start": "0.59.32",
-    "create-analog": "2.5.1",
+    "@angular/create": "21.2.12",
+    "@tanstack/cli": "0.68.0",
+    "create-analog": "2.5.2",
     "create-astro": "5.0.6",
     "create-docusaurus": "3.10.1",
     "create-hono": "0.19.4",
     "create-next-app": "16.2.6",
-    "create-qwik": "1.19.2",
+    "create-qwik": "1.20.0",
     "create-react-router": "7.15.1",
     "create-rwsdk": "3.1.3",
     "create-solid": "0.7.0",
@@ -100008,6 +101388,8 @@ var c3_default43 = config40;
 var { npm: npm19 } = detectPackageManager();
 var generate25 = async (ctx) => {
   await runFrameworkGenerator(ctx, [
+    // @tanstack/cli uses `create` as a subcommand
+    "create",
     ctx.project.name,
     "--deployment",
     "cloudflare",
@@ -100022,7 +101404,7 @@ var config41 = {
   configVersion: 1,
   id: "tanstack-start",
   platform: "workers",
-  frameworkCli: "@tanstack/create-start",
+  frameworkCli: "@tanstack/cli",
   displayName: "TanStack Start",
   generate: generate25,
   transformPackageJson: async () => ({
@@ -100304,7 +101686,7 @@ If the application uses Durable Objects or Workflows, refer to the relevant best
 var import_node_assert6 = __toESM(require("node:assert"));
 
 // ../wrangler/package.json
-var version2 = "4.93.0";
+var version2 = "4.96.0";
 
 // src/git.ts
 var offerGit = async (ctx) => {
@@ -104396,6 +105778,39 @@ smol-toml/dist/index.js:
 */
 /*! Bundled license information:
 
+deep-extend/lib/deep-extend.js:
+  (*!
+   * @description Recursive object extending
+   * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+   * @license MIT
+   *
+   * The MIT License (MIT)
+   *
+   * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+   *
+   * Permission is hereby granted, free of charge, to any person obtaining a copy of
+   * this software and associated documentation files (the "Software"), to deal in
+   * the Software without restriction, including without limitation the rights to
+   * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+   * the Software, and to permit persons to whom the Software is furnished to do so,
+   * subject to the following conditions:
+   *
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+   * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+   * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+   * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   *)
+
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/
+/*! Bundled license information:
+
 undici/lib/web/fetch/body.js:
   (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)