@shopify/create-app 3.76.2 → 3.77.1

package/dist/{chunk-DH5OC5ON.js → chunk-PC72P66L.js}

@@ -9,7 +9,7 @@ import {
   packageManagerFromUserAgent,
   removeSession,
   setSession
-} from "./chunk-DVNRCA3A.js";
+} from "./chunk-EOJTBQOC.js";
 import {
   AbortError,
   BugError,
@@ -27,11 +27,13 @@ import {
   hashString,
   import_ts_error,
   isAppManagementDisabled,
+  isCI,
   isCloudEnvironment,
   isSpin,
   isTTY,
   keypress,
   macAddress,
+  maxRequestTimeForNetworkCallsMs,
   nonRandomUUID,
   openURL,
   outputCompleted,
@@ -43,9 +45,11 @@ import {
   runWithTimer,
   serviceEnvironment,
   sessionConstants,
+  skipNetworkLevelRetry,
+  sleep,
   spinFqdn,
   themeToken
-} from "./chunk-4YFG4SYR.js";
+} from "./chunk-J27B2HLC.js";
 import {
   cwd
 } from "./chunk-ZUCWDIGE.js";
@@ -15528,11 +15532,11 @@ var require_url_state_machine = __commonJS({
     function isSpecialScheme(scheme) {
       return specialSchemes[scheme] !== void 0;
     }
-    function isSpecial(url) {
-      return isSpecialScheme(url.scheme);
+    function isSpecial(url4) {
+      return isSpecialScheme(url4.scheme);
     }
-    function isNotSpecial(url) {
-      return !isSpecialScheme(url.scheme);
+    function isNotSpecial(url4) {
+      return !isSpecialScheme(url4.scheme);
     }
     function defaultPort(scheme) {
       return specialSchemes[scheme];
@@ -15679,8 +15683,8 @@ var require_url_state_machine = __commonJS({
         arr[i] !== 0 ? (currLen > maxLen && (maxIdx = currStart, maxLen = currLen), currStart = null, currLen = 0) : (currStart === null && (currStart = i), ++currLen);
       return currLen > maxLen ? currStart : maxIdx;
     }
-    function serializeHost(host) {
-      return typeof host == "number" ? serializeIPv4(host) : host instanceof Array ? `[${serializeIPv6(host)}]` : host;
+    function serializeHost(host4) {
+      return typeof host4 == "number" ? serializeIPv4(host4) : host4 instanceof Array ? `[${serializeIPv6(host4)}]` : host4;
     }
     function domainToASCII(domain, beStrict = !1) {
       let result = tr46.toASCII(domain, {
@@ -15692,30 +15696,30 @@ var require_url_state_machine = __commonJS({
       });
       return result === null || result === "" ? failure : result;
     }
-    function trimControlChars(url) {
-      return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/ug, "");
+    function trimControlChars(url4) {
+      return url4.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/ug, "");
     }
-    function trimTabAndNewline(url) {
-      return url.replace(/\u0009|\u000A|\u000D/ug, "");
+    function trimTabAndNewline(url4) {
+      return url4.replace(/\u0009|\u000A|\u000D/ug, "");
     }
-    function shortenPath(url) {
-      let { path } = url;
-      path.length !== 0 && (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0]) || path.pop());
+    function shortenPath(url4) {
+      let { path } = url4;
+      path.length !== 0 && (url4.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0]) || path.pop());
     }
-    function includesCredentials(url) {
-      return url.username !== "" || url.password !== "";
+    function includesCredentials(url4) {
+      return url4.username !== "" || url4.password !== "";
     }
-    function cannotHaveAUsernamePasswordPort(url) {
-      return url.host === null || url.host === "" || url.scheme === "file";
+    function cannotHaveAUsernamePasswordPort(url4) {
+      return url4.host === null || url4.host === "" || url4.scheme === "file";
     }
-    function hasAnOpaquePath(url) {
-      return typeof url.path == "string";
+    function hasAnOpaquePath(url4) {
+      return typeof url4.path == "string";
     }
     function isNormalizedWindowsDriveLetter(string) {
       return /^[A-Za-z]:$/u.test(string);
     }
-    function URLStateMachine(input, base, encodingOverride, url, stateOverride) {
-      if (this.pointer = 0, this.input = input, this.base = base || null, this.encodingOverride = encodingOverride || "utf-8", this.stateOverride = stateOverride, this.url = url, this.failure = !1, this.parseError = !1, !this.url) {
+    function URLStateMachine(input, base, encodingOverride, url4, stateOverride) {
+      if (this.pointer = 0, this.input = input, this.base = base || null, this.encodingOverride = encodingOverride || "utf-8", this.stateOverride = stateOverride, this.url = url4, this.failure = !1, this.parseError = !1, !this.url) {
         this.url = {
           scheme: "",
           username: "",
@@ -15815,19 +15819,19 @@ var require_url_state_machine = __commonJS({
           return this.parseError = !0, failure;
         if (this.stateOverride === "hostname")
           return !1;
-        let host = parseHost(this.buffer, isNotSpecial(this.url));
-        if (host === failure)
+        let host4 = parseHost(this.buffer, isNotSpecial(this.url));
+        if (host4 === failure)
           return failure;
-        this.url.host = host, this.buffer = "", this.state = "port";
+        this.url.host = host4, this.buffer = "", this.state = "port";
       } else if (isNaN(c) || c === p("/") || c === p("?") || c === p("#") || isSpecial(this.url) && c === p("\\")) {
         if (--this.pointer, isSpecial(this.url) && this.buffer === "")
           return this.parseError = !0, failure;
         if (this.stateOverride && this.buffer === "" && (includesCredentials(this.url) || this.url.port !== null))
           return this.parseError = !0, !1;
-        let host = parseHost(this.buffer, isNotSpecial(this.url));
-        if (host === failure)
+        let host4 = parseHost(this.buffer, isNotSpecial(this.url));
+        if (host4 === failure)
           return failure;
-        if (this.url.host = host, this.buffer = "", this.state = "path start", this.stateOverride)
+        if (this.url.host = host4, this.buffer = "", this.state = "path start", this.stateOverride)
           return !1;
       } else
         c === p("[") ? this.arrFlag = !0 : c === p("]") && (this.arrFlag = !1), this.buffer += cStr;
@@ -15870,10 +15874,10 @@ var require_url_state_machine = __commonJS({
             return !1;
           this.state = "path start";
         } else {
-          let host = parseHost(this.buffer, isNotSpecial(this.url));
-          if (host === failure)
+          let host4 = parseHost(this.buffer, isNotSpecial(this.url));
+          if (host4 === failure)
             return failure;
-          if (host === "localhost" && (host = ""), this.url.host = host, this.stateOverride)
+          if (host4 === "localhost" && (host4 = ""), this.url.host = host4, this.stateOverride)
             return !1;
           this.buffer = "", this.state = "path start";
         }
@@ -15900,28 +15904,28 @@ var require_url_state_machine = __commonJS({
     URLStateMachine.prototype["parse fragment"] = function(c) {
       return isNaN(c) || (c === p("%") && (!infra.isASCIIHex(this.input[this.pointer + 1]) || !infra.isASCIIHex(this.input[this.pointer + 2])) && (this.parseError = !0), this.url.fragment += utf8PercentEncodeCodePoint(c, isFragmentPercentEncode)), !0;
     };
-    function serializeURL(url, excludeFragment) {
-      let output = `${url.scheme}:`;
-      return url.host !== null && (output += "//", (url.username !== "" || url.password !== "") && (output += url.username, url.password !== "" && (output += `:${url.password}`), output += "@"), output += serializeHost(url.host), url.port !== null && (output += `:${url.port}`)), url.host === null && !hasAnOpaquePath(url) && url.path.length > 1 && url.path[0] === "" && (output += "/."), output += serializePath(url), url.query !== null && (output += `?${url.query}`), !excludeFragment && url.fragment !== null && (output += `#${url.fragment}`), output;
+    function serializeURL(url4, excludeFragment) {
+      let output = `${url4.scheme}:`;
+      return url4.host !== null && (output += "//", (url4.username !== "" || url4.password !== "") && (output += url4.username, url4.password !== "" && (output += `:${url4.password}`), output += "@"), output += serializeHost(url4.host), url4.port !== null && (output += `:${url4.port}`)), url4.host === null && !hasAnOpaquePath(url4) && url4.path.length > 1 && url4.path[0] === "" && (output += "/."), output += serializePath(url4), url4.query !== null && (output += `?${url4.query}`), !excludeFragment && url4.fragment !== null && (output += `#${url4.fragment}`), output;
     }
     function serializeOrigin(tuple) {
       let result = `${tuple.scheme}://`;
       return result += serializeHost(tuple.host), tuple.port !== null && (result += `:${tuple.port}`), result;
     }
-    function serializePath(url) {
-      if (hasAnOpaquePath(url))
-        return url.path;
+    function serializePath(url4) {
+      if (hasAnOpaquePath(url4))
+        return url4.path;
       let output = "";
-      for (let segment of url.path)
+      for (let segment of url4.path)
         output += `/${segment}`;
       return output;
     }
     module.exports.serializeURL = serializeURL;
     module.exports.serializePath = serializePath;
-    module.exports.serializeURLOrigin = function(url) {
-      switch (url.scheme) {
+    module.exports.serializeURLOrigin = function(url4) {
+      switch (url4.scheme) {
         case "blob": {
-          let pathURL = module.exports.parseURL(serializePath(url));
+          let pathURL = module.exports.parseURL(serializePath(url4));
           return pathURL === null || pathURL.scheme !== "http" && pathURL.scheme !== "https" ? "null" : module.exports.serializeURLOrigin(pathURL);
         }
         case "ftp":
@@ -15930,9 +15934,9 @@ var require_url_state_machine = __commonJS({
         case "ws":
         case "wss":
           return serializeOrigin({
-            scheme: url.scheme,
-            host: url.host,
-            port: url.port
+            scheme: url4.scheme,
+            host: url4.host,
+            port: url4.port
           });
         case "file":
           return "null";
@@ -15945,11 +15949,11 @@ var require_url_state_machine = __commonJS({
       let usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride);
       return usm.failure ? null : usm.url;
     };
-    module.exports.setTheUsername = function(url, username) {
-      url.username = utf8PercentEncodeString(username, isUserinfoPercentEncode);
+    module.exports.setTheUsername = function(url4, username) {
+      url4.username = utf8PercentEncodeString(username, isUserinfoPercentEncode);
     };
-    module.exports.setThePassword = function(url, password) {
-      url.password = utf8PercentEncodeString(password, isUserinfoPercentEncode);
+    module.exports.setThePassword = function(url4, password) {
+      url4.password = utf8PercentEncodeString(password, isUserinfoPercentEncode);
     };
     module.exports.serializeHost = serializeHost;
     module.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort;
@@ -16486,18 +16490,18 @@ var require_URL_impl = __commonJS({
       // Unlike the spec, we duplicate some code between the constructor and canParse, because we want to give useful error
       // messages in the constructor that distinguish between the different causes of failure.
       constructor(globalObject, constructorArgs) {
-        let url = constructorArgs[0], base = constructorArgs[1], parsedBase = null;
+        let url4 = constructorArgs[0], base = constructorArgs[1], parsedBase = null;
         if (base !== void 0 && (parsedBase = usm.basicURLParse(base), parsedBase === null))
           throw new TypeError(`Invalid base URL: ${base}`);
-        let parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
+        let parsedURL = usm.basicURLParse(url4, { baseURL: parsedBase });
         if (parsedURL === null)
-          throw new TypeError(`Invalid URL: ${url}`);
+          throw new TypeError(`Invalid URL: ${url4}`);
         let query = parsedURL.query !== null ? parsedURL.query : "";
         this._url = parsedURL, this._query = URLSearchParams2.createImpl(globalObject, [query], { doNotStripQMark: !0 }), this._query._url = this;
       }
-      static canParse(url, base) {
+      static canParse(url4, base) {
         let parsedBase = null;
-        return !(base !== void 0 && (parsedBase = usm.basicURLParse(base), parsedBase === null) || usm.basicURLParse(url, { baseURL: parsedBase }) === null);
+        return !(base !== void 0 && (parsedBase = usm.basicURLParse(base), parsedBase === null) || usm.basicURLParse(url4, { baseURL: parsedBase }) === null);
       }
       get href() {
         return usm.serializeURL(this._url);
@@ -16532,8 +16536,8 @@ var require_URL_impl = __commonJS({
         usm.cannotHaveAUsernamePasswordPort(this._url) || usm.setThePassword(this._url, v);
       }
       get host() {
-        let url = this._url;
-        return url.host === null ? "" : url.port === null ? usm.serializeHost(url.host) : `${usm.serializeHost(url.host)}:${usm.serializeInteger(url.port)}`;
+        let url4 = this._url;
+        return url4.host === null ? "" : url4.port === null ? usm.serializeHost(url4.host) : `${usm.serializeHost(url4.host)}:${usm.serializeInteger(url4.port)}`;
       }
       set host(v) {
         usm.hasAnOpaquePath(this._url) || usm.basicURLParse(v, { url: this._url, stateOverride: "host" });
@@ -16560,13 +16564,13 @@ var require_URL_impl = __commonJS({
         return this._url.query === null || this._url.query === "" ? "" : `?${this._url.query}`;
       }
       set search(v) {
-        let url = this._url;
+        let url4 = this._url;
         if (v === "") {
-          url.query = null, this._query._list = [], this._potentiallyStripTrailingSpacesFromAnOpaquePath();
+          url4.query = null, this._query._list = [], this._potentiallyStripTrailingSpacesFromAnOpaquePath();
           return;
         }
         let input = v[0] === "?" ? v.substring(1) : v;
-        url.query = "", usm.basicURLParse(input, { url, stateOverride: "query" }), this._query._list = urlencoded.parseUrlencodedString(input);
+        url4.query = "", usm.basicURLParse(input, { url: url4, stateOverride: "query" }), this._query._list = urlencoded.parseUrlencodedString(input);
       }
       get searchParams() {
         return this._query;
@@ -16636,7 +16640,7 @@ var require_URL = __commonJS({
         return;
       let ctorRegistry = utils.initCtorRegistry(globalObject);
       class URL2 {
-        constructor(url) {
+        constructor(url4) {
           if (arguments.length < 1)
             throw new globalObject.TypeError(
               `Failed to construct 'URL': 1 argument required, but only ${arguments.length} present.`
@@ -16832,7 +16836,7 @@ var require_URL = __commonJS({
             globals: globalObject
           }), esValue[implSymbol].hash = V;
         }
-        static canParse(url) {
+        static canParse(url4) {
           if (arguments.length < 1)
             throw new globalObject.TypeError(
               `Failed to execute 'canParse' on 'URL': 1 argument required, but only ${arguments.length} present.`
@@ -17594,11 +17598,11 @@ var require_lib2 = __commonJS({
       let orig = new URL$1(original).protocol, dest = new URL$1(destination).protocol;
       return orig === dest;
     };
-    function fetch4(url, opts) {
+    function fetch4(url4, opts) {
       if (!fetch4.Promise)
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       return Body2.Promise = fetch4.Promise, new fetch4.Promise(function(resolve, reject) {
-        let request = new Request2(url, opts), options = getNodeRequestOptions2(request), send = (options.protocol === "https:" ? https3 : http3).request, signal = request.signal, response = null, abort = function() {
+        let request = new Request2(url4, opts), options = getNodeRequestOptions2(request), send = (options.protocol === "https:" ? https3 : http3).request, signal = request.signal, response = null, abort = function() {
           let error = new AbortError3("The user aborted a request.");
           reject(error), request.body && request.body instanceof Stream3.Readable && destroyStream(request.body, error), !(!response || !response.body) && response.body.emit("error", error);
         };
@@ -17761,8 +17765,8 @@ var require_lib2 = __commonJS({
 var require_node_ponyfill = __commonJS({
   "../../node_modules/.pnpm/cross-fetch@3.1.8/node_modules/cross-fetch/dist/node-ponyfill.js"(exports, module) {
     init_cjs_shims();
-    var nodeFetch = require_lib2(), realFetch = nodeFetch.default || nodeFetch, fetch4 = function(url, options) {
-      return /^\/\//.test(url) && (url = "https:" + url), realFetch.call(this, url, options);
+    var nodeFetch = require_lib2(), realFetch = nodeFetch.default || nodeFetch, fetch4 = function(url4, options) {
+      return /^\/\//.test(url4) && (url4 = "https:" + url4), realFetch.call(this, url4, options);
     };
     fetch4.ponyfill = !0;
     module.exports = exports = fetch4;
@@ -26797,7 +26801,7 @@ var require_populate = __commonJS({
 var require_form_data = __commonJS({
   "../../node_modules/.pnpm/form-data@4.0.1/node_modules/form-data/lib/form_data.js"(exports, module) {
     init_cjs_shims();
-    var CombinedStream = require_combined_stream(), util2 = __require("util"), path = __require("path"), http3 = __require("http"), https3 = __require("https"), parseUrl = __require("url").parse, fs2 = __require("fs"), Stream3 = __require("stream").Stream, mime = require_mime_types(), asynckit = require_asynckit(), populate = require_populate();
+    var CombinedStream = require_combined_stream(), util2 = __require("util"), path = __require("path"), http3 = __require("http"), https3 = __require("https"), parseUrl = __require("url").parse, fs6 = __require("fs"), Stream3 = __require("stream").Stream, mime = require_mime_types(), asynckit = require_asynckit(), populate = require_populate();
     module.exports = FormData3;
     util2.inherits(FormData3, CombinedStream);
     function FormData3(options) {
@@ -26825,7 +26829,7 @@ var require_form_data = __commonJS({
       options.knownLength != null ? valueLength += +options.knownLength : Buffer.isBuffer(value) ? valueLength = value.length : typeof value == "string" && (valueLength = Buffer.byteLength(value)), this._valueLength += valueLength, this._overheadLength += Buffer.byteLength(header) + FormData3.LINE_BREAK.length, !(!value || !value.path && !(value.readable && value.hasOwnProperty("httpVersion")) && !(value instanceof Stream3)) && (options.knownLength || this._valuesToMeasure.push(value));
     };
     FormData3.prototype._lengthRetriever = function(value, callback) {
-      value.hasOwnProperty("fd") ? value.end != null && value.end != 1 / 0 && value.start != null ? callback(null, value.end + 1 - (value.start ? value.start : 0)) : fs2.stat(value.path, function(err2, stat) {
+      value.hasOwnProperty("fd") ? value.end != null && value.end != 1 / 0 && value.start != null ? callback(null, value.end + 1 - (value.start ? value.start : 0)) : fs6.stat(value.path, function(err2, stat) {
         var fileSize;
         if (err2) {
           callback(err2);
@@ -26947,7 +26951,7 @@ var require_form_data = __commonJS({
 
 // ../cli-kit/dist/public/common/version.js
 init_cjs_shims();
-var CLI_KIT_VERSION = "3.76.2";
+var CLI_KIT_VERSION = "3.77.1";
 
 // ../cli-kit/dist/private/node/analytics.js
 init_cjs_shims();
@@ -30048,11 +30052,42 @@ async function shouldRejectUnauthorizedRequests() {
 
 // ../cli-kit/dist/private/node/api/urls.js
 init_cjs_shims();
-function sanitizeURL(url) {
-  let parsedUrl = new URL(url);
+function sanitizeURL(url4) {
+  let parsedUrl = new URL(url4);
   return parsedUrl.searchParams.has("subject_token") && parsedUrl.searchParams.set("subject_token", "****"), parsedUrl.searchParams.has("token") && parsedUrl.searchParams.set("token", "****"), parsedUrl.toString();
 }
 
+// ../cli-kit/dist/private/node/sleep-with-backoff.js
+init_cjs_shims();
+var DEFAULT_RETRY_DELAY_MS = 300, DEFAULT_MAX_TIME_MS = 1e4;
+function calculateBackoffDelay(attempt, firstDelayMs, maximumDelayMs = DEFAULT_MAX_TIME_MS / 3) {
+  if (attempt === 0)
+    return 0;
+  let delayMultiplier = 2 ** (attempt - 1);
+  return Math.min(firstDelayMs * delayMultiplier, maximumDelayMs);
+}
+async function* backoffGenerator(shouldContinue, firstDelayMs) {
+  let attempt = 0;
+  for (; ; ) {
+    let nextDelayMs = calculateBackoffDelay(attempt, firstDelayMs);
+    if (!shouldContinue(nextDelayMs))
+      return { remainingMs: 0, iterations: attempt };
+    await sleep(nextDelayMs / 1e3), yield nextDelayMs, attempt++;
+  }
+}
+async function* sleepWithBackoffUntil(maxTimeMs = DEFAULT_MAX_TIME_MS, firstDelayMs = DEFAULT_RETRY_DELAY_MS) {
+  if (maxTimeMs <= 0)
+    return { remainingMs: 0, iterations: 0 };
+  let startTime = Date.now(), generator = backoffGenerator((nextDelay) => Date.now() - startTime + nextDelay <= maxTimeMs, firstDelayMs), attempt = 0;
+  for await (let delayMs of generator)
+    yield delayMs, attempt++;
+  let elapsedTime = Date.now() - startTime;
+  return {
+    remainingMs: maxTimeMs - elapsedTime,
+    iterations: attempt
+  };
+}
+
 // ../../node_modules/.pnpm/graphql-request@6.1.0_graphql@16.10.0/node_modules/graphql-request/build/esm/index.js
 init_cjs_shims();
 
@@ -30274,7 +30309,7 @@ var resolveHeaders = (headers) => {
   }), acc), []);
   return `query=${encodeURIComponent(params_.jsonSerializer.stringify(payload))}`;
 }, createHttpMethodFetcher = (method) => async (params) => {
-  let { url, query, variables, operationName, fetch: fetch4, fetchOptions, middleware } = params, headers = { ...params.headers }, queryParams = "", body;
+  let { url: url4, query, variables, operationName, fetch: fetch4, fetchOptions, middleware } = params, headers = { ...params.headers }, queryParams = "", body;
   method === "POST" ? (body = createRequestBody(query, variables, operationName, fetchOptions.jsonSerializer), typeof body == "string" && (headers["Content-Type"] = "application/json")) : queryParams = buildRequestConfig({
     query,
     variables,
@@ -30286,20 +30321,20 @@ var resolveHeaders = (headers) => {
     headers,
     body,
     ...fetchOptions
-  }, urlResolved = url, initResolved = init;
+  }, urlResolved = url4, initResolved = init;
   if (middleware) {
-    let result = await Promise.resolve(middleware({ ...init, url, operationName, variables })), { url: urlNew, ...initNew } = result;
+    let result = await Promise.resolve(middleware({ ...init, url: url4, operationName, variables })), { url: urlNew, ...initNew } = result;
     urlResolved = urlNew, initResolved = initNew;
   }
   return queryParams && (urlResolved = `${urlResolved}?${queryParams}`), await fetch4(urlResolved, initResolved);
 }, GraphQLClient = class {
-  constructor(url, requestConfig = {}) {
-    this.url = url, this.requestConfig = requestConfig, this.rawRequest = async (...args) => {
-      let [queryOrOptions, variables, requestHeaders] = args, rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url: url2 } = this;
+  constructor(url4, requestConfig = {}) {
+    this.url = url4, this.requestConfig = requestConfig, this.rawRequest = async (...args) => {
+      let [queryOrOptions, variables, requestHeaders] = args, rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url: url5 } = this;
       rawRequestOptions.signal !== void 0 && (fetchOptions.signal = rawRequestOptions.signal);
       let { operationName } = resolveRequestDocument(rawRequestOptions.query);
       return makeRequest({
-        url: url2,
+        url: url5,
         query: rawRequestOptions.query,
         variables: rawRequestOptions.variables,
         headers: {
@@ -30317,11 +30352,11 @@ var resolveHeaders = (headers) => {
     };
   }
   async request(documentOrOptions, ...variablesAndRequestHeaders) {
-    let [variables, requestHeaders] = variablesAndRequestHeaders, requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url } = this;
+    let [variables, requestHeaders] = variablesAndRequestHeaders, requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url: url4 } = this;
     requestOptions.signal !== void 0 && (fetchOptions.signal = requestOptions.signal);
     let { query, operationName } = resolveRequestDocument(requestOptions.document);
     return makeRequest({
-      url,
+      url: url4,
       query,
       variables: requestOptions.variables,
       headers: {
@@ -30413,7 +30448,7 @@ var createRequestBody = (query, variables, operationName, jsonSerializer) => {
 
 // ../cli-kit/dist/private/node/api.js
 import { performance } from "perf_hooks";
-var allAPIs = ["admin", "storefront-renderer", "partners", "business-platform", "app-management"], DEFAULT_RETRY_DELAY_MS = 1e3, DEFAULT_RETRY_LIMIT = 10, interestingResponseHeaders = /* @__PURE__ */ new Set([
+var allAPIs = ["admin", "storefront-renderer", "partners", "business-platform", "app-management"], DEFAULT_RETRY_DELAY_MS2 = 1e3, DEFAULT_RETRY_LIMIT = 10, interestingResponseHeaders = /* @__PURE__ */ new Set([
   "cache-control",
   "content-type",
   "etag",
@@ -30424,10 +30459,38 @@ var allAPIs = ["admin", "storefront-renderer", "partners", "business-platform",
 function responseHeaderIsInteresting(header) {
   return interestingResponseHeaders.has(header);
 }
-async function makeVerboseRequest({ request, url }) {
-  let t0 = performance.now(), duration = 0, responseHeaders = {}, sanitizedUrl = sanitizeURL(url), response = {};
+function isARetryableNetworkError(error) {
+  return error instanceof Error ? [
+    "socket hang up",
+    "ECONNRESET",
+    "ECONNABORTED",
+    "ENOTFOUND",
+    "ENETUNREACH",
+    "network socket disonnected",
+    "ETIMEDOUT",
+    "ECONNREFUSED",
+    "EAI_FAIL",
+    "The operation was aborted."
+  ].some((issueMessage) => error.message.includes(issueMessage)) : !1;
+}
+async function runRequestWithNetworkLevelRetry(requestOptions) {
+  if (!requestOptions.useNetworkLevelRetry)
+    return requestOptions.request();
+  let lastSeenError;
+  for await (let _delayMs of sleepWithBackoffUntil(requestOptions.maxRetryTimeMs))
+    try {
+      return await requestOptions.request();
+    } catch (err2) {
+      if (lastSeenError = err2, !isARetryableNetworkError(err2))
+        throw err2;
+      outputDebug(`Retrying request to ${requestOptions.url} due to network error ${err2}`);
+    }
+  throw lastSeenError;
+}
+async function makeVerboseRequest(requestOptions) {
+  let t0 = performance.now(), duration = 0, responseHeaders = {}, sanitizedUrl = sanitizeURL(requestOptions.url), response = {};
   try {
-    response = await request(), response.headers.forEach((value, key) => {
+    response = await runRequestWithNetworkLevelRetry(requestOptions), response.headers.forEach((value, key) => {
       responseHeaderIsInteresting(key) && (responseHeaders[key] = value);
     });
   } catch (err2) {
@@ -30493,8 +30556,8 @@ async function makeVerboseRequest({ request, url }) {
 function errorsIncludeStatus429(error) {
   return error.response.status === 429 ? !0 : typeof error.response.errors == "string" ? !1 : error.response.errors?.some((error2) => error2.extensions?.code === "429") ?? !1;
 }
-async function simpleRequestWithDebugLog({ request, url }, errorHandler) {
-  let result = await makeVerboseRequest({ request, url });
+async function simpleRequestWithDebugLog(requestOptions, errorHandler) {
+  let result = await makeVerboseRequest(requestOptions);
   switch (outputDebug(`Request to ${result.sanitizedUrl} completed in ${result.duration} ms
 With response headers:
 ${result.sanitizedHeaders}
@@ -30511,10 +30574,10 @@ ${result.sanitizedHeaders}
       throw errorHandler ? errorHandler(result.clientError, result.requestId) : result.clientError;
   }
 }
-async function retryAwareRequest({ request, url }, errorHandler, unauthorizedHandler, retryOptions = {
+async function retryAwareRequest(requestOptions, errorHandler, unauthorizedHandler, retryOptions = {
   scheduleDelay: setTimeout
 }) {
-  let retriesUsed = 0, limitRetriesTo = retryOptions.limitRetriesTo ?? DEFAULT_RETRY_LIMIT, result = await makeVerboseRequest({ request, url });
+  let retriesUsed = 0, limitRetriesTo = retryOptions.limitRetriesTo ?? DEFAULT_RETRY_LIMIT, result = await makeVerboseRequest(requestOptions);
   for (outputDebug(`Request to ${result.sanitizedUrl} completed in ${result.duration} ms
 With response headers:
 ${result.sanitizedHeaders}
@@ -30533,10 +30596,10 @@ ${result.sanitizedHeaders}
     if (limitRetriesTo <= retriesUsed)
       throw outputDebug(`${limitRetriesTo} retries exhausted for request to ${result.sanitizedUrl}`), errorHandler ? errorHandler(result.clientError, result.requestId) : result.clientError;
     retriesUsed += 1;
-    let retryDelayMs = result.delayMs ?? retryOptions.defaultDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    let retryDelayMs = result.delayMs ?? retryOptions.defaultDelayMs ?? DEFAULT_RETRY_DELAY_MS2;
     outputDebug(`Scheduling retry request #${retriesUsed} to ${result.sanitizedUrl} in ${retryDelayMs} ms`), result = await new Promise((resolve) => {
       retryOptions.scheduleDelay(() => {
-        resolve(makeVerboseRequest({ request, url }));
+        resolve(makeVerboseRequest(requestOptions));
       }, retryDelayMs);
     });
   }
@@ -30596,137 +30659,229 @@ init_cjs_shims();
 // ../cli-kit/dist/public/node/context/fqdn.js
 init_cjs_shims();
 
-// ../cli-kit/dist/public/node/vendor/dev_server/DevServer.js
+// ../cli-kit/dist/public/node/vendor/dev_server/index.js
+init_cjs_shims();
+
+// ../cli-kit/dist/public/node/vendor/dev_server/env.js
+init_cjs_shims();
+var isDevServerEnvironment = process.env.USING_DEV === "1" || process.env.SPIN === "1";
+function assertCompatibleEnvironment() {
+  if (!isDevServerEnvironment)
+    throw new Error("DevServer is not supported in this environment");
+}
+
+// ../cli-kit/dist/public/node/vendor/dev_server/dev-server.js
+init_cjs_shims();
+import fs5 from "node:fs";
+
+// ../cli-kit/dist/public/node/vendor/dev_server/dev-server-2024.js
 init_cjs_shims();
 var ni = __toESM(require_network_interfaces(), 1);
-import fs from "fs";
-import * as os from "os";
-import { execSync } from "child_process";
-var DevServerUtils = class _DevServerUtils {
-  static assertConnectable(name, addr, port) {
-    try {
-      execSync(`nc -z -v -w 1 ${addr} ${port}`, {
-        timeout: _DevServerUtils.CONNECT_TIMEOUT,
-        stdio: "ignore"
-      });
-    } catch {
-      throw new Error(`NET FAILED DevServer for '${name}' is not running on ${port} / ${addr}: \`dev up ${name}\` to start it.`);
-    }
+import fs2 from "node:fs";
+
+// ../cli-kit/dist/public/node/vendor/dev_server/network/index.js
+init_cjs_shims();
+import { spawnSync } from "node:child_process";
+
+// ../cli-kit/dist/public/node/vendor/dev_server/network/host.js
+init_cjs_shims();
+import fs from "node:fs";
+var HOSTS_FILE = "/etc/hosts", hostToIpCache = {}, lastModifiedTime = 0;
+function loadHostsFile() {
+  try {
+    let modifiedTime = fs.statSync(HOSTS_FILE).mtimeMs;
+    if (modifiedTime === lastModifiedTime)
+      return;
+    let lines = fs.readFileSync(HOSTS_FILE, "utf8").split(/\r?\n/);
+    hostToIpCache = {};
+    for (let line of lines) {
+      if (line.trim().startsWith("#") || line.trim() === "")
+        continue;
+      let matches = /^\s*(?<ipAddress>[^\s#]+)\s+(?<matchedHostName>[^\s#]+)\s*(#.*)?$/.exec(line);
+      if (matches && matches.groups) {
+        let { ipAddress, matchedHostName } = matches.groups;
+        matchedHostName && ipAddress && (hostToIpCache[matchedHostName] = ipAddress);
+      }
+    }
+    lastModifiedTime = modifiedTime;
+  } catch (error) {
+    console.log("Error reading hosts file:", error);
   }
-  static inferenceModeAndProjectIsEdition2016(name) {
-    try {
-      fs.accessSync(_DevServerUtils.INFERENCE_MODE_SENTINEL);
-      try {
-        return fs.accessSync(`/opt/nginx/etc/manifest/${name}/current/edition-2024`), !1;
-      } catch {
-        return !0;
-      }
-    } catch {
-      return !1;
-    }
+}
+function getIpFromHosts(hostname) {
+  loadHostsFile();
+  let ipAddress = hostToIpCache[hostname];
+  if (ipAddress)
+    return ipAddress;
+  throw new Error(`No IP found for hostname: ${hostname}`);
+}
+
+// ../cli-kit/dist/public/node/vendor/dev_server/network/index.js
+var DEFAULT_CONNECT_TIMEOUT = 100, checkPort;
+function assertConnectable(options) {
+  checkPort || (checkPort = getCheckPortHelper());
+  let { port, addr, timeout = DEFAULT_CONNECT_TIMEOUT } = options;
+  try {
+    if (!checkPort(addr === "localhost" ? "127.0.0.1" : addr, port, timeout))
+      throw new Error(`DevServer for '${options.projectName}' is not running on ${port} / ${addr}: \`dev up ${options.projectName}\` to start it.`);
+  } catch (err2) {
+    throw new Error(`DevServer check for '${options.projectName}' on ${port} / ${addr} failed (${err2})`);
   }
-  static getIpFromHosts(hostname) {
-    try {
-      let lines = fs.readFileSync(_DevServerUtils.HOSTS_FILE, "utf8").split(/\r?\n/);
-      for (let line of lines) {
-        let matches = /^\s*?([^#]+?)\s+([^#]+?)$/.exec(line);
-        if (matches && matches.length === 3 && matches[2] === hostname)
-          return matches[1];
-      }
-    } catch (error) {
-      console.error("Error reading hosts file:", error);
-    }
-    throw new Error(`No IP found for hostname: ${hostname}`);
+}
+function getCheckPortHelper() {
+  return fallbackCheckPort;
+}
+function fallbackCheckPort(address, port, timeout) {
+  return spawnSync("nc", ["-z", "-w", "1", address, port.toString()], {
+    timeout,
+    stdio: "ignore"
+  }).status === 0;
+}
+
+// ../cli-kit/dist/public/node/vendor/dev_server/dev-server-2024.js
+var NON_SHOP_PREFIXES = ["app", "dev", "shopify"], BACKEND_PORT = 8080;
+function createServer(projectName) {
+  return {
+    host: (options = {}) => host(projectName, options),
+    url: (options = {}) => url(projectName, options)
+  };
+}
+function host(projectName, options = {}) {
+  assertCompatibleEnvironment(), (assertRunningOverride || assertRunning2024)(projectName);
+  let prefix = (options.nonstandardHostPrefix || projectName).replace(/_/g, "-");
+  if (projectName === "shopify") {
+    if (prefix.endsWith("-dev-api"))
+      return `${prefix.replace("-dev-api", "")}.dev-api.shop.dev`;
+    if (!NON_SHOP_PREFIXES.includes(prefix))
+      return `${prefix}.my.shop.dev`;
+  }
+  return `${prefix}.shop.dev`;
+}
+function url(projectName, options = {}) {
+  return `https://${host(projectName, options)}`;
+}
+function assertRunning2024(projectName) {
+  assertConnectable({
+    projectName,
+    addr: getBackendIp(projectName),
+    port: BACKEND_PORT
+  });
+}
+function getBackendIp(projectName) {
+  try {
+    let backendIp = resolveBackendHost(projectName);
+    return ni.fromIp(backendIp, { internal: !0, ipVersion: 4 }), backendIp;
+  } catch {
+    throw new Error(`DevServer for '${projectName}' is not running: \`dev up ${projectName}\` to start it.`);
   }
-  static getAddrPort2024(name) {
-    try {
-      let backendIp = _DevServerUtils.resolveBackendHost(name), interfaceName = ni.fromIp(backendIp, {
-        internal: !0,
-        ipVersion: 4
-      });
-      return [backendIp, _DevServerUtils.BACKEND_PORT];
-    } catch {
-      throw new Error(`DevServer for '${name}' is not running: \`dev up ${name}\` to start it.`);
-    }
+}
+function resolveBackendHost(name) {
+  let host4;
+  try {
+    host4 = fs2.readlinkSync(`/opt/nginx/etc/manifest/${name}/current`);
+  } catch {
+    host4 = `${name}.root.shopify.dev.internal`;
   }
-  static getAddrPort2016(name) {
-    try {
-      let portContent = fs.readFileSync(`${os.homedir()}/.local/run/services/${name}/server/port`, "utf-8");
-      return ["localhost", parseInt(portContent, 10)];
-    } catch {
-      throw new Error(`DevServer for '${name}' is not running: \`dev up ${name}\` to start it.`);
-    }
+  try {
+    return getIpFromHosts(host4);
+  } catch {
+    return host4;
   }
-  static resolveBackendHost(name) {
-    let host;
-    try {
-      host = fs.readlinkSync(`/opt/nginx/etc/manifest/${name}/current`);
-    } catch {
-      host = `${name}.root.shopify.dev.internal`;
-    }
-    try {
-      return _DevServerUtils.getIpFromHosts(host);
-    } catch {
-      return host;
-    }
+}
+var assertRunningOverride;
+
+// ../cli-kit/dist/public/node/vendor/dev_server/dev-server-2016.js
+init_cjs_shims();
+import fs3 from "fs";
+import * as os from "node:os";
+function createServer2(projectName) {
+  return {
+    host: (options = {}) => host2(projectName, options),
+    url: (options = {}) => url2(projectName, options)
+  };
+}
+function host2(projectName, options = {}) {
+  return assertCompatibleEnvironment(), (assertRunningOverride2 || assertRunning2016)(projectName), `${options.nonstandardHostPrefix || projectName}.myshopify.io`;
+}
+function url2(projectName, options = {}) {
+  return `https://${host2(projectName, options)}`;
+}
+function assertRunning2016(projectName) {
+  let [addr, port] = getAddrPort(projectName);
+  assertConnectable({ projectName, addr, port });
+}
+function getAddrPort(name) {
+  try {
+    let portContent = fs3.readFileSync(`${os.homedir()}/.local/run/services/${name}/server/port`, "utf-8");
+    return ["localhost", parseInt(portContent, 10)];
+  } catch {
+    throw new Error(`DevServer for '${name}' is not running: \`dev up ${name}\` to start it.`);
   }
-};
-DevServerUtils.INFERENCE_MODE_SENTINEL = "/opt/dev/misc/dev-server-inference-mode";
-DevServerUtils.BACKEND_PORT = 8080;
-DevServerUtils.CONNECT_TIMEOUT = 100;
-DevServerUtils.HOSTS_FILE = "/etc/hosts";
+}
+var assertRunningOverride2;
+
+// ../cli-kit/dist/public/node/vendor/dev_server/dev-server-spin.js
+init_cjs_shims();
+import fs4 from "node:fs";
+function createServer3(projectName) {
+  return {
+    host: (options = {}) => host3(projectName, options),
+    url: (options = {}) => url3(projectName, options)
+  };
+}
+function host3(projectName, { nonstandardHostPrefix } = {}) {
+  assertCompatibleEnvironment();
+  let services = fs4.readdirSync("/run/ports2").filter((file) => file.endsWith(`--${projectName}`));
+  if (services.length === 0)
+    throw new Error(`DevServer for '${projectName}' not present in this spin environment`);
+  if (projectName === "shopify")
+    return `${nonstandardHostPrefix?.replace(/[-_]dev[-_]api$/, "")}.${projectName}.${process.env.SPIN_FQDN}`;
+  let match = new RegExp(`^(.+)${projectName}$`).exec(services[0]), organization = match ? match[1] : "";
+  return `${organization === "shopify--" ? "" : `${organization}`}${projectName}.${process.env.SPIN_FQDN}`;
+}
+function url3(projectName, options = {}) {
+  return `https://${host3(projectName, options)}`;
+}
+
+// ../cli-kit/dist/public/node/vendor/dev_server/dev-server.js
 var DevServer = class {
-  constructor(name) {
-    if (!process.env.SPIN && !process.env.USING_DEV)
-      throw new Error("DevServer is not supported in this environment");
-    if (name === "shopify")
-      throw new Error("Use DevServer.core for the 'shopify' project");
-    this.name = name;
-  }
-  url({ nonstandardHostPrefix } = {}) {
-    return `https://${this.host({ nonstandardHostPrefix })}`;
-  }
-  host({ nonstandardHostPrefix } = {}) {
-    let prefix = nonstandardHostPrefix || this.name;
-    if (process.env.SPIN === "1") {
-      let services = fs.readdirSync("/run/ports2").filter((file) => file.endsWith(`--${this.name}`));
-      if (services.length === 0)
-        throw new Error(`DevServer for '${this.name}' not present in this spin environment`);
-      let match = new RegExp(`^(.+)${this.name}$`).exec(services[0]), organization = match ? match[1] : "";
-      return `${organization !== "shopify--" ? `${organization}` : ""}${this.name}.${process.env.SPIN_FQDN}`;
-    } else return DevServerUtils.inferenceModeAndProjectIsEdition2016(this.name) ? (this.assertRunningLocally2016(), `${prefix}.myshopify.io`) : (this.assertRunningLocally2024(), `${prefix}.shop.dev`);
-  }
-  assertRunningLocally2024() {
-    let [addr, port] = DevServerUtils.getAddrPort2024(this.name);
-    DevServerUtils.assertConnectable(this.name, addr, port);
-  }
-  assertRunningLocally2016() {
-    let [addr, port] = DevServerUtils.getAddrPort2016(this.name);
-    DevServerUtils.assertConnectable(this.name, addr, port);
+  constructor(projectName) {
+    if (this.projectName = projectName, projectName === "shopify")
+      throw new Error("Use `import {DevServerCore}` for the 'shopify' project");
+    this.serverImpl = inferProjectServer(projectName);
+  }
+  host(options) {
+    return this.serverImpl.host(options);
+  }
+  url(options) {
+    return this.serverImpl.url(options);
   }
 }, DevServerCore = class {
   constructor() {
-    this.name = "shopify";
-  }
-  url(prefix) {
-    return `https://${this.host(prefix)}`;
+    this.serverImpl = inferProjectServer("shopify");
   }
   host(prefix) {
-    if (process.env.SPIN === "1") {
-      if (!fs.readdirSync("/run/ports2").find((file) => file.endsWith(`--${this.name}`)))
-        throw new Error(`DevServer for '${this.name}' not present in this spin environment`);
-      return `${prefix}.${this.name}.${process.env.SPIN_FQDN}`;
-    } else return DevServerUtils.inferenceModeAndProjectIsEdition2016("shopify") ? (this.assertRunningLocally2016(), `${prefix}.myshopify.io`) : (this.assertRunningLocally2024(), `${prefix}.my.shop.dev`);
+    return this.serverImpl.host({ nonstandardHostPrefix: prefix });
   }
-  assertRunningLocally2024() {
-    let [addr, port] = DevServerUtils.getAddrPort2024("shopify");
-    DevServerUtils.assertConnectable("shopify", addr, port);
+  url(prefix) {
+    return this.serverImpl.url({ nonstandardHostPrefix: prefix });
   }
-  assertRunningLocally2016() {
-    let [addr, port] = DevServerUtils.getAddrPort2016("shopify");
-    DevServerUtils.assertConnectable("shopify", addr, port);
+}, INFERENCE_MODE_SENTINEL = "/opt/dev/misc/dev-server-inference-mode";
+function inferProjectServer(projectName) {
+  return process.env.SPIN === "1" ? createServer3(projectName) : inferenceModeAndProjectIsEdition2016(projectName) ? createServer2(projectName) : createServer(projectName);
+}
+function inferenceModeAndProjectIsEdition2016(projectName) {
+  try {
+    fs5.accessSync(INFERENCE_MODE_SENTINEL);
+    try {
+      return fs5.accessSync(`/opt/nginx/etc/manifest/${projectName}/current/edition-2024`), !1;
+    } catch {
+      return !0;
+    }
+  } catch {
+    return !1;
   }
-};
+}
 
 // ../cli-kit/dist/public/node/context/fqdn.js
 var CouldntObtainPartnersSpinFQDNError = new AbortError("Couldn't obtain the Spin FQDN for Partners when the CLI is not running from a Spin environment."), CouldntObtainIdentitySpinFQDNError = new AbortError("Couldn't obtain the Spin FQDN for Identity when the CLI is not running from a Spin environment."), CouldntObtainShopifySpinFQDNError = new AbortError("Couldn't obtain the Spin FQDN for Shopify when the CLI is not running from a Spin environment."), NotProvidedStoreFQDNError = new AbortError("Couldn't obtain the Shopify FQDN because the store FQDN was not provided.");
@@ -31234,12 +31389,12 @@ var INTERNALS2 = Symbol("Response internals"), Response = class _Response extend
    * @param {number} status An optional status code for the response (e.g., 302.)
    * @returns {Response}    A Response object.
    */
-  static redirect(url, status = 302) {
+  static redirect(url4, status = 302) {
     if (!isRedirect(status))
       throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
     return new _Response(null, {
       headers: {
-        location: new URL(url).toString()
+        location: new URL(url4).toString()
       },
       status
     });
@@ -31290,8 +31445,8 @@ var getSearch = (parsedURL) => {
 // ../../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/referrer.js
 init_cjs_shims();
 import { isIP } from "node:net";
-function stripURLForUseAsAReferrer(url, originOnly = !1) {
-  return url == null || (url = new URL(url), /^(about|blob|data):$/.test(url.protocol)) ? "no-referrer" : (url.username = "", url.password = "", url.hash = "", originOnly && (url.pathname = "", url.search = ""), url);
+function stripURLForUseAsAReferrer(url4, originOnly = !1) {
+  return url4 == null || (url4 = new URL(url4), /^(about|blob|data):$/.test(url4.protocol)) ? "no-referrer" : (url4.username = "", url4.password = "", url4.hash = "", originOnly && (url4.pathname = "", url4.search = ""), url4);
 }
 var ReferrerPolicy = /* @__PURE__ */ new Set([
   "",
@@ -31309,14 +31464,14 @@ function validateReferrerPolicy(referrerPolicy) {
     throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
   return referrerPolicy;
 }
-function isOriginPotentiallyTrustworthy(url) {
-  if (/^(http|ws)s:$/.test(url.protocol))
+function isOriginPotentiallyTrustworthy(url4) {
+  if (/^(http|ws)s:$/.test(url4.protocol))
     return !0;
-  let hostIp = url.host.replace(/(^\[)|(]$)/g, ""), hostIPVersion = isIP(hostIp);
-  return hostIPVersion === 4 && /^127\./.test(hostIp) || hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp) ? !0 : url.host === "localhost" || url.host.endsWith(".localhost") ? !1 : url.protocol === "file:";
+  let hostIp = url4.host.replace(/(^\[)|(]$)/g, ""), hostIPVersion = isIP(hostIp);
+  return hostIPVersion === 4 && /^127\./.test(hostIp) || hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp) ? !0 : url4.host === "localhost" || url4.host.endsWith(".localhost") ? !1 : url4.protocol === "file:";
 }
-function isUrlPotentiallyTrustworthy(url) {
-  return /^about:(blank|srcdoc)$/.test(url) || url.protocol === "data:" || /^(blob|filesystem):$/.test(url.protocol) ? !0 : isOriginPotentiallyTrustworthy(url);
+function isUrlPotentiallyTrustworthy(url4) {
+  return /^about:(blank|srcdoc)$/.test(url4) || url4.protocol === "data:" || /^(blob|filesystem):$/.test(url4.protocol) ? !0 : isOriginPotentiallyTrustworthy(url4);
 }
 function determineRequestsReferrer(request, { referrerURLCallback, referrerOriginCallback } = {}) {
   if (request.referrer === "no-referrer" || request.referrerPolicy === "")
@@ -31491,11 +31646,11 @@ var AbortError2 = class extends FetchBaseError {
 
 // ../../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/index.js
 var supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
-async function fetch(url, options_) {
+async function fetch(url4, options_) {
   return new Promise((resolve, reject) => {
-    let request = new Request(url, options_), { parsedURL, options } = getNodeRequestOptions(request);
+    let request = new Request(url4, options_), { parsedURL, options } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol))
-      throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
+      throw new TypeError(`node-fetch cannot load ${url4}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
     if (parsedURL.protocol === "data:") {
       let data = dist_default(request.url), response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
       resolve(response2);
@@ -31666,25 +31821,76 @@ function fixResponseChunkedTransferBadEnding(request, errorCallback) {
 function formData() {
   return new import_form_data.default();
 }
-async function fetch2(url, init) {
-  return runWithTimer("cmd_all_timing_network_ms")(() => simpleRequestWithDebugLog({ url: url.toString(), request: () => fetch(url, init) }));
-}
-async function shopifyFetch(url, init) {
-  let sanitizedUrl = sanitizeURL(url.toString()), options = {
-    ...init ?? {},
-    headers: {
-      ...await buildHeaders(),
-      ...init?.headers ?? {}
-    }
+function requestMode(preset = "default", env = process.env) {
+  let networkLevelRetryIsSupported = !skipNetworkLevelRetry(env);
+  switch (preset) {
+    case "default":
+      return {
+        useNetworkLevelRetry: networkLevelRetryIsSupported,
+        maxRetryTimeMs: DEFAULT_MAX_TIME_MS,
+        useAbortSignal: !0,
+        timeoutMs: maxRequestTimeForNetworkCallsMs(env)
+      };
+    case "non-blocking":
+      return {
+        useNetworkLevelRetry: !1,
+        useAbortSignal: !0,
+        timeoutMs: maxRequestTimeForNetworkCallsMs(env)
+      };
+    case "slow-request":
+      return {
+        useNetworkLevelRetry: !1,
+        useAbortSignal: !1
+      };
+  }
+  return {
+    ...preset,
+    useNetworkLevelRetry: networkLevelRetryIsSupported && preset.useNetworkLevelRetry
   };
-  return outputDebug(outputContent`Sending ${options.method ?? "GET"} request to URL ${sanitizedUrl}
+}
+function abortSignalFromRequestBehaviour(behaviour) {
+  let signal;
+  return behaviour.useAbortSignal === !0 ? signal = AbortSignal.timeout(behaviour.timeoutMs) : behaviour.useAbortSignal && typeof behaviour.useAbortSignal == "function" ? signal = behaviour.useAbortSignal() : behaviour.useAbortSignal && (signal = behaviour.useAbortSignal), signal;
+}
+async function innerFetch({ url: url4, behaviour, init, logRequest, useHttpsAgent }) {
+  logRequest && outputDebug(outputContent`Sending ${init?.method ?? "GET"} request to URL ${sanitizeURL(url4.toString())}
 With request headers:
-${sanitizedHeadersOutput(options.headers ?? {})}
-`), runWithTimer("cmd_all_timing_network_ms")(async () => simpleRequestWithDebugLog({
-    url: url.toString(),
-    request: async () => fetch(url, { ...init, agent: await httpsAgent() })
+${sanitizedHeadersOutput(init?.headers ?? {})}
+`);
+  let agent;
+  useHttpsAgent && (agent = await httpsAgent());
+  let request = async () => {
+    let signal = abortSignalFromRequestBehaviour(behaviour);
+    return init?.signal && (signal = init.signal), fetch(url4, { ...init, agent, signal });
+  };
+  return runWithTimer("cmd_all_timing_network_ms")(async () => simpleRequestWithDebugLog({
+    url: url4.toString(),
+    request,
+    ...behaviour
   }));
 }
+async function fetch2(url4, init, preferredBehaviour) {
+  let options = {
+    url: url4,
+    init,
+    logRequest: !1,
+    useHttpsAgent: !1,
+    // all special behaviours are disabled by default
+    behaviour: requestMode(preferredBehaviour || "non-blocking")
+  };
+  return innerFetch(options);
+}
+async function shopifyFetch(url4, init, preferredBehaviour) {
+  let options = {
+    url: url4,
+    init,
+    logRequest: !0,
+    useHttpsAgent: !0,
+    // special behaviours enabled by default
+    behaviour: preferredBehaviour ? requestMode(preferredBehaviour) : requestMode()
+  };
+  return innerFetch(options);
+}
 
 // ../cli-kit/dist/public/node/result.js
 init_cjs_shims();
@@ -31955,9 +32161,9 @@ If you're the store owner, then you need to log in to the store directly using t
   return error === "invalid_grant" ? new InvalidGrantError() : error === "invalid_request" ? new InvalidRequestError() : error === "invalid_target" ? new InvalidTargetError(invalidTargetErrorMessage) : new AbortError(error);
 }
 async function tokenRequest(params) {
-  let fqdn = await identityFqdn(), url = new URL(`https://${fqdn}/oauth/token`);
-  url.search = new URLSearchParams(Object.entries(params)).toString();
-  let res = await shopifyFetch(url.href, { method: "POST" }), payload = await res.json();
+  let fqdn = await identityFqdn(), url4 = new URL(`https://${fqdn}/oauth/token`);
+  url4.search = new URLSearchParams(Object.entries(params)).toString();
+  let res = await shopifyFetch(url4.href, { method: "POST" }), payload = await res.json();
   return res.ok ? ok(payload) : err(payload.error);
 }
 function buildIdentityToken(result, existingUserId) {
@@ -32002,7 +32208,7 @@ async function remove() {
 // ../cli-kit/dist/private/node/session/device-authorization.js
 init_cjs_shims();
 async function requestDeviceAuthorization(scopes) {
-  let fqdn = await identityFqdn(), queryParams = { client_id: clientId(), scope: scopes.join(" ") }, url = `https://${fqdn}/oauth/device_authorization`, jsonResult = await (await shopifyFetch(url, {
+  let fqdn = await identityFqdn(), queryParams = { client_id: clientId(), scope: scopes.join(" ") }, url4 = `https://${fqdn}/oauth/device_authorization`, jsonResult = await (await shopifyFetch(url4, {
     method: "POST",
     headers: { "Content-type": "application/x-www-form-urlencoded" },
     body: convertRequestToParams(queryParams)
@@ -32010,13 +32216,13 @@ async function requestDeviceAuthorization(scopes) {
   if (outputDebug(outputContent`Received device authorization code: ${outputToken.json(jsonResult)}`), !jsonResult.device_code || !jsonResult.verification_uri_complete)
     throw new BugError("Failed to start authorization process");
   if (outputInfo(`
-To run this command, log in to Shopify.`), !isTTY())
+To run this command, log in to Shopify.`), isCI())
     throw new AbortError("Authorization is required to continue, but the current environment does not support interactive prompts.", "To resolve this, specify credentials in your environment, or run the command in an interactive environment such as your local terminal.");
   outputInfo(outputContent`User verification code: ${jsonResult.user_code}`);
   let linkToken = outputToken.link(jsonResult.verification_uri_complete), cloudMessage = () => {
     outputInfo(outputContent`👉 Open this link to start the auth process: ${linkToken}`);
   };
-  return isCloudEnvironment() ? cloudMessage() : (outputInfo("\u{1F449} Press any key to open the login page on your browser"), await keypress(), await openURL(jsonResult.verification_uri_complete) ? outputInfo(outputContent`Opened link to start the auth process: ${linkToken}`) : cloudMessage()), {
+  return isCloudEnvironment() || !isTTY() ? cloudMessage() : (outputInfo("\u{1F449} Press any key to open the login page on your browser"), await keypress(), await openURL(jsonResult.verification_uri_complete) ? outputInfo(outputContent`Opened link to start the auth process: ${linkToken}`) : cloudMessage()), {
     deviceCode: jsonResult.device_code,
     userCode: jsonResult.user_code,
     verificationUri: jsonResult.verification_uri,
@@ -32280,7 +32486,10 @@ export {
   require_mime_types,
   FetchError,
   formData,
+  requestMode,
+  abortSignalFromRequestBehaviour,
   fetch2 as fetch,
+  shopifyFetch,
   z,
   partnersFqdn,
   appManagementFqdn,
@@ -32317,4 +32526,4 @@ mime-types/index.js:
    * MIT Licensed
    *)
 */
-//# sourceMappingURL=chunk-DH5OC5ON.js.map
+//# sourceMappingURL=chunk-PC72P66L.js.map