create-cloudflare 2.68.4 → 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) {
@@ -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;
@@ -77820,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;
@@ -78650,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,
@@ -78699,6 +79688,8 @@ var defaultWranglerConfig = {
   vectorize: [],
   ai_search_namespaces: [],
   ai_search: [],
+  web_search: void 0,
+  agent_memory: [],
   hyperdrive: [],
   workflows: [],
   secrets_store_secrets: [],
@@ -82737,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(
   {
@@ -83300,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",
@@ -83352,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",
@@ -84546,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,
@@ -85629,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",
@@ -86544,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(
@@ -87043,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
       )}.`
     );
@@ -87056,6 +88112,7 @@ var validatePipelineBinding = /* @__PURE__ */ __name((diagnostics, field, value)
   }
   validateAdditionalProperties(diagnostics, field, Object.keys(value), [
     "binding",
+    "stream",
     "pipeline",
     "remote"
   ]);
@@ -87995,7 +89052,9 @@ var BINDING_LOCAL_SUPPORT = {
   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"
+  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) {
@@ -88564,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], {
@@ -88585,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)) {
@@ -88940,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);
@@ -95907,7 +96998,7 @@ var Yargs = YargsFactory(esm_default2);
 var yargs_default = Yargs;
 
 // package.json
-var version = "2.68.4";
+var version = "2.69.0";
 
 // src/metrics.ts
 var import_node_async_hooks = require("node:async_hooks");
@@ -98119,7 +99210,7 @@ var package_default = {
   name: "frameworks_clis_info",
   dependencies: {
     "@angular/create": "21.2.12",
-    "@tanstack/create-start": "0.59.32",
+    "@tanstack/cli": "0.68.0",
     "create-analog": "2.5.2",
     "create-astro": "5.0.6",
     "create-docusaurus": "3.10.1",
@@ -100297,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",
@@ -100311,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 () => ({
@@ -100593,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.95.0";
+var version2 = "4.96.0";
 
 // src/git.ts
 var offerGit = async (ctx) => {
@@ -104685,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> *)