@cloudflare/deploy-helpers 0.1.3 → 0.2.0

package/dist/index.mjs

@@ -1,35 +1,421 @@
 import { __commonJS, __name, __require, __toESM, fetchListResult, logger, fetchResult, confirm, fetchPagedListResult, prompt, isNonInteractiveOrCI } from './chunk-NAAB7FBS.mjs';
 export { initDeployHelpersContext } from './chunk-NAAB7FBS.mjs';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import assert6 from 'node:assert';
-import fs, { readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import * as path5 from 'node:path';
-import path5__default, { resolve, extname } from 'node:path';
+import { readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+import path__default, { resolve, extname, isAbsolute, sep } from 'node:path';
 import url, { URLSearchParams as URLSearchParams$1 } from 'node:url';
 import * as cli from '@cloudflare/cli-shared-helpers';
 import { cancel } from '@cloudflare/cli-shared-helpers';
-import { verifyDockerInstalled } from '@cloudflare/containers-shared';
 import { getEnvironmentVariableFactory, getHostFromRoute, retryOnAPIFailure, UserError, ParseError, getComplianceRegionSubdomain, configFileName, formatTime, getSubdomainMixedStateCheckDisabled, LOGGER_LEVELS, APIError, INHERIT_SYMBOL, COMPLIANCE_REGION_CONFIG_UNKNOWN, constructWranglerConfig, SERVICE_TAG_PREFIX, ENVIRONMENT_TAG_PREFIX, getWranglerTmpDir, getCIMatchTag, FatalError, formatConfigSnippet, readFileSync as readFileSync$1, parseJSON, getBindingTypeFriendlyName, getBindingLocalSupport, assertNever as assertNever$1, experimental_patchConfig, getTodaysCompatDate, getDockerPath, parseNonHyphenedUuid, getWorkersCIBranchName } from '@cloudflare/workers-utils';
+import { spawnSync, execSync, spawn } from 'node:child_process';
 import { FormData, Response } from 'undici';
 import chalk5 from 'chalk';
 import PQueue from 'p-queue';
 import { writeFile, readdir, stat, readFile } from 'node:fs/promises';
-import { CF_ASSETS_IGNORE_FILENAME, MAX_ASSET_SIZE } from '@cloudflare/workers-shared/utils/constants';
-import { createAssetsIgnoreFunction, normalizeFilePath, getContentType } from '@cloudflare/workers-shared/utils/helpers';
 import prettyBytes from 'pretty-bytes';
 import { hash } from 'blake3-wasm';
 import { Blob } from 'node:buffer';
 import { gzipSync } from 'node:zlib';
 import { brandColor, white, gray, dim, blue } from '@cloudflare/cli-shared-helpers/colors';
 import { inputPrompt, leftT } from '@cloudflare/cli-shared-helpers/interactive';
-import { spawnSync, execSync } from 'node:child_process';
 import { sync } from 'command-exists';
 import readline from 'node:readline';
 import { parse } from 'dotenv';
 import { stripVTControlCharacters } from 'node:util';
-import { maybeGetFile } from '@cloudflare/workers-shared';
 import { getFreshSourceMapSupport, getNodeCompat } from 'miniflare';
 import { createHash } from 'node:crypto';
 
+// ../../node_modules/.pnpm/ignore@5.3.1/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@5.3.1/node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    __name(makeArray, "makeArray");
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define2 = /* @__PURE__ */ __name((object, key, value) => Object.defineProperty(object, key, { value }), "define");
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = /* @__PURE__ */ __name(() => false, "RETURN_FALSE");
+    var sanitizeRange = /* @__PURE__ */ __name((range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    ), "sanitizeRange");
+    var cleanRangeBackSlash = /* @__PURE__ */ __name((slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    }, "cleanRangeBackSlash");
+    var REPLACERS = [
+      [
+        // remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a \ ) -> (a  )
+        /\\?\s+$/,
+        (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
+      ],
+      // replace (\ ) with ' '
+      [
+        /\\\s/g,
+        () => SPACE
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        /* @__PURE__ */ __name(function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }, "startingReplacer")
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ],
+      // trailing wildcard
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = /* @__PURE__ */ __name((pattern, ignoreCase) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+    }, "makeRegex");
+    var isString = /* @__PURE__ */ __name((subject) => typeof subject === "string", "isString");
+    var checkPattern = /* @__PURE__ */ __name((pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0, "checkPattern");
+    var splitPattern = /* @__PURE__ */ __name((pattern) => pattern.split(REGEX_SPLITALL_CRLF), "splitPattern");
+    var IgnoreRule = class {
+      static {
+        __name(this, "IgnoreRule");
+      }
+      constructor(origin, pattern, negative, regex) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex;
+      }
+    };
+    var createRule = /* @__PURE__ */ __name((pattern, ignoreCase) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex = makeRegex(pattern, ignoreCase);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex
+      );
+    }, "createRule");
+    var throwError = /* @__PURE__ */ __name((message, Ctor) => {
+      throw new Ctor(message);
+    }, "throwError");
+    var checkPath = /* @__PURE__ */ __name((path8, originalPath, doThrow) => {
+      if (!isString(path8)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path8) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path8)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    }, "checkPath");
+    var isNotRelative = /* @__PURE__ */ __name((path8) => REGEX_TEST_INVALID_PATH.test(path8), "isNotRelative");
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      static {
+        __name(this, "Ignore");
+      }
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define2(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      //          |           ignored : unignored
+      // negative |   0:0   |   0:1   |   1:0   |   1:1
+      // -------- | ------- | ------- | ------- | --------
+      //     0    |  TEST   |  TEST   |  SKIP   |    X
+      //     1    |  TESTIF |  SKIP   |  TEST   |    X
+      // - SKIP: always skip
+      // - TEST: always test
+      // - TESTIF: only test if checkUnignored
+      // - X: that never happen
+      // @param {boolean} whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // @returns {TestResult} true if a file is ignored
+      _testOne(path8, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path8);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path8 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path8,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError
+        );
+        return this._t(path8, cache, checkUnignored, slices);
+      }
+      _t(path8, cache, checkUnignored, slices) {
+        if (path8 in cache) {
+          return cache[path8];
+        }
+        if (!slices) {
+          slices = path8.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path8] = this._testOne(path8, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
+      }
+      ignores(path8) {
+        return this._test(path8, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path8) => !this.ignores(path8);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path8) {
+        return this._test(path8, this._testCache, true);
+      }
+    };
+    var factory = /* @__PURE__ */ __name((options) => new Ignore(options), "factory");
+    var isPathValid = /* @__PURE__ */ __name((path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE), "isPathValid");
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module.exports = factory;
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+    ) {
+      const makePosix = /* @__PURE__ */ __name((str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/"), "makePosix");
+      checkPath.convert = makePosix;
+      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/heap@0.2.7/node_modules/heap/lib/heap.js
 var require_heap = __commonJS({
   "../../node_modules/.pnpm/heap@0.2.7/node_modules/heap/lib/heap.js"(exports, module) {
@@ -69,57 +455,57 @@ var require_heap = __commonJS({
         }
         return [].splice.apply(a, [lo, lo - lo].concat(x)), x;
       }, "insort");
-      heappush = /* @__PURE__ */ __name(function(array, item, cmp) {
+      heappush = /* @__PURE__ */ __name(function(array2, item, cmp) {
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        array.push(item);
-        return _siftdown(array, 0, array.length - 1, cmp);
+        array2.push(item);
+        return _siftdown(array2, 0, array2.length - 1, cmp);
       }, "heappush");
-      heappop = /* @__PURE__ */ __name(function(array, cmp) {
+      heappop = /* @__PURE__ */ __name(function(array2, cmp) {
         var lastelt, returnitem;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        lastelt = array.pop();
-        if (array.length) {
-          returnitem = array[0];
-          array[0] = lastelt;
-          _siftup(array, 0, cmp);
+        lastelt = array2.pop();
+        if (array2.length) {
+          returnitem = array2[0];
+          array2[0] = lastelt;
+          _siftup(array2, 0, cmp);
         } else {
           returnitem = lastelt;
         }
         return returnitem;
       }, "heappop");
-      heapreplace = /* @__PURE__ */ __name(function(array, item, cmp) {
+      heapreplace = /* @__PURE__ */ __name(function(array2, item, cmp) {
         var returnitem;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        returnitem = array[0];
-        array[0] = item;
-        _siftup(array, 0, cmp);
+        returnitem = array2[0];
+        array2[0] = item;
+        _siftup(array2, 0, cmp);
         return returnitem;
       }, "heapreplace");
-      heappushpop = /* @__PURE__ */ __name(function(array, item, cmp) {
+      heappushpop = /* @__PURE__ */ __name(function(array2, item, cmp) {
         var _ref;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        if (array.length && cmp(array[0], item) < 0) {
-          _ref = [array[0], item], item = _ref[0], array[0] = _ref[1];
-          _siftup(array, 0, cmp);
+        if (array2.length && cmp(array2[0], item) < 0) {
+          _ref = [array2[0], item], item = _ref[0], array2[0] = _ref[1];
+          _siftup(array2, 0, cmp);
         }
         return item;
       }, "heappushpop");
-      heapify = /* @__PURE__ */ __name(function(array, cmp) {
+      heapify = /* @__PURE__ */ __name(function(array2, cmp) {
         var i, _i, _len, _ref1, _results, _results1;
         if (cmp == null) {
           cmp = defaultCmp;
         }
         _ref1 = function() {
           _results1 = [];
-          for (var _j2 = 0, _ref2 = floor(array.length / 2); 0 <= _ref2 ? _j2 < _ref2 : _j2 > _ref2; 0 <= _ref2 ? _j2++ : _j2--) {
+          for (var _j2 = 0, _ref2 = floor(array2.length / 2); 0 <= _ref2 ? _j2 < _ref2 : _j2 > _ref2; 0 <= _ref2 ? _j2++ : _j2--) {
             _results1.push(_j2);
           }
           return _results1;
@@ -127,51 +513,51 @@ var require_heap = __commonJS({
         _results = [];
         for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
           i = _ref1[_i];
-          _results.push(_siftup(array, i, cmp));
+          _results.push(_siftup(array2, i, cmp));
         }
         return _results;
       }, "heapify");
-      updateItem = /* @__PURE__ */ __name(function(array, item, cmp) {
+      updateItem = /* @__PURE__ */ __name(function(array2, item, cmp) {
         var pos;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        pos = array.indexOf(item);
+        pos = array2.indexOf(item);
         if (pos === -1) {
           return;
         }
-        _siftdown(array, 0, pos, cmp);
-        return _siftup(array, pos, cmp);
+        _siftdown(array2, 0, pos, cmp);
+        return _siftup(array2, pos, cmp);
       }, "updateItem");
-      nlargest = /* @__PURE__ */ __name(function(array, n, cmp) {
+      nlargest = /* @__PURE__ */ __name(function(array2, n, cmp) {
         var elem, result, _i, _len, _ref;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        result = array.slice(0, n);
+        result = array2.slice(0, n);
         if (!result.length) {
           return result;
         }
         heapify(result, cmp);
-        _ref = array.slice(n);
+        _ref = array2.slice(n);
         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
           elem = _ref[_i];
           heappushpop(result, elem, cmp);
         }
         return result.sort(cmp).reverse();
       }, "nlargest");
-      nsmallest = /* @__PURE__ */ __name(function(array, n, cmp) {
+      nsmallest = /* @__PURE__ */ __name(function(array2, n, cmp) {
         var elem, los, result, _i, _j, _len, _ref, _ref1, _results;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        if (n * 10 <= array.length) {
-          result = array.slice(0, n).sort(cmp);
+        if (n * 10 <= array2.length) {
+          result = array2.slice(0, n).sort(cmp);
           if (!result.length) {
             return result;
           }
           los = result[result.length - 1];
-          _ref = array.slice(n);
+          _ref = array2.slice(n);
           for (_i = 0, _len = _ref.length; _i < _len; _i++) {
             elem = _ref[_i];
             if (cmp(elem, los) < 0) {
@@ -182,51 +568,51 @@ var require_heap = __commonJS({
           }
           return result;
         }
-        heapify(array, cmp);
+        heapify(array2, cmp);
         _results = [];
-        for (_j = 0, _ref1 = min(n, array.length); 0 <= _ref1 ? _j < _ref1 : _j > _ref1; 0 <= _ref1 ? ++_j : --_j) {
-          _results.push(heappop(array, cmp));
+        for (_j = 0, _ref1 = min(n, array2.length); 0 <= _ref1 ? _j < _ref1 : _j > _ref1; 0 <= _ref1 ? ++_j : --_j) {
+          _results.push(heappop(array2, cmp));
         }
         return _results;
       }, "nsmallest");
-      _siftdown = /* @__PURE__ */ __name(function(array, startpos, pos, cmp) {
+      _siftdown = /* @__PURE__ */ __name(function(array2, startpos, pos, cmp) {
         var newitem, parent, parentpos;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        newitem = array[pos];
+        newitem = array2[pos];
         while (pos > startpos) {
           parentpos = pos - 1 >> 1;
-          parent = array[parentpos];
+          parent = array2[parentpos];
           if (cmp(newitem, parent) < 0) {
-            array[pos] = parent;
+            array2[pos] = parent;
             pos = parentpos;
             continue;
           }
           break;
         }
-        return array[pos] = newitem;
+        return array2[pos] = newitem;
       }, "_siftdown");
-      _siftup = /* @__PURE__ */ __name(function(array, pos, cmp) {
+      _siftup = /* @__PURE__ */ __name(function(array2, pos, cmp) {
         var childpos, endpos, newitem, rightpos, startpos;
         if (cmp == null) {
           cmp = defaultCmp;
         }
-        endpos = array.length;
+        endpos = array2.length;
         startpos = pos;
-        newitem = array[pos];
+        newitem = array2[pos];
         childpos = 2 * pos + 1;
         while (childpos < endpos) {
           rightpos = childpos + 1;
-          if (rightpos < endpos && !(cmp(array[childpos], array[rightpos]) < 0)) {
+          if (rightpos < endpos && !(cmp(array2[childpos], array2[rightpos]) < 0)) {
             childpos = rightpos;
           }
-          array[pos] = array[childpos];
+          array2[pos] = array2[childpos];
           pos = childpos;
           childpos = 2 * pos + 1;
         }
-        array[pos] = newitem;
-        return _siftdown(array, startpos, pos, cmp);
+        array2[pos] = newitem;
+        return _siftdown(array2, startpos, pos, cmp);
       }, "_siftup");
       Heap = function() {
         Heap2.push = heappush;
@@ -2155,12 +2541,12 @@ var require_lib = __commonJS({
         }
         return bestMatch;
       }
-      scalarize(array, originals, fuzzyOriginals) {
+      scalarize(array2, originals, fuzzyOriginals) {
         const fuzzyMatches = [];
         if (fuzzyOriginals) {
           const keyScores = {};
-          for (let index = 0; index < array.length; index++) {
-            const item = array[index];
+          for (let index = 0; index < array2.length; index++) {
+            const item = array2[index];
             if (this.isScalar(item)) {
               continue;
             }
@@ -2174,8 +2560,8 @@ var require_lib = __commonJS({
           }
         }
         const result = [];
-        for (let index = 0; index < array.length; index++) {
-          const item = array[index];
+        for (let index = 0; index < array2.length; index++) {
+          const item = array2[index];
           if (this.isScalar(item)) {
             result.push(item);
           } else {
@@ -2358,6 +2744,1158 @@ var require_lib = __commonJS({
     module.exports = { diff, diffString, colorize, colorizeToCallback };
   }
 });
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS2 = /* @__PURE__ */ __name((cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+}, "__commonJS");
+var AssetsSchema = z.strictObject({
+  htmlHandling: z.enum([
+    "auto-trailing-slash",
+    "drop-trailing-slash",
+    "force-trailing-slash",
+    "none"
+  ]).optional(),
+  notFoundHandling: z.enum([
+    "single-page-application",
+    "404-page",
+    "none"
+  ]).optional(),
+  runWorkerFirst: z.union([z.array(z.string()), z.boolean()]).optional()
+});
+var KnownBindingSchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("agent-memory"),
+    namespace: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("ai"),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("ai-search"),
+    name: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("ai-search-namespace"),
+    namespace: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("analytics-engine-dataset"),
+    name: z.string().optional()
+  }),
+  z.strictObject({
+    type: z.literal("artifacts"),
+    namespace: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({ type: z.literal("assets") }),
+  z.strictObject({
+    type: z.literal("browser"),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("d1"),
+    name: z.string().optional(),
+    id: z.string().optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("dispatch-namespace"),
+    namespace: z.string(),
+    outbound: z.strictObject({
+      workerName: z.string(),
+      parameters: z.array(z.string()).optional()
+    }).optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("durable-object"),
+    workerName: z.string(),
+    exportName: z.string()
+  }),
+  z.strictObject({
+    type: z.literal("flagship"),
+    id: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("hyperdrive"),
+    id: z.string(),
+    localConnectionString: z.string().optional()
+  }),
+  z.strictObject({
+    type: z.literal("images"),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("json"),
+    value: z.json()
+  }),
+  z.strictObject({
+    type: z.literal("kv"),
+    id: z.string().optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("logfwdr"),
+    destination: z.string()
+  }),
+  z.strictObject({
+    type: z.literal("media"),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("mtls-certificate"),
+    id: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("pipeline"),
+    name: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("queue"),
+    name: z.string(),
+    deliveryDelay: z.number().optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("rate-limit"),
+    namespace: z.string(),
+    simple: z.strictObject({
+      limit: z.number(),
+      period: z.union([z.literal(10), z.literal(60)])
+    })
+  }),
+  z.strictObject({
+    type: z.literal("r2"),
+    name: z.string().optional(),
+    jurisdiction: z.string().optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({ type: z.literal("secret") }),
+  z.strictObject({
+    type: z.literal("secrets-store-secret"),
+    storeId: z.string(),
+    secretName: z.string()
+  }),
+  z.strictObject({
+    type: z.literal("send-email"),
+    destinationAddress: z.string().optional(),
+    allowedDestinationAddresses: z.array(z.string()).optional(),
+    allowedSenderAddresses: z.array(z.string()).optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("stream"),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("text"),
+    value: z.string()
+  }),
+  z.strictObject({
+    type: z.literal("vectorize"),
+    name: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({ type: z.literal("version-metadata") }),
+  z.strictObject({
+    type: z.literal("vpc-service"),
+    id: z.string(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("vpc-network"),
+    tunnelId: z.string().optional(),
+    networkId: z.string().optional(),
+    remote: z.boolean().optional()
+  }).superRefine((value, ctx) => {
+    const hasTunnel = value.tunnelId !== void 0;
+    if (hasTunnel === (value.networkId !== void 0)) ctx.addIssue({
+      code: "custom",
+      message: hasTunnel ? `"vpc-network" bindings must specify exactly one of "tunnelId" or "networkId", not both` : `"vpc-network" bindings must specify either "tunnelId" or "networkId"`
+    });
+  }),
+  z.strictObject({
+    type: z.literal("web-search"),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({
+    type: z.literal("worker"),
+    workerName: z.string(),
+    exportName: z.string().optional(),
+    props: z.record(z.string(), z.unknown()).optional(),
+    remote: z.boolean().optional()
+  }),
+  z.strictObject({ type: z.literal("worker-loader") })
+]);
+var UnsafeBindingSchema = z.looseObject({
+  type: z.templateLiteral(["unsafe:", z.string().min(1)]),
+  dev: z.strictObject({
+    plugin: z.strictObject({
+      package: z.string(),
+      name: z.string()
+    }),
+    options: z.record(z.string(), z.unknown()).optional()
+  }).optional()
+});
+var BindingSchema = z.unknown().transform((value, ctx) => {
+  const result = (typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && value.type.startsWith("unsafe:") ? UnsafeBindingSchema : KnownBindingSchema).safeParse(value);
+  if (!result.success) {
+    ctx.issues.push(...result.error.issues);
+    return z.NEVER;
+  }
+  return result.data;
+});
+function isParsedUnsafeBinding(binding) {
+  return binding.type.startsWith("unsafe:");
+}
+__name(isParsedUnsafeBinding, "isParsedUnsafeBinding");
+var CacheSchema = z.strictObject({ enabled: z.boolean() });
+var SINGLETON_BINDING_TYPES = /* @__PURE__ */ new Set([
+  "ai",
+  "assets",
+  "browser",
+  "images",
+  "media",
+  "stream",
+  "version-metadata",
+  "web-search"
+]);
+var listFormatter = new Intl.ListFormat("en-US");
+var EnvSchema = z.record(z.string(), BindingSchema).superRefine((env, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const binding of Object.values(env)) {
+    const type = binding.type;
+    if (SINGLETON_BINDING_TYPES.has(type)) {
+      if (seen.has(type)) duplicates.add(type);
+      seen.add(type);
+    }
+  }
+  if (duplicates.size > 0) ctx.addIssue({
+    code: "custom",
+    message: `${listFormatter.format([...duplicates].sort())} bindings can only be defined once`
+  });
+}).optional();
+var ExportSchema = z.discriminatedUnion("type", [z.strictObject({
+  type: z.literal("durable-object"),
+  storage: z.enum(["sqlite", "legacy-kv"])
+})]);
+var LimitsSchema = z.strictObject({
+  cpuMs: z.number().optional(),
+  subrequests: z.number().optional()
+});
+var ObservabilitySchema = z.strictObject({
+  enabled: z.boolean().optional(),
+  headSamplingRate: z.number().optional(),
+  logs: z.strictObject({
+    enabled: z.boolean().optional(),
+    headSamplingRate: z.number().optional(),
+    invocationLogs: z.boolean().optional(),
+    persist: z.boolean().optional(),
+    destinations: z.array(z.string()).optional()
+  }).optional(),
+  traces: z.strictObject({
+    enabled: z.boolean().optional(),
+    headSamplingRate: z.number().optional(),
+    persist: z.boolean().optional(),
+    destinations: z.array(z.string()).optional()
+  }).optional()
+});
+var PlacementSchema = z.union([
+  z.strictObject({
+    mode: z.enum(["off", "smart"]),
+    hint: z.string().optional()
+  }),
+  z.strictObject({
+    mode: z.literal("targeted").optional(),
+    region: z.string()
+  }),
+  z.strictObject({
+    mode: z.literal("targeted").optional(),
+    host: z.string()
+  }),
+  z.strictObject({
+    mode: z.literal("targeted").optional(),
+    hostname: z.string()
+  })
+]);
+var TailConsumerSchema = z.strictObject({
+  workerName: z.string(),
+  streaming: z.boolean().optional()
+});
+var TriggerSchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("fetch"),
+    pattern: z.string(),
+    zone: z.string().optional()
+  }),
+  z.strictObject({
+    type: z.literal("queue"),
+    name: z.string(),
+    deadLetterQueue: z.string().optional(),
+    maxBatchSize: z.number().optional(),
+    maxBatchTimeout: z.number().optional(),
+    maxConcurrency: z.number().nullable().optional(),
+    maxRetries: z.number().optional(),
+    retryDelay: z.number().optional(),
+    visibilityTimeoutMs: z.number().optional()
+  }),
+  z.strictObject({
+    type: z.literal("scheduled"),
+    schedule: z.string()
+  })
+]);
+var UnsafeSchema = z.strictObject({
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  capnp: z.union([z.strictObject({
+    basePath: z.string(),
+    sourceSchemas: z.array(z.string()),
+    compiledSchema: z.never().optional()
+  }), z.strictObject({
+    basePath: z.never().optional(),
+    sourceSchemas: z.never().optional(),
+    compiledSchema: z.string()
+  })]).optional()
+});
+var BaseWorkerSchema = z.strictObject({
+  name: z.string(),
+  accountId: z.string().optional(),
+  compatibilityDate: z.string(),
+  compatibilityFlags: z.array(z.string()).optional(),
+  assets: AssetsSchema.optional(),
+  domains: z.array(z.string()).optional(),
+  triggers: z.array(TriggerSchema).optional(),
+  tailConsumers: z.array(TailConsumerSchema).optional(),
+  cache: CacheSchema.optional(),
+  placement: PlacementSchema.optional(),
+  limits: LimitsSchema.optional(),
+  logpush: z.boolean().optional(),
+  observability: ObservabilitySchema.optional(),
+  workersDev: z.boolean().optional(),
+  previewUrls: z.boolean().optional(),
+  complianceRegion: z.enum(["public", "fedramp-high"]).optional(),
+  firstPartyWorker: z.boolean().optional(),
+  unsafe: UnsafeSchema.optional(),
+  env: EnvSchema,
+  exports: z.record(z.string(), ExportSchema).optional()
+});
+var InputWorkerSchema = BaseWorkerSchema.extend({ entrypoint: z.union([z.string(), z.strictObject({ default: z.string() })]).transform((value) => typeof value === "string" ? value : value.default).optional() });
+var ModuleTypeSchema = z.enum([
+  "esm",
+  "cjs",
+  "python",
+  "pythonRequirement",
+  "wasm",
+  "text",
+  "data",
+  "json",
+  "sourcemap"
+]);
+var ManifestSchema = z.strictObject({
+  mainModule: z.string(),
+  modules: z.record(z.string(), z.strictObject({ type: ModuleTypeSchema }))
+});
+var OutputWorkerSchema = BaseWorkerSchema.extend({ manifest: ManifestSchema.optional() });
+var require_dist = /* @__PURE__ */ __commonJS2({ "../../node_modules/.pnpm/ts-dedent@2.2.0/node_modules/ts-dedent/dist/index.js": /* @__PURE__ */ __name((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.dedent = void 0;
+  function dedent$1(templ) {
+    var values = [];
+    for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+    var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+    strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+    var indentLengths = strings.reduce(function(arr, str) {
+      var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+      if (matches) return arr.concat(matches.map(function(match) {
+        var _a, _b;
+        return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+      }));
+      return arr;
+    }, []);
+    if (indentLengths.length) {
+      var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+      strings = strings.map(function(str) {
+        return str.replace(pattern_1, "\n");
+      });
+    }
+    strings[0] = strings[0].replace(/^\r?\n/, "");
+    var string2 = strings[0];
+    values.forEach(function(value, i) {
+      var endentations = string2.match(/(?:^|\n)( *)$/);
+      var endentation = endentations ? endentations[1] : "";
+      var indentedValue = value;
+      if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map(function(str, i$1) {
+        return i$1 === 0 ? str : "" + endentation + str;
+      }).join("\n");
+      string2 += indentedValue + strings[i + 1];
+    });
+    return string2;
+  }
+  __name(dedent$1, "dedent$1");
+  exports.dedent = dedent$1;
+}, "../../node_modules/.pnpm/ts-dedent@2.2.0/node_modules/ts-dedent/dist/index.js") });
+require_dist();
+function convertToWranglerConfig(config) {
+  const result = {};
+  convertTopLevel(config, result);
+  convertBindingsAndAssets(config, result);
+  convertExports(config);
+  convertDomains(config, result);
+  convertTriggers(config, result);
+  convertTailConsumers(config, result);
+  return result;
+}
+__name(convertToWranglerConfig, "convertToWranglerConfig");
+function convertTopLevel(config, result) {
+  if (config.name !== void 0) result.name = config.name;
+  if (typeof config.entrypoint === "string") result.main = config.entrypoint;
+  if (config.accountId !== void 0) result.account_id = config.accountId;
+  if (config.compatibilityDate !== void 0) result.compatibility_date = config.compatibilityDate;
+  if (config.compatibilityFlags !== void 0) result.compatibility_flags = config.compatibilityFlags;
+  if (config.workersDev !== void 0) result.workers_dev = config.workersDev;
+  if (config.previewUrls !== void 0) result.preview_urls = config.previewUrls;
+  if (config.logpush !== void 0) result.logpush = config.logpush;
+  if (config.complianceRegion !== void 0) result.compliance_region = config.complianceRegion === "fedramp-high" ? "fedramp_high" : "public";
+  if (config.firstPartyWorker !== void 0) result.first_party_worker = config.firstPartyWorker;
+  if (config.placement !== void 0) result.placement = config.placement;
+  if (config.limits !== void 0) {
+    const limits = {};
+    if (config.limits.cpuMs !== void 0) limits.cpu_ms = config.limits.cpuMs;
+    if (config.limits.subrequests !== void 0) limits.subrequests = config.limits.subrequests;
+    result.limits = limits;
+  }
+  if (config.observability !== void 0) result.observability = convertObservability(config.observability);
+  if (config.cache !== void 0) result.cache = { enabled: config.cache.enabled };
+  if (config.unsafe !== void 0) result.unsafe = convertUnsafeTopLevel(config.unsafe);
+}
+__name(convertTopLevel, "convertTopLevel");
+function convertObservability(observability) {
+  const out = {};
+  if (observability.enabled !== void 0) out.enabled = observability.enabled;
+  if (observability.headSamplingRate !== void 0) out.head_sampling_rate = observability.headSamplingRate;
+  if (observability.logs !== void 0) {
+    const logs = {};
+    const { logs: src } = observability;
+    if (src.enabled !== void 0) logs.enabled = src.enabled;
+    if (src.headSamplingRate !== void 0) logs.head_sampling_rate = src.headSamplingRate;
+    if (src.invocationLogs !== void 0) logs.invocation_logs = src.invocationLogs;
+    if (src.persist !== void 0) logs.persist = src.persist;
+    if (src.destinations !== void 0) logs.destinations = src.destinations;
+    out.logs = logs;
+  }
+  if (observability.traces !== void 0) {
+    const traces = {};
+    const { traces: src } = observability;
+    if (src.enabled !== void 0) traces.enabled = src.enabled;
+    if (src.headSamplingRate !== void 0) traces.head_sampling_rate = src.headSamplingRate;
+    if (src.persist !== void 0) traces.persist = src.persist;
+    if (src.destinations !== void 0) traces.destinations = src.destinations;
+    out.traces = traces;
+  }
+  return out;
+}
+__name(convertObservability, "convertObservability");
+function convertUnsafeTopLevel(unsafe) {
+  const out = {};
+  if (unsafe.metadata !== void 0) out.metadata = unsafe.metadata;
+  if (unsafe.capnp !== void 0) {
+    if ("compiledSchema" in unsafe.capnp && unsafe.capnp.compiledSchema) out.capnp = { compiled_schema: unsafe.capnp.compiledSchema };
+    else if ("basePath" in unsafe.capnp && unsafe.capnp.basePath) out.capnp = {
+      base_path: unsafe.capnp.basePath,
+      source_schemas: unsafe.capnp.sourceSchemas ?? []
+    };
+  }
+  return out;
+}
+__name(convertUnsafeTopLevel, "convertUnsafeTopLevel");
+function convertBindingsAndAssets(config, result) {
+  let assetsBindingName;
+  const env = config.env ?? {};
+  const kvNamespaces = [];
+  const d1Databases = [];
+  const r2Buckets = [];
+  const vectorize = [];
+  const mtlsCertificates = [];
+  const hyperdrive = [];
+  const pipelines = [];
+  const flagship = [];
+  const aiSearch = [];
+  const aiSearchNamespaces = [];
+  const agentMemory = [];
+  const analyticsEngineDatasets = [];
+  const artifacts = [];
+  const dispatchNamespaces = [];
+  const secretsStoreSecrets = [];
+  const sendEmail = [];
+  const vpcServices = [];
+  const vpcNetworks = [];
+  const workerLoaders = [];
+  const ratelimits = [];
+  const services = [];
+  const durableObjectBindings = [];
+  const workflows = [];
+  const queueProducers = [];
+  const logfwdrBindings = [];
+  const unsafeBindings = [];
+  const vars = {};
+  const secretsRequired = [];
+  for (const [name, binding] of Object.entries(env)) {
+    if (isParsedUnsafeBinding(binding)) {
+      unsafeBindings.push({
+        ...binding,
+        name,
+        type: binding.type.slice(7)
+      });
+      continue;
+    }
+    switch (binding.type) {
+      case "agent-memory":
+        agentMemory.push(omitUndefined({
+          binding: name,
+          namespace: binding.namespace,
+          remote: binding.remote
+        }));
+        break;
+      case "ai":
+        result.ai = omitUndefined({
+          binding: name,
+          remote: binding.remote
+        });
+        break;
+      case "ai-search":
+        aiSearch.push(omitUndefined({
+          binding: name,
+          instance_name: binding.name,
+          remote: binding.remote
+        }));
+        break;
+      case "ai-search-namespace":
+        aiSearchNamespaces.push(omitUndefined({
+          binding: name,
+          namespace: binding.namespace,
+          remote: binding.remote
+        }));
+        break;
+      case "analytics-engine-dataset":
+        analyticsEngineDatasets.push(omitUndefined({
+          binding: name,
+          dataset: binding.name
+        }));
+        break;
+      case "artifacts":
+        artifacts.push(omitUndefined({
+          binding: name,
+          namespace: binding.namespace,
+          remote: binding.remote
+        }));
+        break;
+      case "assets":
+        assetsBindingName = name;
+        break;
+      case "browser":
+        result.browser = omitUndefined({
+          binding: name,
+          remote: binding.remote
+        });
+        break;
+      case "d1":
+        d1Databases.push(omitUndefined({
+          binding: name,
+          database_id: binding.id,
+          database_name: binding.name,
+          remote: binding.remote
+        }));
+        break;
+      case "dispatch-namespace": {
+        const entry = {
+          binding: name,
+          namespace: binding.namespace
+        };
+        if (binding.outbound) entry.outbound = omitUndefined({
+          service: binding.outbound.workerName,
+          parameters: binding.outbound.parameters
+        });
+        if (binding.remote !== void 0) entry.remote = binding.remote;
+        dispatchNamespaces.push(entry);
+        break;
+      }
+      case "durable-object":
+        durableObjectBindings.push({
+          name,
+          class_name: binding.exportName,
+          script_name: binding.workerName
+        });
+        break;
+      case "flagship":
+        flagship.push(omitUndefined({
+          binding: name,
+          app_id: binding.id,
+          remote: binding.remote
+        }));
+        break;
+      case "hyperdrive":
+        hyperdrive.push(omitUndefined({
+          binding: name,
+          id: binding.id,
+          localConnectionString: binding.localConnectionString
+        }));
+        break;
+      case "images":
+        result.images = omitUndefined({
+          binding: name,
+          remote: binding.remote
+        });
+        break;
+      case "json":
+        vars[name] = binding.value;
+        break;
+      case "kv":
+        kvNamespaces.push(omitUndefined({
+          binding: name,
+          id: binding.id,
+          remote: binding.remote
+        }));
+        break;
+      case "logfwdr":
+        logfwdrBindings.push({
+          name,
+          destination: binding.destination
+        });
+        break;
+      case "media":
+        result.media = omitUndefined({
+          binding: name,
+          remote: binding.remote
+        });
+        break;
+      case "mtls-certificate":
+        mtlsCertificates.push(omitUndefined({
+          binding: name,
+          certificate_id: binding.id,
+          remote: binding.remote
+        }));
+        break;
+      case "pipeline":
+        pipelines.push(omitUndefined({
+          binding: name,
+          stream: binding.name,
+          remote: binding.remote
+        }));
+        break;
+      case "queue":
+        queueProducers.push(omitUndefined({
+          binding: name,
+          queue: binding.name,
+          delivery_delay: binding.deliveryDelay,
+          remote: binding.remote
+        }));
+        break;
+      case "rate-limit":
+        ratelimits.push({
+          name,
+          namespace_id: binding.namespace,
+          simple: binding.simple
+        });
+        break;
+      case "r2":
+        r2Buckets.push(omitUndefined({
+          binding: name,
+          bucket_name: binding.name,
+          jurisdiction: binding.jurisdiction,
+          remote: binding.remote
+        }));
+        break;
+      case "secret":
+        secretsRequired.push(name);
+        break;
+      case "secrets-store-secret":
+        secretsStoreSecrets.push({
+          binding: name,
+          store_id: binding.storeId,
+          secret_name: binding.secretName
+        });
+        break;
+      case "send-email":
+        sendEmail.push(omitUndefined({
+          name,
+          destination_address: binding.destinationAddress,
+          allowed_destination_addresses: binding.allowedDestinationAddresses,
+          allowed_sender_addresses: binding.allowedSenderAddresses,
+          remote: binding.remote
+        }));
+        break;
+      case "stream":
+        result.stream = omitUndefined({
+          binding: name,
+          remote: binding.remote
+        });
+        break;
+      case "text":
+        vars[name] = binding.value;
+        break;
+      case "vectorize":
+        vectorize.push(omitUndefined({
+          binding: name,
+          index_name: binding.name,
+          remote: binding.remote
+        }));
+        break;
+      case "version-metadata":
+        result.version_metadata = { binding: name };
+        break;
+      case "vpc-service":
+        vpcServices.push(omitUndefined({
+          binding: name,
+          service_id: binding.id,
+          remote: binding.remote
+        }));
+        break;
+      case "vpc-network":
+        if (binding.tunnelId !== void 0) vpcNetworks.push(omitUndefined({
+          binding: name,
+          tunnel_id: binding.tunnelId,
+          remote: binding.remote
+        }));
+        else if (binding.networkId !== void 0) vpcNetworks.push(omitUndefined({
+          binding: name,
+          network_id: binding.networkId,
+          remote: binding.remote
+        }));
+        break;
+      case "web-search":
+        result.websearch = omitUndefined({
+          binding: name,
+          remote: binding.remote
+        });
+        break;
+      case "worker":
+        services.push(omitUndefined({
+          binding: name,
+          service: binding.workerName,
+          entrypoint: binding.exportName,
+          props: binding.props,
+          remote: binding.remote
+        }));
+        break;
+      case "worker-loader":
+        workerLoaders.push({ binding: name });
+        break;
+    }
+  }
+  if (kvNamespaces.length) result.kv_namespaces = kvNamespaces;
+  if (d1Databases.length) result.d1_databases = d1Databases;
+  if (r2Buckets.length) result.r2_buckets = r2Buckets;
+  if (vectorize.length) result.vectorize = vectorize;
+  if (mtlsCertificates.length) result.mtls_certificates = mtlsCertificates;
+  if (hyperdrive.length) result.hyperdrive = hyperdrive;
+  if (pipelines.length) result.pipelines = pipelines;
+  if (flagship.length) result.flagship = flagship;
+  if (aiSearch.length) result.ai_search = aiSearch;
+  if (aiSearchNamespaces.length) result.ai_search_namespaces = aiSearchNamespaces;
+  if (agentMemory.length) result.agent_memory = agentMemory;
+  if (analyticsEngineDatasets.length) result.analytics_engine_datasets = analyticsEngineDatasets;
+  if (artifacts.length) result.artifacts = artifacts;
+  if (dispatchNamespaces.length) result.dispatch_namespaces = dispatchNamespaces;
+  if (secretsStoreSecrets.length) result.secrets_store_secrets = secretsStoreSecrets;
+  if (sendEmail.length) result.send_email = sendEmail;
+  if (vpcServices.length) result.vpc_services = vpcServices;
+  if (vpcNetworks.length) result.vpc_networks = vpcNetworks;
+  if (workerLoaders.length) result.worker_loaders = workerLoaders;
+  if (ratelimits.length) result.ratelimits = ratelimits;
+  if (services.length) result.services = services;
+  if (durableObjectBindings.length) result.durable_objects = { bindings: durableObjectBindings };
+  if (workflows.length) result.workflows = workflows;
+  if (queueProducers.length) result.queues = {
+    ...result.queues ?? {},
+    producers: queueProducers
+  };
+  if (logfwdrBindings.length) result.logfwdr = { bindings: logfwdrBindings };
+  if (unsafeBindings.length) result.unsafe = {
+    ...result.unsafe ?? {},
+    bindings: unsafeBindings
+  };
+  if (Object.keys(vars).length) result.vars = vars;
+  if (secretsRequired.length) result.secrets = { required: secretsRequired };
+  if (config.assets !== void 0 || assetsBindingName !== void 0) {
+    const assets = {};
+    if (assetsBindingName !== void 0) assets.binding = assetsBindingName;
+    if (config.assets?.htmlHandling !== void 0) assets.html_handling = config.assets.htmlHandling;
+    if (config.assets?.notFoundHandling !== void 0) assets.not_found_handling = config.assets.notFoundHandling;
+    if (config.assets?.runWorkerFirst !== void 0) assets.run_worker_first = config.assets.runWorkerFirst;
+    result.assets = assets;
+  }
+}
+__name(convertBindingsAndAssets, "convertBindingsAndAssets");
+function convertExports(config, _result) {
+  const exports$2 = config.exports;
+  if (!exports$2) return;
+  for (const value of Object.values(exports$2)) if (value.type === "durable-object") throw new Error("Durable Object exports are not currently supported.");
+}
+__name(convertExports, "convertExports");
+function convertTriggers(config, result) {
+  const triggers$1 = config.triggers;
+  if (!triggers$1 || triggers$1.length === 0) return;
+  const crons = [];
+  const routes = result.routes ? [...result.routes] : [];
+  const queueConsumers = result.queues?.consumers ? [...result.queues.consumers] : [];
+  for (const trigger of triggers$1) switch (trigger.type) {
+    case "scheduled":
+      crons.push(trigger.schedule);
+      break;
+    case "fetch":
+      if (trigger.zone === void 0) routes.push(trigger.pattern);
+      else if (trigger.zone.includes(".")) routes.push({
+        pattern: trigger.pattern,
+        zone_name: trigger.zone
+      });
+      else routes.push({
+        pattern: trigger.pattern,
+        zone_id: trigger.zone
+      });
+      break;
+    case "queue":
+      queueConsumers.push(omitUndefined({
+        queue: trigger.name,
+        dead_letter_queue: trigger.deadLetterQueue,
+        max_batch_size: trigger.maxBatchSize,
+        max_batch_timeout: trigger.maxBatchTimeout,
+        max_concurrency: trigger.maxConcurrency,
+        max_retries: trigger.maxRetries,
+        retry_delay: trigger.retryDelay,
+        visibility_timeout_ms: trigger.visibilityTimeoutMs
+      }));
+      break;
+  }
+  if (crons.length) result.triggers = { crons };
+  if (routes.length) result.routes = routes;
+  if (queueConsumers.length) result.queues = {
+    ...result.queues ?? {},
+    consumers: queueConsumers
+  };
+}
+__name(convertTriggers, "convertTriggers");
+function convertDomains(config, result) {
+  if (!config.domains || config.domains.length === 0) return;
+  const routes = result.routes ? [...result.routes] : [];
+  for (const domain of config.domains) routes.push({
+    pattern: domain,
+    custom_domain: true
+  });
+  result.routes = routes;
+}
+__name(convertDomains, "convertDomains");
+function convertTailConsumers(config, result) {
+  const consumers = config.tailConsumers;
+  if (!consumers || consumers.length === 0) return;
+  const tail = [];
+  const streaming = [];
+  for (const consumer of consumers) if (consumer.streaming) streaming.push({ service: consumer.workerName });
+  else tail.push({ service: consumer.workerName });
+  if (tail.length) result.tail_consumers = tail;
+  if (streaming.length) result.streaming_tail_consumers = streaming;
+}
+__name(convertTailConsumers, "convertTailConsumers");
+function omitUndefined(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) if (value !== void 0) out[key] = value;
+  return out;
+}
+__name(omitUndefined, "omitUndefined");
+new AsyncLocalStorage();
+
+// ../containers-shared/src/client/models/ApplicationRollout.ts
+var ApplicationRollout;
+((ApplicationRollout2) => {
+  ((kind2) => {
+    kind2["FULL_AUTO"] = "full_auto";
+    kind2["FULL_MANUAL"] = "full_manual";
+    kind2["DURABLE_OBJECTS_AUTO"] = "durable_objects_auto";
+  })(ApplicationRollout2.kind || (ApplicationRollout2.kind = {}));
+  ((strategy2) => {
+    strategy2["ROLLING"] = "rolling";
+  })(ApplicationRollout2.strategy || (ApplicationRollout2.strategy = {}));
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["PROGRESSING"] = "progressing";
+    status2["COMPLETED"] = "completed";
+    status2["REVERTED"] = "reverted";
+    status2["REPLACED"] = "replaced";
+  })(ApplicationRollout2.status || (ApplicationRollout2.status = {}));
+})(ApplicationRollout || (ApplicationRollout = {}));
+
+// ../containers-shared/src/client/models/BadRequestWithCodeError.ts
+var BadRequestWithCodeError;
+((BadRequestWithCodeError2) => {
+  ((error2) => {
+    error2["VALIDATE_INPUT"] = "VALIDATE_INPUT";
+  })(BadRequestWithCodeError2.error || (BadRequestWithCodeError2.error = {}));
+})(BadRequestWithCodeError || (BadRequestWithCodeError = {}));
+
+// ../containers-shared/src/client/models/CreateApplicationRolloutRequest.ts
+var CreateApplicationRolloutRequest;
+((CreateApplicationRolloutRequest2) => {
+  ((strategy2) => {
+    strategy2["ROLLING"] = "rolling";
+  })(CreateApplicationRolloutRequest2.strategy || (CreateApplicationRolloutRequest2.strategy = {}));
+  ((step_percentage2) => {
+    step_percentage2[step_percentage2["_5"] = 5] = "_5";
+    step_percentage2[step_percentage2["_10"] = 10] = "_10";
+    step_percentage2[step_percentage2["_20"] = 20] = "_20";
+    step_percentage2[step_percentage2["_25"] = 25] = "_25";
+    step_percentage2[step_percentage2["_50"] = 50] = "_50";
+    step_percentage2[step_percentage2["_100"] = 100] = "_100";
+  })(CreateApplicationRolloutRequest2.step_percentage || (CreateApplicationRolloutRequest2.step_percentage = {}));
+  ((kind2) => {
+    kind2["FULL_AUTO"] = "full_auto";
+    kind2["FULL_MANUAL"] = "full_manual";
+  })(CreateApplicationRolloutRequest2.kind || (CreateApplicationRolloutRequest2.kind = {}));
+})(CreateApplicationRolloutRequest || (CreateApplicationRolloutRequest = {}));
+
+// ../containers-shared/src/client/models/DeploymentNotFoundError.ts
+var DeploymentNotFoundError;
+((DeploymentNotFoundError2) => {
+  ((error2) => {
+    error2["DEPLOYMENT_NOT_FOUND"] = "DEPLOYMENT_NOT_FOUND";
+  })(DeploymentNotFoundError2.error || (DeploymentNotFoundError2.error = {}));
+})(DeploymentNotFoundError || (DeploymentNotFoundError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryAlreadyExistsError.ts
+var ImageRegistryAlreadyExistsError;
+((ImageRegistryAlreadyExistsError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_ALREADY_EXISTS"] = "IMAGE_REGISTRY_ALREADY_EXISTS";
+  })(ImageRegistryAlreadyExistsError2.error || (ImageRegistryAlreadyExistsError2.error = {}));
+})(ImageRegistryAlreadyExistsError || (ImageRegistryAlreadyExistsError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryIsPublic.ts
+var ImageRegistryIsPublic;
+((ImageRegistryIsPublic2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_IS_PUBLIC"] = "IMAGE_REGISTRY_IS_PUBLIC";
+  })(ImageRegistryIsPublic2.error || (ImageRegistryIsPublic2.error = {}));
+})(ImageRegistryIsPublic || (ImageRegistryIsPublic = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryNotAllowedError.ts
+var ImageRegistryNotAllowedError;
+((ImageRegistryNotAllowedError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_NOT_ALLOWED"] = "IMAGE_REGISTRY_NOT_ALLOWED";
+  })(ImageRegistryNotAllowedError2.error || (ImageRegistryNotAllowedError2.error = {}));
+})(ImageRegistryNotAllowedError || (ImageRegistryNotAllowedError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryNotFoundError.ts
+var ImageRegistryNotFoundError;
+((ImageRegistryNotFoundError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_NOT_FOUND"] = "IMAGE_REGISTRY_NOT_FOUND";
+  })(ImageRegistryNotFoundError2.error || (ImageRegistryNotFoundError2.error = {}));
+})(ImageRegistryNotFoundError || (ImageRegistryNotFoundError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryProtocolAlreadyExists.ts
+var ImageRegistryProtocolAlreadyExists;
+((ImageRegistryProtocolAlreadyExists2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS"] = "IMAGE_REGISTRY_PROTOCOL_ALREADY_EXISTS";
+  })(ImageRegistryProtocolAlreadyExists2.error || (ImageRegistryProtocolAlreadyExists2.error = {}));
+})(ImageRegistryProtocolAlreadyExists || (ImageRegistryProtocolAlreadyExists = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryProtocolIsReferencedError.ts
+var ImageRegistryProtocolIsReferencedError;
+((ImageRegistryProtocolIsReferencedError2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTO_IS_REFERENCED"] = "IMAGE_REGISTRY_PROTO_IS_REFERENCED";
+  })(ImageRegistryProtocolIsReferencedError2.error || (ImageRegistryProtocolIsReferencedError2.error = {}));
+})(ImageRegistryProtocolIsReferencedError || (ImageRegistryProtocolIsReferencedError = {}));
+
+// ../containers-shared/src/client/models/ImageRegistryProtocolNotFound.ts
+var ImageRegistryProtocolNotFound;
+((ImageRegistryProtocolNotFound2) => {
+  ((error2) => {
+    error2["IMAGE_REGISTRY_PROTOCOL_NOT_FOUND"] = "IMAGE_REGISTRY_PROTOCOL_NOT_FOUND";
+  })(ImageRegistryProtocolNotFound2.error || (ImageRegistryProtocolNotFound2.error = {}));
+})(ImageRegistryProtocolNotFound || (ImageRegistryProtocolNotFound = {}));
+
+// ../containers-shared/src/client/models/ProvisionerConfiguration.ts
+var ProvisionerConfiguration;
+((ProvisionerConfiguration2) => {
+  ((type2) => {
+    type2["NONE"] = "none";
+    type2["CLOUDINIT"] = "cloudinit";
+  })(ProvisionerConfiguration2.type || (ProvisionerConfiguration2.type = {}));
+})(ProvisionerConfiguration || (ProvisionerConfiguration = {}));
+
+// ../containers-shared/src/client/models/RolloutStep.ts
+var RolloutStep;
+((RolloutStep2) => {
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["PROGRESSING"] = "progressing";
+    status2["REVERTING"] = "reverting";
+    status2["COMPLETED"] = "completed";
+    status2["REVERTED"] = "reverted";
+  })(RolloutStep2.status || (RolloutStep2.status = {}));
+})(RolloutStep || (RolloutStep = {}));
+
+// ../containers-shared/src/client/models/SecretNameAlreadyExists.ts
+var SecretNameAlreadyExists;
+((SecretNameAlreadyExists2) => {
+  ((error2) => {
+    error2["SECRET_NAME_ALREADY_EXISTS"] = "SECRET_NAME_ALREADY_EXISTS";
+  })(SecretNameAlreadyExists2.error || (SecretNameAlreadyExists2.error = {}));
+})(SecretNameAlreadyExists || (SecretNameAlreadyExists = {}));
+
+// ../containers-shared/src/client/models/SecretNotFound.ts
+var SecretNotFound;
+((SecretNotFound2) => {
+  ((error2) => {
+    error2["SECRET_NAME_NOT_FOUND"] = "SECRET_NAME_NOT_FOUND";
+  })(SecretNotFound2.error || (SecretNotFound2.error = {}));
+})(SecretNotFound || (SecretNotFound = {}));
+
+// ../containers-shared/src/client/models/SSHPublicKeyNotFoundError.ts
+var SSHPublicKeyNotFoundError;
+((SSHPublicKeyNotFoundError2) => {
+  ((error2) => {
+    error2["SSH_PUBLIC_KEY_NOT_FOUND"] = "SSH_PUBLIC_KEY_NOT_FOUND";
+  })(SSHPublicKeyNotFoundError2.error || (SSHPublicKeyNotFoundError2.error = {}));
+})(SSHPublicKeyNotFoundError || (SSHPublicKeyNotFoundError = {}));
+
+// ../containers-shared/src/client/models/UpdateApplicationRolloutRequest.ts
+var UpdateApplicationRolloutRequest;
+((UpdateApplicationRolloutRequest2) => {
+  ((action2) => {
+    action2["NEXT"] = "next";
+    action2["PREVIOUS"] = "previous";
+    action2["REVERT"] = "revert";
+  })(UpdateApplicationRolloutRequest2.action || (UpdateApplicationRolloutRequest2.action = {}));
+})(UpdateApplicationRolloutRequest || (UpdateApplicationRolloutRequest = {}));
+
+// ../containers-shared/src/utils.ts
+var runDockerCmd = /* @__PURE__ */ __name((dockerPath, args, stdio) => {
+  let aborted = false;
+  let resolve3;
+  let reject;
+  const ready = new Promise((res, rej) => {
+    resolve3 = res;
+    reject = rej;
+  });
+  const child = spawn(dockerPath, args, {
+    stdio: stdio ?? "inherit",
+    // We need to set detached to true so that the child process
+    // will control all of its child processes and we can kill
+    // all of them in case we need to abort the build process.
+    // On Windows, detached: true opens a new console window per child
+    // process, so we only set it on non-Windows platforms.
+    detached: process.platform !== "win32",
+    // Prevent child processes from opening visible console windows on Windows.
+    // This is a no-op on non-Windows platforms.
+    windowsHide: true
+  });
+  let errorHandled = false;
+  child.on("close", (code) => {
+    if (code === 0 || aborted) {
+      resolve3({ aborted });
+    } else if (!errorHandled) {
+      errorHandled = true;
+      reject(
+        new UserError(`Docker command exited with code: ${code}`, {
+          telemetryMessage: false
+        })
+      );
+    }
+  });
+  child.on("error", (err) => {
+    if (!errorHandled) {
+      errorHandled = true;
+      reject(
+        new UserError(`Docker command failed: ${err.message}`, {
+          telemetryMessage: false
+        })
+      );
+    }
+  });
+  return {
+    abort: /* @__PURE__ */ __name(() => {
+      aborted = true;
+      child.unref();
+      if (child.pid !== void 0) {
+        if (process.platform === "win32") {
+          child.kill();
+        } else {
+          process.kill(-child.pid);
+        }
+      }
+    }, "abort"),
+    ready,
+    then: /* @__PURE__ */ __name(async (onResolve, onReject) => ready.then(onResolve).catch(onReject), "then")
+  };
+}, "runDockerCmd");
+var isDockerRunning = /* @__PURE__ */ __name(async (dockerPath) => {
+  try {
+    await runDockerCmd(dockerPath, ["info"], ["inherit", "pipe", "pipe"]);
+  } catch {
+    return false;
+  }
+  return true;
+}, "isDockerRunning");
+var verifyDockerInstalled = /* @__PURE__ */ __name(async ({
+  dockerPath,
+  numberOfContainers,
+  isDev = true,
+  isDryRun = false
+}) => {
+  const dockerIsRunning = await isDockerRunning(dockerPath);
+  if (!dockerIsRunning) {
+    throw new UserError(
+      getFailedToRunDockerErrorMessage({
+        numberOfContainers,
+        isDev,
+        isDryRun
+      }),
+      {
+        telemetryMessage: false
+      }
+    );
+  }
+}, "verifyDockerInstalled");
+function getFailedToRunDockerErrorMessage({
+  numberOfContainers,
+  isDev,
+  isDryRun
+}) {
+  const operation = isDev ? "running dev" : `deploying${isDryRun ? " (even in dry-run mode)" : ""}`;
+  const headline = `The Docker CLI is needed to build the configured ${numberOfContainers !== 1 ? "images" : "image"} before ${operation} but could not be launched.`;
+  let daemonHint;
+  if (process.platform === "darwin") {
+    daemonHint = "open the Docker Desktop app or run `open -a Docker`";
+  } else if (process.platform === "win32") {
+    daemonHint = "open the Docker Desktop app";
+  } else {
+    daemonHint = "run `sudo systemctl start docker`";
+  }
+  const steps = `To fix this, try the following:
+  - If Docker is not installed, download it from https://docs.docker.com/get-started/get-docker/
+  - If Docker is installed but the daemon is not running,
+    ${daemonHint}.
+  - If you use an alternative Docker-compatible CLI (e.g. Podman),
+    set the WRANGLER_DOCKER_BIN environment variable to its path and DOCKER_HOST to its socket.`;
+  const alternatives = "Note: Other container tooling that is compatible with the Docker CLI and engine may work, but is not yet guaranteed to do so.";
+  const hint = isDev ? "To suppress this error if you do not intend on triggering any container instances, set dev.enable_containers to false in your Wrangler config or pass --enable-containers=false." : "If you cannot run Docker locally, you can still deploy your Worker by passing --containers-rollout=none. This will not deploy or update your Container.";
+  return `${headline}
+${steps}
+
+${alternatives}
+
+${hint}`;
+}
+__name(getFailedToRunDockerErrorMessage, "getFailedToRunDockerErrorMessage");
 async function getZoneForRoute(complianceConfig, from, zoneIdCache = /* @__PURE__ */ new Map()) {
   const { route, accountId } = from;
   const host = getHostFromRoute(route);
@@ -3483,6 +5021,1335 @@ function isWorkflowDefinedInThisScript(workflow, scriptName) {
   return workflow.script_name === void 0 || workflow.script_name === scriptName;
 }
 __name(isWorkflowDefinedInThisScript, "isWorkflowDefinedInThisScript");
+
+// ../workers-shared/utils/configuration/constants.ts
+var MAX_ROUTES_RULES = 100;
+var MAX_ROUTES_RULE_LENGTH = 100;
+
+// ../workers-shared/utils/configuration/parseStaticRouting.ts
+function parseStaticRouting(input) {
+  if (input.length === 0) {
+    throw new Error(
+      "No `run_worker_first` rules were provided; must provide at least 1 rule."
+    );
+  }
+  if (input.length > MAX_ROUTES_RULES) {
+    throw new Error(
+      `Too many \`run_worker_first\` rules were provided; ${input.length} rules provided exceeds max of ${MAX_ROUTES_RULES}.`
+    );
+  }
+  const rawAssetWorkerRules = [];
+  const assetWorkerRules = [];
+  const userWorkerRules = [];
+  const invalidRules = [];
+  for (const rule of input) {
+    if (rule.startsWith("!/")) {
+      assetWorkerRules.push(rule.slice(1));
+      rawAssetWorkerRules.push(rule);
+    } else if (rule.startsWith("/")) {
+      userWorkerRules.push(rule);
+    } else if (rule.startsWith("!")) {
+      invalidRules.push(`'${rule}': negative rules must start with '!/'`);
+    } else {
+      invalidRules.push(`'${rule}': rules must start with '/' or '!/'`);
+    }
+  }
+  if (assetWorkerRules.length > 0 && userWorkerRules.length === 0) {
+    throw new Error(
+      "Only negative `run_worker_first` rules were provided; must provide at least 1 non-negative rule"
+    );
+  }
+  const invalidAssetWorkerRules = validateStaticRoutingRules(rawAssetWorkerRules);
+  const invalidUserWorkerRules = validateStaticRoutingRules(userWorkerRules);
+  const errorMessage = formatInvalidRoutes([
+    ...invalidRules,
+    ...invalidUserWorkerRules,
+    ...invalidAssetWorkerRules
+  ]);
+  if (errorMessage) {
+    throw new Error(errorMessage);
+  }
+  return { asset_worker: assetWorkerRules, user_worker: userWorkerRules };
+}
+__name(parseStaticRouting, "parseStaticRouting");
+function validateStaticRoutingRules(rules) {
+  const invalid = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.length > MAX_ROUTES_RULE_LENGTH) {
+      invalid.push(
+        `'${rule}': all rules must be less than ${MAX_ROUTES_RULE_LENGTH} characters in length`
+      );
+    }
+    if (seen.has(rule)) {
+      invalid.push(`'${rule}': rule is a duplicate; rules must be unique`);
+    }
+    if (rule.endsWith("*")) {
+      for (const otherRule of rules) {
+        if (otherRule !== rule && otherRule.startsWith(rule.slice(0, -1))) {
+          invalid.push(`'${otherRule}': rule '${rule}' makes it redundant`);
+        }
+      }
+    }
+    seen.add(rule);
+  }
+  return invalid;
+}
+__name(validateStaticRoutingRules, "validateStaticRoutingRules");
+var formatInvalidRoutes = /* @__PURE__ */ __name((invalidRules) => {
+  if (invalidRules.length === 0) {
+    return void 0;
+  }
+  return `Invalid routes in \`run_worker_first\`:
+` + invalidRules.join("\n");
+}, "formatInvalidRoutes");
+var MAX_ASSET_SIZE = 25 * 1024 * 1024;
+var CF_ASSETS_IGNORE_FILENAME = ".assetsignore";
+var REDIRECTS_FILENAME = "_redirects";
+var HEADERS_FILENAME = "_headers";
+
+// ../workers-shared/utils/helpers.ts
+var import_ignore = __toESM(require_ignore());
+
+// ../../node_modules/.pnpm/mime@4.0.7/node_modules/mime/dist/types/other.js
+var types = {
+  "application/prs.cww": ["cww"],
+  "application/prs.xsf+xml": ["xsf"],
+  "application/vnd.1000minds.decision-model+xml": ["1km"],
+  "application/vnd.3gpp.pic-bw-large": ["plb"],
+  "application/vnd.3gpp.pic-bw-small": ["psb"],
+  "application/vnd.3gpp.pic-bw-var": ["pvb"],
+  "application/vnd.3gpp2.tcap": ["tcap"],
+  "application/vnd.3m.post-it-notes": ["pwn"],
+  "application/vnd.accpac.simply.aso": ["aso"],
+  "application/vnd.accpac.simply.imp": ["imp"],
+  "application/vnd.acucobol": ["acu"],
+  "application/vnd.acucorp": ["atc", "acutc"],
+  "application/vnd.adobe.air-application-installer-package+zip": ["air"],
+  "application/vnd.adobe.formscentral.fcdt": ["fcdt"],
+  "application/vnd.adobe.fxp": ["fxp", "fxpl"],
+  "application/vnd.adobe.xdp+xml": ["xdp"],
+  "application/vnd.adobe.xfdf": ["*xfdf"],
+  "application/vnd.age": ["age"],
+  "application/vnd.ahead.space": ["ahead"],
+  "application/vnd.airzip.filesecure.azf": ["azf"],
+  "application/vnd.airzip.filesecure.azs": ["azs"],
+  "application/vnd.amazon.ebook": ["azw"],
+  "application/vnd.americandynamics.acc": ["acc"],
+  "application/vnd.amiga.ami": ["ami"],
+  "application/vnd.android.package-archive": ["apk"],
+  "application/vnd.anser-web-certificate-issue-initiation": ["cii"],
+  "application/vnd.anser-web-funds-transfer-initiation": ["fti"],
+  "application/vnd.antix.game-component": ["atx"],
+  "application/vnd.apple.installer+xml": ["mpkg"],
+  "application/vnd.apple.keynote": ["key"],
+  "application/vnd.apple.mpegurl": ["m3u8"],
+  "application/vnd.apple.numbers": ["numbers"],
+  "application/vnd.apple.pages": ["pages"],
+  "application/vnd.apple.pkpass": ["pkpass"],
+  "application/vnd.aristanetworks.swi": ["swi"],
+  "application/vnd.astraea-software.iota": ["iota"],
+  "application/vnd.audiograph": ["aep"],
+  "application/vnd.autodesk.fbx": ["fbx"],
+  "application/vnd.balsamiq.bmml+xml": ["bmml"],
+  "application/vnd.blueice.multipass": ["mpm"],
+  "application/vnd.bmi": ["bmi"],
+  "application/vnd.businessobjects": ["rep"],
+  "application/vnd.chemdraw+xml": ["cdxml"],
+  "application/vnd.chipnuts.karaoke-mmd": ["mmd"],
+  "application/vnd.cinderella": ["cdy"],
+  "application/vnd.citationstyles.style+xml": ["csl"],
+  "application/vnd.claymore": ["cla"],
+  "application/vnd.cloanto.rp9": ["rp9"],
+  "application/vnd.clonk.c4group": ["c4g", "c4d", "c4f", "c4p", "c4u"],
+  "application/vnd.cluetrust.cartomobile-config": ["c11amc"],
+  "application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"],
+  "application/vnd.commonspace": ["csp"],
+  "application/vnd.contact.cmsg": ["cdbcmsg"],
+  "application/vnd.cosmocaller": ["cmc"],
+  "application/vnd.crick.clicker": ["clkx"],
+  "application/vnd.crick.clicker.keyboard": ["clkk"],
+  "application/vnd.crick.clicker.palette": ["clkp"],
+  "application/vnd.crick.clicker.template": ["clkt"],
+  "application/vnd.crick.clicker.wordbank": ["clkw"],
+  "application/vnd.criticaltools.wbs+xml": ["wbs"],
+  "application/vnd.ctc-posml": ["pml"],
+  "application/vnd.cups-ppd": ["ppd"],
+  "application/vnd.curl.car": ["car"],
+  "application/vnd.curl.pcurl": ["pcurl"],
+  "application/vnd.dart": ["dart"],
+  "application/vnd.data-vision.rdz": ["rdz"],
+  "application/vnd.dbf": ["dbf"],
+  "application/vnd.dcmp+xml": ["dcmp"],
+  "application/vnd.dece.data": ["uvf", "uvvf", "uvd", "uvvd"],
+  "application/vnd.dece.ttml+xml": ["uvt", "uvvt"],
+  "application/vnd.dece.unspecified": ["uvx", "uvvx"],
+  "application/vnd.dece.zip": ["uvz", "uvvz"],
+  "application/vnd.denovo.fcselayout-link": ["fe_launch"],
+  "application/vnd.dna": ["dna"],
+  "application/vnd.dolby.mlp": ["mlp"],
+  "application/vnd.dpgraph": ["dpg"],
+  "application/vnd.dreamfactory": ["dfac"],
+  "application/vnd.ds-keypoint": ["kpxx"],
+  "application/vnd.dvb.ait": ["ait"],
+  "application/vnd.dvb.service": ["svc"],
+  "application/vnd.dynageo": ["geo"],
+  "application/vnd.ecowin.chart": ["mag"],
+  "application/vnd.enliven": ["nml"],
+  "application/vnd.epson.esf": ["esf"],
+  "application/vnd.epson.msf": ["msf"],
+  "application/vnd.epson.quickanime": ["qam"],
+  "application/vnd.epson.salt": ["slt"],
+  "application/vnd.epson.ssf": ["ssf"],
+  "application/vnd.eszigno3+xml": ["es3", "et3"],
+  "application/vnd.ezpix-album": ["ez2"],
+  "application/vnd.ezpix-package": ["ez3"],
+  "application/vnd.fdf": ["*fdf"],
+  "application/vnd.fdsn.mseed": ["mseed"],
+  "application/vnd.fdsn.seed": ["seed", "dataless"],
+  "application/vnd.flographit": ["gph"],
+  "application/vnd.fluxtime.clip": ["ftc"],
+  "application/vnd.framemaker": ["fm", "frame", "maker", "book"],
+  "application/vnd.frogans.fnc": ["fnc"],
+  "application/vnd.frogans.ltf": ["ltf"],
+  "application/vnd.fsc.weblaunch": ["fsc"],
+  "application/vnd.fujitsu.oasys": ["oas"],
+  "application/vnd.fujitsu.oasys2": ["oa2"],
+  "application/vnd.fujitsu.oasys3": ["oa3"],
+  "application/vnd.fujitsu.oasysgp": ["fg5"],
+  "application/vnd.fujitsu.oasysprs": ["bh2"],
+  "application/vnd.fujixerox.ddd": ["ddd"],
+  "application/vnd.fujixerox.docuworks": ["xdw"],
+  "application/vnd.fujixerox.docuworks.binder": ["xbd"],
+  "application/vnd.fuzzysheet": ["fzs"],
+  "application/vnd.genomatix.tuxedo": ["txd"],
+  "application/vnd.geogebra.file": ["ggb"],
+  "application/vnd.geogebra.slides": ["ggs"],
+  "application/vnd.geogebra.tool": ["ggt"],
+  "application/vnd.geometry-explorer": ["gex", "gre"],
+  "application/vnd.geonext": ["gxt"],
+  "application/vnd.geoplan": ["g2w"],
+  "application/vnd.geospace": ["g3w"],
+  "application/vnd.gmx": ["gmx"],
+  "application/vnd.google-apps.document": ["gdoc"],
+  "application/vnd.google-apps.drawing": ["gdraw"],
+  "application/vnd.google-apps.form": ["gform"],
+  "application/vnd.google-apps.jam": ["gjam"],
+  "application/vnd.google-apps.map": ["gmap"],
+  "application/vnd.google-apps.presentation": ["gslides"],
+  "application/vnd.google-apps.script": ["gscript"],
+  "application/vnd.google-apps.site": ["gsite"],
+  "application/vnd.google-apps.spreadsheet": ["gsheet"],
+  "application/vnd.google-earth.kml+xml": ["kml"],
+  "application/vnd.google-earth.kmz": ["kmz"],
+  "application/vnd.gov.sk.xmldatacontainer+xml": ["xdcf"],
+  "application/vnd.grafeq": ["gqf", "gqs"],
+  "application/vnd.groove-account": ["gac"],
+  "application/vnd.groove-help": ["ghf"],
+  "application/vnd.groove-identity-message": ["gim"],
+  "application/vnd.groove-injector": ["grv"],
+  "application/vnd.groove-tool-message": ["gtm"],
+  "application/vnd.groove-tool-template": ["tpl"],
+  "application/vnd.groove-vcard": ["vcg"],
+  "application/vnd.hal+xml": ["hal"],
+  "application/vnd.handheld-entertainment+xml": ["zmm"],
+  "application/vnd.hbci": ["hbci"],
+  "application/vnd.hhe.lesson-player": ["les"],
+  "application/vnd.hp-hpgl": ["hpgl"],
+  "application/vnd.hp-hpid": ["hpid"],
+  "application/vnd.hp-hps": ["hps"],
+  "application/vnd.hp-jlyt": ["jlt"],
+  "application/vnd.hp-pcl": ["pcl"],
+  "application/vnd.hp-pclxl": ["pclxl"],
+  "application/vnd.hydrostatix.sof-data": ["sfd-hdstx"],
+  "application/vnd.ibm.minipay": ["mpy"],
+  "application/vnd.ibm.modcap": ["afp", "listafp", "list3820"],
+  "application/vnd.ibm.rights-management": ["irm"],
+  "application/vnd.ibm.secure-container": ["sc"],
+  "application/vnd.iccprofile": ["icc", "icm"],
+  "application/vnd.igloader": ["igl"],
+  "application/vnd.immervision-ivp": ["ivp"],
+  "application/vnd.immervision-ivu": ["ivu"],
+  "application/vnd.insors.igm": ["igm"],
+  "application/vnd.intercon.formnet": ["xpw", "xpx"],
+  "application/vnd.intergeo": ["i2g"],
+  "application/vnd.intu.qbo": ["qbo"],
+  "application/vnd.intu.qfx": ["qfx"],
+  "application/vnd.ipunplugged.rcprofile": ["rcprofile"],
+  "application/vnd.irepository.package+xml": ["irp"],
+  "application/vnd.is-xpr": ["xpr"],
+  "application/vnd.isac.fcs": ["fcs"],
+  "application/vnd.jam": ["jam"],
+  "application/vnd.jcp.javame.midlet-rms": ["rms"],
+  "application/vnd.jisp": ["jisp"],
+  "application/vnd.joost.joda-archive": ["joda"],
+  "application/vnd.kahootz": ["ktz", "ktr"],
+  "application/vnd.kde.karbon": ["karbon"],
+  "application/vnd.kde.kchart": ["chrt"],
+  "application/vnd.kde.kformula": ["kfo"],
+  "application/vnd.kde.kivio": ["flw"],
+  "application/vnd.kde.kontour": ["kon"],
+  "application/vnd.kde.kpresenter": ["kpr", "kpt"],
+  "application/vnd.kde.kspread": ["ksp"],
+  "application/vnd.kde.kword": ["kwd", "kwt"],
+  "application/vnd.kenameaapp": ["htke"],
+  "application/vnd.kidspiration": ["kia"],
+  "application/vnd.kinar": ["kne", "knp"],
+  "application/vnd.koan": ["skp", "skd", "skt", "skm"],
+  "application/vnd.kodak-descriptor": ["sse"],
+  "application/vnd.las.las+xml": ["lasxml"],
+  "application/vnd.llamagraphics.life-balance.desktop": ["lbd"],
+  "application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"],
+  "application/vnd.lotus-1-2-3": ["123"],
+  "application/vnd.lotus-approach": ["apr"],
+  "application/vnd.lotus-freelance": ["pre"],
+  "application/vnd.lotus-notes": ["nsf"],
+  "application/vnd.lotus-organizer": ["org"],
+  "application/vnd.lotus-screencam": ["scm"],
+  "application/vnd.lotus-wordpro": ["lwp"],
+  "application/vnd.macports.portpkg": ["portpkg"],
+  "application/vnd.mapbox-vector-tile": ["mvt"],
+  "application/vnd.mcd": ["mcd"],
+  "application/vnd.medcalcdata": ["mc1"],
+  "application/vnd.mediastation.cdkey": ["cdkey"],
+  "application/vnd.mfer": ["mwf"],
+  "application/vnd.mfmp": ["mfm"],
+  "application/vnd.micrografx.flo": ["flo"],
+  "application/vnd.micrografx.igx": ["igx"],
+  "application/vnd.mif": ["mif"],
+  "application/vnd.mobius.daf": ["daf"],
+  "application/vnd.mobius.dis": ["dis"],
+  "application/vnd.mobius.mbk": ["mbk"],
+  "application/vnd.mobius.mqy": ["mqy"],
+  "application/vnd.mobius.msl": ["msl"],
+  "application/vnd.mobius.plc": ["plc"],
+  "application/vnd.mobius.txf": ["txf"],
+  "application/vnd.mophun.application": ["mpn"],
+  "application/vnd.mophun.certificate": ["mpc"],
+  "application/vnd.mozilla.xul+xml": ["xul"],
+  "application/vnd.ms-artgalry": ["cil"],
+  "application/vnd.ms-cab-compressed": ["cab"],
+  "application/vnd.ms-excel": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"],
+  "application/vnd.ms-excel.addin.macroenabled.12": ["xlam"],
+  "application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"],
+  "application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"],
+  "application/vnd.ms-excel.template.macroenabled.12": ["xltm"],
+  "application/vnd.ms-fontobject": ["eot"],
+  "application/vnd.ms-htmlhelp": ["chm"],
+  "application/vnd.ms-ims": ["ims"],
+  "application/vnd.ms-lrm": ["lrm"],
+  "application/vnd.ms-officetheme": ["thmx"],
+  "application/vnd.ms-outlook": ["msg"],
+  "application/vnd.ms-pki.seccat": ["cat"],
+  "application/vnd.ms-pki.stl": ["*stl"],
+  "application/vnd.ms-powerpoint": ["ppt", "pps", "pot"],
+  "application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"],
+  "application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"],
+  "application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"],
+  "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"],
+  "application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"],
+  "application/vnd.ms-project": ["*mpp", "mpt"],
+  "application/vnd.ms-visio.viewer": ["vdx"],
+  "application/vnd.ms-word.document.macroenabled.12": ["docm"],
+  "application/vnd.ms-word.template.macroenabled.12": ["dotm"],
+  "application/vnd.ms-works": ["wps", "wks", "wcm", "wdb"],
+  "application/vnd.ms-wpl": ["wpl"],
+  "application/vnd.ms-xpsdocument": ["xps"],
+  "application/vnd.mseq": ["mseq"],
+  "application/vnd.musician": ["mus"],
+  "application/vnd.muvee.style": ["msty"],
+  "application/vnd.mynfc": ["taglet"],
+  "application/vnd.nato.bindingdataobject+xml": ["bdo"],
+  "application/vnd.neurolanguage.nlu": ["nlu"],
+  "application/vnd.nitf": ["ntf", "nitf"],
+  "application/vnd.noblenet-directory": ["nnd"],
+  "application/vnd.noblenet-sealer": ["nns"],
+  "application/vnd.noblenet-web": ["nnw"],
+  "application/vnd.nokia.n-gage.ac+xml": ["*ac"],
+  "application/vnd.nokia.n-gage.data": ["ngdat"],
+  "application/vnd.nokia.n-gage.symbian.install": ["n-gage"],
+  "application/vnd.nokia.radio-preset": ["rpst"],
+  "application/vnd.nokia.radio-presets": ["rpss"],
+  "application/vnd.novadigm.edm": ["edm"],
+  "application/vnd.novadigm.edx": ["edx"],
+  "application/vnd.novadigm.ext": ["ext"],
+  "application/vnd.oasis.opendocument.chart": ["odc"],
+  "application/vnd.oasis.opendocument.chart-template": ["otc"],
+  "application/vnd.oasis.opendocument.database": ["odb"],
+  "application/vnd.oasis.opendocument.formula": ["odf"],
+  "application/vnd.oasis.opendocument.formula-template": ["odft"],
+  "application/vnd.oasis.opendocument.graphics": ["odg"],
+  "application/vnd.oasis.opendocument.graphics-template": ["otg"],
+  "application/vnd.oasis.opendocument.image": ["odi"],
+  "application/vnd.oasis.opendocument.image-template": ["oti"],
+  "application/vnd.oasis.opendocument.presentation": ["odp"],
+  "application/vnd.oasis.opendocument.presentation-template": ["otp"],
+  "application/vnd.oasis.opendocument.spreadsheet": ["ods"],
+  "application/vnd.oasis.opendocument.spreadsheet-template": ["ots"],
+  "application/vnd.oasis.opendocument.text": ["odt"],
+  "application/vnd.oasis.opendocument.text-master": ["odm"],
+  "application/vnd.oasis.opendocument.text-template": ["ott"],
+  "application/vnd.oasis.opendocument.text-web": ["oth"],
+  "application/vnd.olpc-sugar": ["xo"],
+  "application/vnd.oma.dd2+xml": ["dd2"],
+  "application/vnd.openblox.game+xml": ["obgx"],
+  "application/vnd.openofficeorg.extension": ["oxt"],
+  "application/vnd.openstreetmap.data+xml": ["osm"],
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": [
+    "pptx"
+  ],
+  "application/vnd.openxmlformats-officedocument.presentationml.slide": [
+    "sldx"
+  ],
+  "application/vnd.openxmlformats-officedocument.presentationml.slideshow": [
+    "ppsx"
+  ],
+  "application/vnd.openxmlformats-officedocument.presentationml.template": [
+    "potx"
+  ],
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"],
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.template": [
+    "xltx"
+  ],
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": [
+    "docx"
+  ],
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.template": [
+    "dotx"
+  ],
+  "application/vnd.osgeo.mapguide.package": ["mgp"],
+  "application/vnd.osgi.dp": ["dp"],
+  "application/vnd.osgi.subsystem": ["esa"],
+  "application/vnd.palm": ["pdb", "pqa", "oprc"],
+  "application/vnd.pawaafile": ["paw"],
+  "application/vnd.pg.format": ["str"],
+  "application/vnd.pg.osasli": ["ei6"],
+  "application/vnd.picsel": ["efif"],
+  "application/vnd.pmi.widget": ["wg"],
+  "application/vnd.pocketlearn": ["plf"],
+  "application/vnd.powerbuilder6": ["pbd"],
+  "application/vnd.previewsystems.box": ["box"],
+  "application/vnd.procrate.brushset": ["brushset"],
+  "application/vnd.procreate.brush": ["brush"],
+  "application/vnd.procreate.dream": ["drm"],
+  "application/vnd.proteus.magazine": ["mgz"],
+  "application/vnd.publishare-delta-tree": ["qps"],
+  "application/vnd.pvi.ptid1": ["ptid"],
+  "application/vnd.pwg-xhtml-print+xml": ["xhtm"],
+  "application/vnd.quark.quarkxpress": [
+    "qxd",
+    "qxt",
+    "qwd",
+    "qwt",
+    "qxl",
+    "qxb"
+  ],
+  "application/vnd.rar": ["rar"],
+  "application/vnd.realvnc.bed": ["bed"],
+  "application/vnd.recordare.musicxml": ["mxl"],
+  "application/vnd.recordare.musicxml+xml": ["musicxml"],
+  "application/vnd.rig.cryptonote": ["cryptonote"],
+  "application/vnd.rim.cod": ["cod"],
+  "application/vnd.rn-realmedia": ["rm"],
+  "application/vnd.rn-realmedia-vbr": ["rmvb"],
+  "application/vnd.route66.link66+xml": ["link66"],
+  "application/vnd.sailingtracker.track": ["st"],
+  "application/vnd.seemail": ["see"],
+  "application/vnd.sema": ["sema"],
+  "application/vnd.semd": ["semd"],
+  "application/vnd.semf": ["semf"],
+  "application/vnd.shana.informed.formdata": ["ifm"],
+  "application/vnd.shana.informed.formtemplate": ["itp"],
+  "application/vnd.shana.informed.interchange": ["iif"],
+  "application/vnd.shana.informed.package": ["ipk"],
+  "application/vnd.simtech-mindmapper": ["twd", "twds"],
+  "application/vnd.smaf": ["mmf"],
+  "application/vnd.smart.teacher": ["teacher"],
+  "application/vnd.software602.filler.form+xml": ["fo"],
+  "application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"],
+  "application/vnd.spotfire.dxp": ["dxp"],
+  "application/vnd.spotfire.sfs": ["sfs"],
+  "application/vnd.stardivision.calc": ["sdc"],
+  "application/vnd.stardivision.draw": ["sda"],
+  "application/vnd.stardivision.impress": ["sdd"],
+  "application/vnd.stardivision.math": ["smf"],
+  "application/vnd.stardivision.writer": ["sdw", "vor"],
+  "application/vnd.stardivision.writer-global": ["sgl"],
+  "application/vnd.stepmania.package": ["smzip"],
+  "application/vnd.stepmania.stepchart": ["sm"],
+  "application/vnd.sun.wadl+xml": ["wadl"],
+  "application/vnd.sun.xml.calc": ["sxc"],
+  "application/vnd.sun.xml.calc.template": ["stc"],
+  "application/vnd.sun.xml.draw": ["sxd"],
+  "application/vnd.sun.xml.draw.template": ["std"],
+  "application/vnd.sun.xml.impress": ["sxi"],
+  "application/vnd.sun.xml.impress.template": ["sti"],
+  "application/vnd.sun.xml.math": ["sxm"],
+  "application/vnd.sun.xml.writer": ["sxw"],
+  "application/vnd.sun.xml.writer.global": ["sxg"],
+  "application/vnd.sun.xml.writer.template": ["stw"],
+  "application/vnd.sus-calendar": ["sus", "susp"],
+  "application/vnd.svd": ["svd"],
+  "application/vnd.symbian.install": ["sis", "sisx"],
+  "application/vnd.syncml+xml": ["xsm"],
+  "application/vnd.syncml.dm+wbxml": ["bdm"],
+  "application/vnd.syncml.dm+xml": ["xdm"],
+  "application/vnd.syncml.dmddf+xml": ["ddf"],
+  "application/vnd.tao.intent-module-archive": ["tao"],
+  "application/vnd.tcpdump.pcap": ["pcap", "cap", "dmp"],
+  "application/vnd.tmobile-livetv": ["tmo"],
+  "application/vnd.trid.tpt": ["tpt"],
+  "application/vnd.triscape.mxs": ["mxs"],
+  "application/vnd.trueapp": ["tra"],
+  "application/vnd.ufdl": ["ufd", "ufdl"],
+  "application/vnd.uiq.theme": ["utz"],
+  "application/vnd.umajin": ["umj"],
+  "application/vnd.unity": ["unityweb"],
+  "application/vnd.uoml+xml": ["uoml", "uo"],
+  "application/vnd.vcx": ["vcx"],
+  "application/vnd.visio": ["vsd", "vst", "vss", "vsw", "vsdx", "vtx"],
+  "application/vnd.visionary": ["vis"],
+  "application/vnd.vsf": ["vsf"],
+  "application/vnd.wap.wbxml": ["wbxml"],
+  "application/vnd.wap.wmlc": ["wmlc"],
+  "application/vnd.wap.wmlscriptc": ["wmlsc"],
+  "application/vnd.webturbo": ["wtb"],
+  "application/vnd.wolfram.player": ["nbp"],
+  "application/vnd.wordperfect": ["wpd"],
+  "application/vnd.wqd": ["wqd"],
+  "application/vnd.wt.stf": ["stf"],
+  "application/vnd.xara": ["xar"],
+  "application/vnd.xfdl": ["xfdl"],
+  "application/vnd.yamaha.hv-dic": ["hvd"],
+  "application/vnd.yamaha.hv-script": ["hvs"],
+  "application/vnd.yamaha.hv-voice": ["hvp"],
+  "application/vnd.yamaha.openscoreformat": ["osf"],
+  "application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"],
+  "application/vnd.yamaha.smaf-audio": ["saf"],
+  "application/vnd.yamaha.smaf-phrase": ["spf"],
+  "application/vnd.yellowriver-custom-menu": ["cmp"],
+  "application/vnd.zul": ["zir", "zirz"],
+  "application/vnd.zzazz.deck+xml": ["zaz"],
+  "application/x-7z-compressed": ["7z"],
+  "application/x-abiword": ["abw"],
+  "application/x-ace-compressed": ["ace"],
+  "application/x-apple-diskimage": ["*dmg"],
+  "application/x-arj": ["arj"],
+  "application/x-authorware-bin": ["aab", "x32", "u32", "vox"],
+  "application/x-authorware-map": ["aam"],
+  "application/x-authorware-seg": ["aas"],
+  "application/x-bcpio": ["bcpio"],
+  "application/x-bdoc": ["*bdoc"],
+  "application/x-bittorrent": ["torrent"],
+  "application/x-blender": ["blend"],
+  "application/x-blorb": ["blb", "blorb"],
+  "application/x-bzip": ["bz"],
+  "application/x-bzip2": ["bz2", "boz"],
+  "application/x-cbr": ["cbr", "cba", "cbt", "cbz", "cb7"],
+  "application/x-cdlink": ["vcd"],
+  "application/x-cfs-compressed": ["cfs"],
+  "application/x-chat": ["chat"],
+  "application/x-chess-pgn": ["pgn"],
+  "application/x-chrome-extension": ["crx"],
+  "application/x-cocoa": ["cco"],
+  "application/x-compressed": ["*rar"],
+  "application/x-conference": ["nsc"],
+  "application/x-cpio": ["cpio"],
+  "application/x-csh": ["csh"],
+  "application/x-debian-package": ["*deb", "udeb"],
+  "application/x-dgc-compressed": ["dgc"],
+  "application/x-director": [
+    "dir",
+    "dcr",
+    "dxr",
+    "cst",
+    "cct",
+    "cxt",
+    "w3d",
+    "fgd",
+    "swa"
+  ],
+  "application/x-doom": ["wad"],
+  "application/x-dtbncx+xml": ["ncx"],
+  "application/x-dtbook+xml": ["dtb"],
+  "application/x-dtbresource+xml": ["res"],
+  "application/x-dvi": ["dvi"],
+  "application/x-envoy": ["evy"],
+  "application/x-eva": ["eva"],
+  "application/x-font-bdf": ["bdf"],
+  "application/x-font-ghostscript": ["gsf"],
+  "application/x-font-linux-psf": ["psf"],
+  "application/x-font-pcf": ["pcf"],
+  "application/x-font-snf": ["snf"],
+  "application/x-font-type1": ["pfa", "pfb", "pfm", "afm"],
+  "application/x-freearc": ["arc"],
+  "application/x-futuresplash": ["spl"],
+  "application/x-gca-compressed": ["gca"],
+  "application/x-glulx": ["ulx"],
+  "application/x-gnumeric": ["gnumeric"],
+  "application/x-gramps-xml": ["gramps"],
+  "application/x-gtar": ["gtar"],
+  "application/x-hdf": ["hdf"],
+  "application/x-httpd-php": ["php"],
+  "application/x-install-instructions": ["install"],
+  "application/x-ipynb+json": ["ipynb"],
+  "application/x-iso9660-image": ["*iso"],
+  "application/x-iwork-keynote-sffkey": ["*key"],
+  "application/x-iwork-numbers-sffnumbers": ["*numbers"],
+  "application/x-iwork-pages-sffpages": ["*pages"],
+  "application/x-java-archive-diff": ["jardiff"],
+  "application/x-java-jnlp-file": ["jnlp"],
+  "application/x-keepass2": ["kdbx"],
+  "application/x-latex": ["latex"],
+  "application/x-lua-bytecode": ["luac"],
+  "application/x-lzh-compressed": ["lzh", "lha"],
+  "application/x-makeself": ["run"],
+  "application/x-mie": ["mie"],
+  "application/x-mobipocket-ebook": ["*prc", "mobi"],
+  "application/x-ms-application": ["application"],
+  "application/x-ms-shortcut": ["lnk"],
+  "application/x-ms-wmd": ["wmd"],
+  "application/x-ms-wmz": ["wmz"],
+  "application/x-ms-xbap": ["xbap"],
+  "application/x-msaccess": ["mdb"],
+  "application/x-msbinder": ["obd"],
+  "application/x-mscardfile": ["crd"],
+  "application/x-msclip": ["clp"],
+  "application/x-msdos-program": ["*exe"],
+  "application/x-msdownload": ["*exe", "*dll", "com", "bat", "*msi"],
+  "application/x-msmediaview": ["mvb", "m13", "m14"],
+  "application/x-msmetafile": ["*wmf", "*wmz", "*emf", "emz"],
+  "application/x-msmoney": ["mny"],
+  "application/x-mspublisher": ["pub"],
+  "application/x-msschedule": ["scd"],
+  "application/x-msterminal": ["trm"],
+  "application/x-mswrite": ["wri"],
+  "application/x-netcdf": ["nc", "cdf"],
+  "application/x-ns-proxy-autoconfig": ["pac"],
+  "application/x-nzb": ["nzb"],
+  "application/x-perl": ["pl", "pm"],
+  "application/x-pilot": ["*prc", "*pdb"],
+  "application/x-pkcs12": ["p12", "pfx"],
+  "application/x-pkcs7-certificates": ["p7b", "spc"],
+  "application/x-pkcs7-certreqresp": ["p7r"],
+  "application/x-rar-compressed": ["*rar"],
+  "application/x-redhat-package-manager": ["rpm"],
+  "application/x-research-info-systems": ["ris"],
+  "application/x-sea": ["sea"],
+  "application/x-sh": ["sh"],
+  "application/x-shar": ["shar"],
+  "application/x-shockwave-flash": ["swf"],
+  "application/x-silverlight-app": ["xap"],
+  "application/x-sql": ["*sql"],
+  "application/x-stuffit": ["sit"],
+  "application/x-stuffitx": ["sitx"],
+  "application/x-subrip": ["srt"],
+  "application/x-sv4cpio": ["sv4cpio"],
+  "application/x-sv4crc": ["sv4crc"],
+  "application/x-t3vm-image": ["t3"],
+  "application/x-tads": ["gam"],
+  "application/x-tar": ["tar"],
+  "application/x-tcl": ["tcl", "tk"],
+  "application/x-tex": ["tex"],
+  "application/x-tex-tfm": ["tfm"],
+  "application/x-texinfo": ["texinfo", "texi"],
+  "application/x-tgif": ["*obj"],
+  "application/x-ustar": ["ustar"],
+  "application/x-virtualbox-hdd": ["hdd"],
+  "application/x-virtualbox-ova": ["ova"],
+  "application/x-virtualbox-ovf": ["ovf"],
+  "application/x-virtualbox-vbox": ["vbox"],
+  "application/x-virtualbox-vbox-extpack": ["vbox-extpack"],
+  "application/x-virtualbox-vdi": ["vdi"],
+  "application/x-virtualbox-vhd": ["vhd"],
+  "application/x-virtualbox-vmdk": ["vmdk"],
+  "application/x-wais-source": ["src"],
+  "application/x-web-app-manifest+json": ["webapp"],
+  "application/x-x509-ca-cert": ["der", "crt", "pem"],
+  "application/x-xfig": ["fig"],
+  "application/x-xliff+xml": ["*xlf"],
+  "application/x-xpinstall": ["xpi"],
+  "application/x-xz": ["xz"],
+  "application/x-zip-compressed": ["*zip"],
+  "application/x-zmachine": ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"],
+  "audio/vnd.dece.audio": ["uva", "uvva"],
+  "audio/vnd.digital-winds": ["eol"],
+  "audio/vnd.dra": ["dra"],
+  "audio/vnd.dts": ["dts"],
+  "audio/vnd.dts.hd": ["dtshd"],
+  "audio/vnd.lucent.voice": ["lvp"],
+  "audio/vnd.ms-playready.media.pya": ["pya"],
+  "audio/vnd.nuera.ecelp4800": ["ecelp4800"],
+  "audio/vnd.nuera.ecelp7470": ["ecelp7470"],
+  "audio/vnd.nuera.ecelp9600": ["ecelp9600"],
+  "audio/vnd.rip": ["rip"],
+  "audio/x-aac": ["*aac"],
+  "audio/x-aiff": ["aif", "aiff", "aifc"],
+  "audio/x-caf": ["caf"],
+  "audio/x-flac": ["flac"],
+  "audio/x-m4a": ["*m4a"],
+  "audio/x-matroska": ["mka"],
+  "audio/x-mpegurl": ["m3u"],
+  "audio/x-ms-wax": ["wax"],
+  "audio/x-ms-wma": ["wma"],
+  "audio/x-pn-realaudio": ["ram", "ra"],
+  "audio/x-pn-realaudio-plugin": ["rmp"],
+  "audio/x-realaudio": ["*ra"],
+  "audio/x-wav": ["*wav"],
+  "chemical/x-cdx": ["cdx"],
+  "chemical/x-cif": ["cif"],
+  "chemical/x-cmdf": ["cmdf"],
+  "chemical/x-cml": ["cml"],
+  "chemical/x-csml": ["csml"],
+  "chemical/x-xyz": ["xyz"],
+  "image/prs.btif": ["btif", "btf"],
+  "image/prs.pti": ["pti"],
+  "image/vnd.adobe.photoshop": ["psd"],
+  "image/vnd.airzip.accelerator.azv": ["azv"],
+  "image/vnd.dece.graphic": ["uvi", "uvvi", "uvg", "uvvg"],
+  "image/vnd.djvu": ["djvu", "djv"],
+  "image/vnd.dvb.subtitle": ["*sub"],
+  "image/vnd.dwg": ["dwg"],
+  "image/vnd.dxf": ["dxf"],
+  "image/vnd.fastbidsheet": ["fbs"],
+  "image/vnd.fpx": ["fpx"],
+  "image/vnd.fst": ["fst"],
+  "image/vnd.fujixerox.edmics-mmr": ["mmr"],
+  "image/vnd.fujixerox.edmics-rlc": ["rlc"],
+  "image/vnd.microsoft.icon": ["ico"],
+  "image/vnd.ms-dds": ["dds"],
+  "image/vnd.ms-modi": ["mdi"],
+  "image/vnd.ms-photo": ["wdp"],
+  "image/vnd.net-fpx": ["npx"],
+  "image/vnd.pco.b16": ["b16"],
+  "image/vnd.tencent.tap": ["tap"],
+  "image/vnd.valve.source.texture": ["vtf"],
+  "image/vnd.wap.wbmp": ["wbmp"],
+  "image/vnd.xiff": ["xif"],
+  "image/vnd.zbrush.pcx": ["pcx"],
+  "image/x-3ds": ["3ds"],
+  "image/x-adobe-dng": ["dng"],
+  "image/x-cmu-raster": ["ras"],
+  "image/x-cmx": ["cmx"],
+  "image/x-freehand": ["fh", "fhc", "fh4", "fh5", "fh7"],
+  "image/x-icon": ["*ico"],
+  "image/x-jng": ["jng"],
+  "image/x-mrsid-image": ["sid"],
+  "image/x-ms-bmp": ["*bmp"],
+  "image/x-pcx": ["*pcx"],
+  "image/x-pict": ["pic", "pct"],
+  "image/x-portable-anymap": ["pnm"],
+  "image/x-portable-bitmap": ["pbm"],
+  "image/x-portable-graymap": ["pgm"],
+  "image/x-portable-pixmap": ["ppm"],
+  "image/x-rgb": ["rgb"],
+  "image/x-tga": ["tga"],
+  "image/x-xbitmap": ["xbm"],
+  "image/x-xpixmap": ["xpm"],
+  "image/x-xwindowdump": ["xwd"],
+  "message/vnd.wfa.wsc": ["wsc"],
+  "model/vnd.bary": ["bary"],
+  "model/vnd.cld": ["cld"],
+  "model/vnd.collada+xml": ["dae"],
+  "model/vnd.dwf": ["dwf"],
+  "model/vnd.gdl": ["gdl"],
+  "model/vnd.gtw": ["gtw"],
+  "model/vnd.mts": ["*mts"],
+  "model/vnd.opengex": ["ogex"],
+  "model/vnd.parasolid.transmit.binary": ["x_b"],
+  "model/vnd.parasolid.transmit.text": ["x_t"],
+  "model/vnd.pytha.pyox": ["pyo", "pyox"],
+  "model/vnd.sap.vds": ["vds"],
+  "model/vnd.usda": ["usda"],
+  "model/vnd.usdz+zip": ["usdz"],
+  "model/vnd.valve.source.compiled-map": ["bsp"],
+  "model/vnd.vtu": ["vtu"],
+  "text/prs.lines.tag": ["dsc"],
+  "text/vnd.curl": ["curl"],
+  "text/vnd.curl.dcurl": ["dcurl"],
+  "text/vnd.curl.mcurl": ["mcurl"],
+  "text/vnd.curl.scurl": ["scurl"],
+  "text/vnd.dvb.subtitle": ["sub"],
+  "text/vnd.familysearch.gedcom": ["ged"],
+  "text/vnd.fly": ["fly"],
+  "text/vnd.fmi.flexstor": ["flx"],
+  "text/vnd.graphviz": ["gv"],
+  "text/vnd.in3d.3dml": ["3dml"],
+  "text/vnd.in3d.spot": ["spot"],
+  "text/vnd.sun.j2me.app-descriptor": ["jad"],
+  "text/vnd.wap.wml": ["wml"],
+  "text/vnd.wap.wmlscript": ["wmls"],
+  "text/x-asm": ["s", "asm"],
+  "text/x-c": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"],
+  "text/x-component": ["htc"],
+  "text/x-fortran": ["f", "for", "f77", "f90"],
+  "text/x-handlebars-template": ["hbs"],
+  "text/x-java-source": ["java"],
+  "text/x-lua": ["lua"],
+  "text/x-markdown": ["mkd"],
+  "text/x-nfo": ["nfo"],
+  "text/x-opml": ["opml"],
+  "text/x-org": ["*org"],
+  "text/x-pascal": ["p", "pas"],
+  "text/x-processing": ["pde"],
+  "text/x-sass": ["sass"],
+  "text/x-scss": ["scss"],
+  "text/x-setext": ["etx"],
+  "text/x-sfv": ["sfv"],
+  "text/x-suse-ymp": ["ymp"],
+  "text/x-uuencode": ["uu"],
+  "text/x-vcalendar": ["vcs"],
+  "text/x-vcard": ["vcf"],
+  "video/vnd.dece.hd": ["uvh", "uvvh"],
+  "video/vnd.dece.mobile": ["uvm", "uvvm"],
+  "video/vnd.dece.pd": ["uvp", "uvvp"],
+  "video/vnd.dece.sd": ["uvs", "uvvs"],
+  "video/vnd.dece.video": ["uvv", "uvvv"],
+  "video/vnd.dvb.file": ["dvb"],
+  "video/vnd.fvt": ["fvt"],
+  "video/vnd.mpegurl": ["mxu", "m4u"],
+  "video/vnd.ms-playready.media.pyv": ["pyv"],
+  "video/vnd.uvvu.mp4": ["uvu", "uvvu"],
+  "video/vnd.vivo": ["viv"],
+  "video/x-f4v": ["f4v"],
+  "video/x-fli": ["fli"],
+  "video/x-flv": ["flv"],
+  "video/x-m4v": ["m4v"],
+  "video/x-matroska": ["mkv", "mk3d", "mks"],
+  "video/x-mng": ["mng"],
+  "video/x-ms-asf": ["asf", "asx"],
+  "video/x-ms-vob": ["vob"],
+  "video/x-ms-wm": ["wm"],
+  "video/x-ms-wmv": ["wmv"],
+  "video/x-ms-wmx": ["wmx"],
+  "video/x-ms-wvx": ["wvx"],
+  "video/x-msvideo": ["avi"],
+  "video/x-sgi-movie": ["movie"],
+  "video/x-smv": ["smv"],
+  "x-conference/x-cooltalk": ["ice"]
+};
+Object.freeze(types);
+var other_default = types;
+
+// ../../node_modules/.pnpm/mime@4.0.7/node_modules/mime/dist/types/standard.js
+var types2 = {
+  "application/andrew-inset": ["ez"],
+  "application/appinstaller": ["appinstaller"],
+  "application/applixware": ["aw"],
+  "application/appx": ["appx"],
+  "application/appxbundle": ["appxbundle"],
+  "application/atom+xml": ["atom"],
+  "application/atomcat+xml": ["atomcat"],
+  "application/atomdeleted+xml": ["atomdeleted"],
+  "application/atomsvc+xml": ["atomsvc"],
+  "application/atsc-dwd+xml": ["dwd"],
+  "application/atsc-held+xml": ["held"],
+  "application/atsc-rsat+xml": ["rsat"],
+  "application/automationml-aml+xml": ["aml"],
+  "application/automationml-amlx+zip": ["amlx"],
+  "application/bdoc": ["bdoc"],
+  "application/calendar+xml": ["xcs"],
+  "application/ccxml+xml": ["ccxml"],
+  "application/cdfx+xml": ["cdfx"],
+  "application/cdmi-capability": ["cdmia"],
+  "application/cdmi-container": ["cdmic"],
+  "application/cdmi-domain": ["cdmid"],
+  "application/cdmi-object": ["cdmio"],
+  "application/cdmi-queue": ["cdmiq"],
+  "application/cpl+xml": ["cpl"],
+  "application/cu-seeme": ["cu"],
+  "application/cwl": ["cwl"],
+  "application/dash+xml": ["mpd"],
+  "application/dash-patch+xml": ["mpp"],
+  "application/davmount+xml": ["davmount"],
+  "application/dicom": ["dcm"],
+  "application/docbook+xml": ["dbk"],
+  "application/dssc+der": ["dssc"],
+  "application/dssc+xml": ["xdssc"],
+  "application/ecmascript": ["ecma"],
+  "application/emma+xml": ["emma"],
+  "application/emotionml+xml": ["emotionml"],
+  "application/epub+zip": ["epub"],
+  "application/exi": ["exi"],
+  "application/express": ["exp"],
+  "application/fdf": ["fdf"],
+  "application/fdt+xml": ["fdt"],
+  "application/font-tdpfr": ["pfr"],
+  "application/geo+json": ["geojson"],
+  "application/gml+xml": ["gml"],
+  "application/gpx+xml": ["gpx"],
+  "application/gxf": ["gxf"],
+  "application/gzip": ["gz"],
+  "application/hjson": ["hjson"],
+  "application/hyperstudio": ["stk"],
+  "application/inkml+xml": ["ink", "inkml"],
+  "application/ipfix": ["ipfix"],
+  "application/its+xml": ["its"],
+  "application/java-archive": ["jar", "war", "ear"],
+  "application/java-serialized-object": ["ser"],
+  "application/java-vm": ["class"],
+  "application/javascript": ["*js"],
+  "application/json": ["json", "map"],
+  "application/json5": ["json5"],
+  "application/jsonml+json": ["jsonml"],
+  "application/ld+json": ["jsonld"],
+  "application/lgr+xml": ["lgr"],
+  "application/lost+xml": ["lostxml"],
+  "application/mac-binhex40": ["hqx"],
+  "application/mac-compactpro": ["cpt"],
+  "application/mads+xml": ["mads"],
+  "application/manifest+json": ["webmanifest"],
+  "application/marc": ["mrc"],
+  "application/marcxml+xml": ["mrcx"],
+  "application/mathematica": ["ma", "nb", "mb"],
+  "application/mathml+xml": ["mathml"],
+  "application/mbox": ["mbox"],
+  "application/media-policy-dataset+xml": ["mpf"],
+  "application/mediaservercontrol+xml": ["mscml"],
+  "application/metalink+xml": ["metalink"],
+  "application/metalink4+xml": ["meta4"],
+  "application/mets+xml": ["mets"],
+  "application/mmt-aei+xml": ["maei"],
+  "application/mmt-usd+xml": ["musd"],
+  "application/mods+xml": ["mods"],
+  "application/mp21": ["m21", "mp21"],
+  "application/mp4": ["*mp4", "*mpg4", "mp4s", "m4p"],
+  "application/msix": ["msix"],
+  "application/msixbundle": ["msixbundle"],
+  "application/msword": ["doc", "dot"],
+  "application/mxf": ["mxf"],
+  "application/n-quads": ["nq"],
+  "application/n-triples": ["nt"],
+  "application/node": ["cjs"],
+  "application/octet-stream": [
+    "bin",
+    "dms",
+    "lrf",
+    "mar",
+    "so",
+    "dist",
+    "distz",
+    "pkg",
+    "bpk",
+    "dump",
+    "elc",
+    "deploy",
+    "exe",
+    "dll",
+    "deb",
+    "dmg",
+    "iso",
+    "img",
+    "msi",
+    "msp",
+    "msm",
+    "buffer"
+  ],
+  "application/oda": ["oda"],
+  "application/oebps-package+xml": ["opf"],
+  "application/ogg": ["ogx"],
+  "application/omdoc+xml": ["omdoc"],
+  "application/onenote": [
+    "onetoc",
+    "onetoc2",
+    "onetmp",
+    "onepkg",
+    "one",
+    "onea"
+  ],
+  "application/oxps": ["oxps"],
+  "application/p2p-overlay+xml": ["relo"],
+  "application/patch-ops-error+xml": ["xer"],
+  "application/pdf": ["pdf"],
+  "application/pgp-encrypted": ["pgp"],
+  "application/pgp-keys": ["asc"],
+  "application/pgp-signature": ["sig", "*asc"],
+  "application/pics-rules": ["prf"],
+  "application/pkcs10": ["p10"],
+  "application/pkcs7-mime": ["p7m", "p7c"],
+  "application/pkcs7-signature": ["p7s"],
+  "application/pkcs8": ["p8"],
+  "application/pkix-attr-cert": ["ac"],
+  "application/pkix-cert": ["cer"],
+  "application/pkix-crl": ["crl"],
+  "application/pkix-pkipath": ["pkipath"],
+  "application/pkixcmp": ["pki"],
+  "application/pls+xml": ["pls"],
+  "application/postscript": ["ai", "eps", "ps"],
+  "application/provenance+xml": ["provx"],
+  "application/pskc+xml": ["pskcxml"],
+  "application/raml+yaml": ["raml"],
+  "application/rdf+xml": ["rdf", "owl"],
+  "application/reginfo+xml": ["rif"],
+  "application/relax-ng-compact-syntax": ["rnc"],
+  "application/resource-lists+xml": ["rl"],
+  "application/resource-lists-diff+xml": ["rld"],
+  "application/rls-services+xml": ["rs"],
+  "application/route-apd+xml": ["rapd"],
+  "application/route-s-tsid+xml": ["sls"],
+  "application/route-usd+xml": ["rusd"],
+  "application/rpki-ghostbusters": ["gbr"],
+  "application/rpki-manifest": ["mft"],
+  "application/rpki-roa": ["roa"],
+  "application/rsd+xml": ["rsd"],
+  "application/rss+xml": ["rss"],
+  "application/rtf": ["rtf"],
+  "application/sbml+xml": ["sbml"],
+  "application/scvp-cv-request": ["scq"],
+  "application/scvp-cv-response": ["scs"],
+  "application/scvp-vp-request": ["spq"],
+  "application/scvp-vp-response": ["spp"],
+  "application/sdp": ["sdp"],
+  "application/senml+xml": ["senmlx"],
+  "application/sensml+xml": ["sensmlx"],
+  "application/set-payment-initiation": ["setpay"],
+  "application/set-registration-initiation": ["setreg"],
+  "application/shf+xml": ["shf"],
+  "application/sieve": ["siv", "sieve"],
+  "application/smil+xml": ["smi", "smil"],
+  "application/sparql-query": ["rq"],
+  "application/sparql-results+xml": ["srx"],
+  "application/sql": ["sql"],
+  "application/srgs": ["gram"],
+  "application/srgs+xml": ["grxml"],
+  "application/sru+xml": ["sru"],
+  "application/ssdl+xml": ["ssdl"],
+  "application/ssml+xml": ["ssml"],
+  "application/swid+xml": ["swidtag"],
+  "application/tei+xml": ["tei", "teicorpus"],
+  "application/thraud+xml": ["tfi"],
+  "application/timestamped-data": ["tsd"],
+  "application/toml": ["toml"],
+  "application/trig": ["trig"],
+  "application/ttml+xml": ["ttml"],
+  "application/ubjson": ["ubj"],
+  "application/urc-ressheet+xml": ["rsheet"],
+  "application/urc-targetdesc+xml": ["td"],
+  "application/voicexml+xml": ["vxml"],
+  "application/wasm": ["wasm"],
+  "application/watcherinfo+xml": ["wif"],
+  "application/widget": ["wgt"],
+  "application/winhlp": ["hlp"],
+  "application/wsdl+xml": ["wsdl"],
+  "application/wspolicy+xml": ["wspolicy"],
+  "application/xaml+xml": ["xaml"],
+  "application/xcap-att+xml": ["xav"],
+  "application/xcap-caps+xml": ["xca"],
+  "application/xcap-diff+xml": ["xdf"],
+  "application/xcap-el+xml": ["xel"],
+  "application/xcap-ns+xml": ["xns"],
+  "application/xenc+xml": ["xenc"],
+  "application/xfdf": ["xfdf"],
+  "application/xhtml+xml": ["xhtml", "xht"],
+  "application/xliff+xml": ["xlf"],
+  "application/xml": ["xml", "xsl", "xsd", "rng"],
+  "application/xml-dtd": ["dtd"],
+  "application/xop+xml": ["xop"],
+  "application/xproc+xml": ["xpl"],
+  "application/xslt+xml": ["*xsl", "xslt"],
+  "application/xspf+xml": ["xspf"],
+  "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"],
+  "application/yang": ["yang"],
+  "application/yin+xml": ["yin"],
+  "application/zip": ["zip"],
+  "application/zip+dotlottie": ["lottie"],
+  "audio/3gpp": ["*3gpp"],
+  "audio/aac": ["adts", "aac"],
+  "audio/adpcm": ["adp"],
+  "audio/amr": ["amr"],
+  "audio/basic": ["au", "snd"],
+  "audio/midi": ["mid", "midi", "kar", "rmi"],
+  "audio/mobile-xmf": ["mxmf"],
+  "audio/mp3": ["*mp3"],
+  "audio/mp4": ["m4a", "mp4a", "m4b"],
+  "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"],
+  "audio/ogg": ["oga", "ogg", "spx", "opus"],
+  "audio/s3m": ["s3m"],
+  "audio/silk": ["sil"],
+  "audio/wav": ["wav"],
+  "audio/wave": ["*wav"],
+  "audio/webm": ["weba"],
+  "audio/xm": ["xm"],
+  "font/collection": ["ttc"],
+  "font/otf": ["otf"],
+  "font/ttf": ["ttf"],
+  "font/woff": ["woff"],
+  "font/woff2": ["woff2"],
+  "image/aces": ["exr"],
+  "image/apng": ["apng"],
+  "image/avci": ["avci"],
+  "image/avcs": ["avcs"],
+  "image/avif": ["avif"],
+  "image/bmp": ["bmp", "dib"],
+  "image/cgm": ["cgm"],
+  "image/dicom-rle": ["drle"],
+  "image/dpx": ["dpx"],
+  "image/emf": ["emf"],
+  "image/fits": ["fits"],
+  "image/g3fax": ["g3"],
+  "image/gif": ["gif"],
+  "image/heic": ["heic"],
+  "image/heic-sequence": ["heics"],
+  "image/heif": ["heif"],
+  "image/heif-sequence": ["heifs"],
+  "image/hej2k": ["hej2"],
+  "image/ief": ["ief"],
+  "image/jaii": ["jaii"],
+  "image/jais": ["jais"],
+  "image/jls": ["jls"],
+  "image/jp2": ["jp2", "jpg2"],
+  "image/jpeg": ["jpg", "jpeg", "jpe"],
+  "image/jph": ["jph"],
+  "image/jphc": ["jhc"],
+  "image/jpm": ["jpm", "jpgm"],
+  "image/jpx": ["jpx", "jpf"],
+  "image/jxl": ["jxl"],
+  "image/jxr": ["jxr"],
+  "image/jxra": ["jxra"],
+  "image/jxrs": ["jxrs"],
+  "image/jxs": ["jxs"],
+  "image/jxsc": ["jxsc"],
+  "image/jxsi": ["jxsi"],
+  "image/jxss": ["jxss"],
+  "image/ktx": ["ktx"],
+  "image/ktx2": ["ktx2"],
+  "image/pjpeg": ["jfif"],
+  "image/png": ["png"],
+  "image/sgi": ["sgi"],
+  "image/svg+xml": ["svg", "svgz"],
+  "image/t38": ["t38"],
+  "image/tiff": ["tif", "tiff"],
+  "image/tiff-fx": ["tfx"],
+  "image/webp": ["webp"],
+  "image/wmf": ["wmf"],
+  "message/disposition-notification": ["disposition-notification"],
+  "message/global": ["u8msg"],
+  "message/global-delivery-status": ["u8dsn"],
+  "message/global-disposition-notification": ["u8mdn"],
+  "message/global-headers": ["u8hdr"],
+  "message/rfc822": ["eml", "mime", "mht", "mhtml"],
+  "model/3mf": ["3mf"],
+  "model/gltf+json": ["gltf"],
+  "model/gltf-binary": ["glb"],
+  "model/iges": ["igs", "iges"],
+  "model/jt": ["jt"],
+  "model/mesh": ["msh", "mesh", "silo"],
+  "model/mtl": ["mtl"],
+  "model/obj": ["obj"],
+  "model/prc": ["prc"],
+  "model/step": ["step", "stp", "stpnc", "p21", "210"],
+  "model/step+xml": ["stpx"],
+  "model/step+zip": ["stpz"],
+  "model/step-xml+zip": ["stpxz"],
+  "model/stl": ["stl"],
+  "model/u3d": ["u3d"],
+  "model/vrml": ["wrl", "vrml"],
+  "model/x3d+binary": ["*x3db", "x3dbz"],
+  "model/x3d+fastinfoset": ["x3db"],
+  "model/x3d+vrml": ["*x3dv", "x3dvz"],
+  "model/x3d+xml": ["x3d", "x3dz"],
+  "model/x3d-vrml": ["x3dv"],
+  "text/cache-manifest": ["appcache", "manifest"],
+  "text/calendar": ["ics", "ifb"],
+  "text/coffeescript": ["coffee", "litcoffee"],
+  "text/css": ["css"],
+  "text/csv": ["csv"],
+  "text/html": ["html", "htm", "shtml"],
+  "text/jade": ["jade"],
+  "text/javascript": ["js", "mjs"],
+  "text/jsx": ["jsx"],
+  "text/less": ["less"],
+  "text/markdown": ["md", "markdown"],
+  "text/mathml": ["mml"],
+  "text/mdx": ["mdx"],
+  "text/n3": ["n3"],
+  "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"],
+  "text/richtext": ["rtx"],
+  "text/rtf": ["*rtf"],
+  "text/sgml": ["sgml", "sgm"],
+  "text/shex": ["shex"],
+  "text/slim": ["slim", "slm"],
+  "text/spdx": ["spdx"],
+  "text/stylus": ["stylus", "styl"],
+  "text/tab-separated-values": ["tsv"],
+  "text/troff": ["t", "tr", "roff", "man", "me", "ms"],
+  "text/turtle": ["ttl"],
+  "text/uri-list": ["uri", "uris", "urls"],
+  "text/vcard": ["vcard"],
+  "text/vtt": ["vtt"],
+  "text/wgsl": ["wgsl"],
+  "text/xml": ["*xml"],
+  "text/yaml": ["yaml", "yml"],
+  "video/3gpp": ["3gp", "3gpp"],
+  "video/3gpp2": ["3g2"],
+  "video/h261": ["h261"],
+  "video/h263": ["h263"],
+  "video/h264": ["h264"],
+  "video/iso.segment": ["m4s"],
+  "video/jpeg": ["jpgv"],
+  "video/jpm": ["*jpm", "*jpgm"],
+  "video/mj2": ["mj2", "mjp2"],
+  "video/mp2t": ["ts", "m2t", "m2ts", "mts"],
+  "video/mp4": ["mp4", "mp4v", "mpg4"],
+  "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"],
+  "video/ogg": ["ogv"],
+  "video/quicktime": ["qt", "mov"],
+  "video/webm": ["webm"]
+};
+Object.freeze(types2);
+var standard_default = types2;
+
+// ../../node_modules/.pnpm/mime@4.0.7/node_modules/mime/dist/src/Mime.js
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Mime_extensionToType;
+var _Mime_typeToExtension;
+var _Mime_typeToExtensions;
+var Mime = class {
+  static {
+    __name(this, "Mime");
+  }
+  constructor(...args) {
+    _Mime_extensionToType.set(this, /* @__PURE__ */ new Map());
+    _Mime_typeToExtension.set(this, /* @__PURE__ */ new Map());
+    _Mime_typeToExtensions.set(this, /* @__PURE__ */ new Map());
+    for (const arg of args) {
+      this.define(arg);
+    }
+  }
+  define(typeMap, force = false) {
+    for (let [type, extensions] of Object.entries(typeMap)) {
+      type = type.toLowerCase();
+      extensions = extensions.map((ext) => ext.toLowerCase());
+      if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type)) {
+        __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type, /* @__PURE__ */ new Set());
+      }
+      const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type);
+      let first = true;
+      for (let extension of extensions) {
+        const starred = extension.startsWith("*");
+        extension = starred ? extension.slice(1) : extension;
+        allExtensions?.add(extension);
+        if (first) {
+          __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type, extension);
+        }
+        first = false;
+        if (starred)
+          continue;
+        const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension);
+        if (currentType && currentType != type && !force) {
+          throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
+        }
+        __classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension, type);
+      }
+    }
+    return this;
+  }
+  getType(path8) {
+    if (typeof path8 !== "string")
+      return null;
+    const last = path8.replace(/^.*[/\\]/s, "").toLowerCase();
+    const ext = last.replace(/^.*\./s, "").toLowerCase();
+    const hasPath = last.length < path8.length;
+    const hasDot = ext.length < last.length - 1;
+    if (!hasDot && hasPath)
+      return null;
+    return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
+  }
+  getExtension(type) {
+    if (typeof type !== "string")
+      return null;
+    type = type?.split?.(";")[0];
+    return (type && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type.trim().toLowerCase())) ?? null;
+  }
+  getAllExtensions(type) {
+    if (typeof type !== "string")
+      return null;
+    return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type.toLowerCase()) ?? null;
+  }
+  _freeze() {
+    this.define = () => {
+      throw new Error("define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances");
+    };
+    Object.freeze(this);
+    for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) {
+      Object.freeze(extensions);
+    }
+    return this;
+  }
+  _getTestState() {
+    return {
+      types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
+      extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f")
+    };
+  }
+};
+_Mime_extensionToType = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtension = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtensions = /* @__PURE__ */ new WeakMap();
+var Mime_default = Mime;
+
+// ../../node_modules/.pnpm/mime@4.0.7/node_modules/mime/dist/src/index.js
+var src_default = new Mime_default(standard_default, other_default)._freeze();
+
+// ../workers-shared/utils/helpers.ts
+var normalizeFilePath = /* @__PURE__ */ __name((relativeFilepath) => {
+  if (isAbsolute(relativeFilepath)) {
+    throw new Error(`Expected relative path`);
+  }
+  return "/" + relativeFilepath.split(sep).join("/");
+}, "normalizeFilePath");
+var getContentType = /* @__PURE__ */ __name((absFilePath) => {
+  let contentType = src_default.getType(absFilePath);
+  if (contentType && contentType.startsWith("text/") && !contentType.includes("charset")) {
+    contentType = `${contentType}; charset=utf-8`;
+  }
+  return contentType;
+}, "getContentType");
+function createPatternMatcher(patterns, exclude) {
+  if (patterns.length === 0) {
+    return (_filePath) => !exclude;
+  } else {
+    const ignorer = (0, import_ignore.default)().add(patterns);
+    return (filePath) => ignorer.test(filePath).ignored;
+  }
+}
+__name(createPatternMatcher, "createPatternMatcher");
+function thrownIsDoesNotExistError(thrown) {
+  return thrown instanceof Error && "code" in thrown && thrown.code === "ENOENT";
+}
+__name(thrownIsDoesNotExistError, "thrownIsDoesNotExistError");
+function maybeGetFile(filePath) {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch (e) {
+    if (!thrownIsDoesNotExistError(e)) {
+      throw e;
+    }
+  }
+}
+__name(maybeGetFile, "maybeGetFile");
+async function createAssetsIgnoreFunction(dir) {
+  const cfAssetIgnorePath = resolve(dir, CF_ASSETS_IGNORE_FILENAME);
+  const ignorePatterns = [
+    // Ignore the `.assetsignore` file and other metafiles by default.
+    // The ignore lib expects unix-style paths for its patterns
+    `/${CF_ASSETS_IGNORE_FILENAME}`,
+    `/${REDIRECTS_FILENAME}`,
+    `/${HEADERS_FILENAME}`
+  ];
+  let assetsIgnoreFilePresent = false;
+  const assetsIgnore = maybeGetFile(cfAssetIgnorePath);
+  if (assetsIgnore !== void 0) {
+    assetsIgnoreFilePresent = true;
+    ignorePatterns.push(...assetsIgnore.split("\n"));
+  }
+  return {
+    assetsIgnoreFunction: createPatternMatcher(ignorePatterns, true),
+    assetsIgnoreFilePresent
+  };
+}
+__name(createAssetsIgnoreFunction, "createAssetsIgnoreFunction");
 var hashFile = /* @__PURE__ */ __name((filepath) => {
   const contents = readFileSync(filepath);
   const base64Contents = contents.toString("base64");
@@ -3579,7 +6446,7 @@ var syncAssets = /* @__PURE__ */ __name(async (complianceConfig, accountId, asse
       const payload = new FormData();
       const uploadedFiles = [];
       for (const manifestEntry of bucket) {
-        const absFilePath = path5.join(assetDirectory, manifestEntry[0]);
+        const absFilePath = path.join(assetDirectory, manifestEntry[0]);
         uploadedFiles.push(manifestEntry[0]);
         payload.append(
           manifestEntry[1].hash,
@@ -3692,7 +6559,7 @@ var buildAssetManifest = /* @__PURE__ */ __name(async (dir) => {
         logger.debug("Ignoring asset:", relativeFilepath);
         return;
       }
-      const filepath = path5.join(dir, relativeFilepath);
+      const filepath = path.join(dir, relativeFilepath);
       const filestat = await stat(filepath);
       if (filestat.isSymbolicLink() || filestat.isDirectory()) {
         return;
@@ -3773,6 +6640,53 @@ If you do want to upload this ${workerJsType}, you can add an empty "${CF_ASSETS
   }
 }
 __name(errorOnLegacyPagesWorkerJSAsset, "errorOnLegacyPagesWorkerJSAsset");
+function resolveAssetOptions({ assetsDir, main }, config) {
+  if (!assetsDir) {
+    return void 0;
+  }
+  const { directory, binding, directoryExists } = assetsDir;
+  const routerConfig = {
+    has_user_worker: main !== void 0
+  };
+  if (typeof config.assets?.run_worker_first === "boolean") {
+    routerConfig.invoke_user_worker_ahead_of_assets = config.assets.run_worker_first;
+  } else if (Array.isArray(config.assets?.run_worker_first)) {
+    routerConfig.static_routing = parseStaticRouting(
+      config.assets.run_worker_first
+    );
+  }
+  if (routerConfig.invoke_user_worker_ahead_of_assets && !config?.assets?.binding) {
+    logger.warn(
+      "run_worker_first=true set without an assets binding\nSetting run_worker_first to true will always invoke your Worker script.\nTo fetch your assets from your Worker, please set the [assets.binding] key in your configuration file.\n\nRead more: https://developers.cloudflare.com/workers/static-assets/binding/#binding"
+    );
+  }
+  if (!routerConfig.has_user_worker && (routerConfig.invoke_user_worker_ahead_of_assets === true || routerConfig.static_routing)) {
+    throw new UserError(
+      "Cannot set run_worker_first without a Worker script.\nPlease remove run_worker_first from your configuration file, or provide a Worker script in your configuration file (`main`).",
+      { telemetryMessage: "assets router missing worker script" }
+    );
+  }
+  const _redirects = directoryExists ? maybeGetFile(path.join(directory, REDIRECTS_FILENAME)) : void 0;
+  const _headers = directoryExists ? maybeGetFile(path.join(directory, HEADERS_FILENAME)) : void 0;
+  const assetConfig = {
+    html_handling: config.assets?.html_handling,
+    not_found_handling: config.assets?.not_found_handling,
+    // The _redirects and _headers files are parsed in Miniflare in dev and parsing is not required for deploy
+    compatibility_date: config.compatibility_date,
+    compatibility_flags: config.compatibility_flags
+  };
+  return {
+    directory,
+    binding,
+    routerConfig,
+    assetConfig,
+    _redirects,
+    _headers,
+    // raw static routing rules for upload. routerConfig.static_routing contains the rules processed for dev.
+    run_worker_first: config.assets?.run_worker_first
+  };
+}
+__name(resolveAssetOptions, "resolveAssetOptions");
 
 // src/deploy/helpers/binding-utils.ts
 function assertNever(_value) {
@@ -5612,14 +8526,14 @@ function createWorkerUploadForm(worker, bindings, options) {
   if (hasManifest && main.type === "esm") {
     assert6(modules !== void 0);
     const subDirs = new Set(
-      modules.map((module) => path5__default.posix.dirname(module.name))
+      modules.map((module) => path__default.posix.dirname(module.name))
     );
     for (const subDir of subDirs) {
       if (subDir === ".") {
         continue;
       }
-      const relativePath = path5__default.posix.relative(subDir, manifestModuleName);
-      const filePath = path5__default.posix.join(subDir, manifestModuleName);
+      const relativePath = path__default.posix.relative(subDir, manifestModuleName);
+      const filePath = path__default.posix.join(subDir, manifestModuleName);
       modules.push({
         name: filePath,
         filePath,
@@ -5983,9 +8897,9 @@ function dedent(templ) {
     });
   }
   strings[0] = strings[0].replace(/^\r?\n/, "");
-  var string = strings[0];
+  var string2 = strings[0];
   values.forEach(function(value, i) {
-    var endentations = string.match(/(?:^|\n)( *)$/);
+    var endentations = string2.match(/(?:^|\n)( *)$/);
     var endentation = endentations ? endentations[1] : "";
     var indentedValue = value;
     if (typeof value === "string" && value.includes("\n")) {
@@ -5993,9 +8907,9 @@ function dedent(templ) {
         return i2 === 0 ? str : "" + endentation + str;
       }).join("\n");
     }
-    string += indentedValue + strings[i + 1];
+    string2 += indentedValue + strings[i + 1];
   });
-  return string;
+  return string2;
 }
 __name(dedent, "dedent");
 var esm_default = dedent;
@@ -6050,9 +8964,9 @@ async function diagnoseStartupError(err, workerBundle, projectRoot, analyseBundl
       "startup-profile",
       false
     );
-    const profile = path5__default.relative(
+    const profile = path__default.relative(
       projectRoot ?? process.cwd(),
-      path5__default.join(tmpDir.path, `worker.cpuprofile`)
+      path__default.join(tmpDir.path, `worker.cpuprofile`)
     );
     await writeFile(profile, JSON.stringify(cpuProfile));
     errorMessage += esm_default`
@@ -6203,7 +9117,7 @@ async function parseBulkInputToObject(input, includeNull = false) {
   let secretFormat;
   if (input) {
     secretSource = "file";
-    const jsonFilePath = path5__default.resolve(input);
+    const jsonFilePath = path__default.resolve(input);
     const fileContent = readFileSync$1(jsonFilePath);
     try {
       content = parseJSON(fileContent);
@@ -7152,130 +10066,67 @@ See https://developers.cloudflare.com/workers/configuration/secrets/#secrets-on-
   }
 }
 __name(handleMissingSecretsError, "handleMissingSecretsError");
-function loadSourceMaps(main, modules, bundle) {
-  const { sourceMapPath, sourceMapMetadata } = bundle;
-  if (sourceMapPath && sourceMapMetadata) {
-    return loadSourceMap(main, sourceMapPath, sourceMapMetadata);
-  } else {
-    return scanSourceMaps([main, ...modules]);
-  }
-}
-__name(loadSourceMaps, "loadSourceMaps");
-function loadSourceMap({ name, filePath }, sourceMapPath, { entryDirectory }) {
-  if (filePath === void 0) {
-    return [];
-  }
-  const map = JSON.parse(
-    fs.readFileSync(path5__default.join(entryDirectory, sourceMapPath), "utf8")
-  );
-  map.file = name;
-  if (map.sourceRoot) {
-    const sourceRootPath = path5__default.dirname(
-      path5__default.join(entryDirectory, sourceMapPath)
-    );
-    map.sourceRoot = path5__default.relative(sourceRootPath, map.sourceRoot);
-  }
-  map.sources = map.sources.map((source) => {
-    const originalPath = path5__default.join(path5__default.dirname(filePath), source);
-    return path5__default.relative(entryDirectory, originalPath);
-  });
-  return [
-    {
-      name: name + ".map",
-      content: JSON.stringify(map)
-    }
-  ];
-}
-__name(loadSourceMap, "loadSourceMap");
-function scanSourceMaps(modules) {
-  const maps = [];
-  for (const module of modules) {
-    const maybeSourcemap = sourceMapForModule(module);
-    if (maybeSourcemap) {
-      maps.push(maybeSourcemap);
-    }
-  }
-  return maps;
-}
-__name(scanSourceMaps, "scanSourceMaps");
-function tryAttachSourcemapToModule(module) {
-  if (module.type !== "esm" && module.type !== "commonjs") {
-    return;
-  }
-  const sourceMap = sourceMapForModule(module);
-  if (sourceMap) {
-    module.sourceMap = sourceMap;
-  }
-}
-__name(tryAttachSourcemapToModule, "tryAttachSourcemapToModule");
-function getSourceMappingUrl(module) {
-  const content = typeof module.content === "string" ? module.content : new TextDecoder().decode(module.content);
-  const commentPrefix = "//# sourceMappingURL=";
-  const lines = content.split("\n");
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i].trim();
-    if (line.length === 0) {
-      continue;
-    }
-    if (line.startsWith(commentPrefix)) {
-      const commentPath = stripPrefix(commentPrefix, line).trim();
-      if (commentPath.startsWith("data:")) {
-        throw new Error(
-          `Unsupported source map path in ${module.filePath}: expected file path but found data URL.`
-        );
-      }
-      return commentPath;
-    }
-    if (!line.startsWith("//#") && !line.startsWith("//@")) {
-      return void 0;
-    }
-  }
-  return void 0;
-}
-__name(getSourceMappingUrl, "getSourceMappingUrl");
-function sourceMapForModule(module) {
-  if (module.filePath === void 0) {
-    return void 0;
-  }
-  const sourceMapUrl = getSourceMappingUrl(module);
-  if (sourceMapUrl === void 0) {
-    return;
-  }
-  const sourcemapPath = path5__default.join(path5__default.dirname(module.filePath), sourceMapUrl);
-  if (!fs.existsSync(sourcemapPath)) {
-    throw new Error(
-      `Invalid source map path in ${module.filePath}: ${sourcemapPath} does not exist.`
-    );
-  }
-  const map = JSON.parse(
-    fs.readFileSync(sourcemapPath, "utf8")
-  );
-  map.file = module.name;
-  if (map.sourceRoot) {
-    map.sourceRoot = cleanPathPrefix(map.sourceRoot);
-  }
-  map.sources = map.sources.map(cleanPathPrefix);
-  return {
-    name: module.name + ".map",
-    content: JSON.stringify(map)
-  };
-}
-__name(sourceMapForModule, "sourceMapForModule");
-function cleanPathPrefix(filePath) {
-  return stripPrefix(
-    "..\\",
-    stripPrefix("../", stripPrefix(".\\", stripPrefix("./", filePath)))
-  );
-}
-__name(cleanPathPrefix, "cleanPathPrefix");
-function stripPrefix(prefix, input) {
-  let stripped = input;
-  while (stripped.startsWith(prefix)) {
-    stripped = stripped.slice(prefix.length);
-  }
-  return stripped;
-}
-__name(stripPrefix, "stripPrefix");
+var InternalConfigSchema = z$1.object({
+  account_id: z$1.number().optional(),
+  script_id: z$1.number().optional(),
+  debug: z$1.boolean().optional()
+});
+var StaticRoutingSchema = z$1.object({
+  user_worker: z$1.array(z$1.string()),
+  asset_worker: z$1.array(z$1.string()).optional()
+});
+z$1.object({
+  invoke_user_worker_ahead_of_assets: z$1.boolean().optional(),
+  static_routing: StaticRoutingSchema.optional(),
+  has_user_worker: z$1.boolean().optional(),
+  ...InternalConfigSchema.shape
+});
+z$1.union([
+  z$1.object({
+    limitedAssetsOnly: z$1.boolean().optional()
+  }),
+  z$1.null()
+]);
+var MetadataStaticRedirectEntry = z$1.object({
+  status: z$1.number(),
+  to: z$1.string(),
+  lineNumber: z$1.number()
+});
+var MetadataRedirectEntry = z$1.object({
+  status: z$1.number(),
+  to: z$1.string()
+});
+var MetadataStaticRedirects = z$1.record(MetadataStaticRedirectEntry);
+var MetadataRedirects = z$1.record(MetadataRedirectEntry);
+var MetadataHeaderEntry = z$1.object({
+  set: z$1.record(z$1.string()).optional(),
+  unset: z$1.array(z$1.string()).optional()
+});
+var MetadataHeaders = z$1.record(MetadataHeaderEntry);
+var RedirectsSchema = z$1.object({
+  version: z$1.literal(1),
+  staticRules: MetadataStaticRedirects,
+  rules: MetadataRedirects
+}).optional();
+var HeadersSchema = z$1.object({
+  version: z$1.literal(2),
+  rules: MetadataHeaders
+}).optional();
+z$1.object({
+  compatibility_date: z$1.string().optional(),
+  compatibility_flags: z$1.array(z$1.string()).optional(),
+  html_handling: z$1.enum([
+    "auto-trailing-slash",
+    "force-trailing-slash",
+    "drop-trailing-slash",
+    "none"
+  ]).optional(),
+  not_found_handling: z$1.enum(["single-page-application", "404-page", "none"]).optional(),
+  redirects: RedirectsSchema,
+  headers: HeadersSchema,
+  has_static_routing: z$1.boolean().optional(),
+  ...InternalConfigSchema.shape
+});
 function maybeRetrieveFileSourceMap(filePath) {
   if (filePath === void 0) {
     return null;
@@ -7324,8 +10175,8 @@ function getSourceMappingPrepareStackTrace(retrieveSourceMap) {
     // Make sure we're using fresh copies of files each time we source map
     emptyCacheBetweenOperations: true,
     // Allow retriever to be overridden at prepare stack trace time
-    retrieveSourceMap(path9) {
-      return retrieveSourceMapOverride?.(path9) ?? null;
+    retrieveSourceMap(path8) {
+      return retrieveSourceMapOverride?.(path8) ?? null;
     }
   });
   sourceMappingPrepareStackTrace = Error.prepareStackTrace;
@@ -7548,13 +10399,13 @@ var validateRoutes = /* @__PURE__ */ __name((routes, assets) => {
     );
   }
   if (mountedAssetRoutes.length > 0 && assets?.directory !== void 0) {
-    const relativeAssetsDir = path5__default.relative(process.cwd(), assets.directory);
+    const relativeAssetsDir = path__default.relative(process.cwd(), assets.directory);
     const warnFn = logger.once?.warn ?? logger.warn;
     warnFn(
       `Warning: The following routes will attempt to serve Assets on a configured path:
 ${mountedAssetRoutes.map((route) => {
         const routeNoScheme = route.replace(/https?:\/\//g, "");
-        const assetPath = path5__default.join(
+        const assetPath = path__default.join(
           relativeAssetsDir,
           routeNoScheme.substring(routeNoScheme.indexOf("/"))
         );
@@ -7597,9 +10448,9 @@ async function deploy(props, config, buildResult, callbacks) {
     compatibilityDate,
     compatibilityFlags,
     keepVars,
-    uploadSourceMaps,
     accountId
   } = props;
+  const assetsOptions = resolveAssetOptions(props, config);
   if (!props.dryRun) {
     assert6(accountId, "Missing account ID");
     await verifyWorkerMatchesCITag(config, accountId, name, config.configPath);
@@ -7713,7 +10564,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       { telemetryMessage: "missing compatibility date when deploying" }
     );
   }
-  validateRoutes(allDeploymentRoutes, props.assetsOptions);
+  validateRoutes(allDeploymentRoutes, assetsOptions);
   const scriptName = name;
   assert6(
     !config.site || config.site.bucket,
@@ -7769,7 +10620,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     resolvedEntryPointPath,
     bundleType,
     content,
-    bundle
+    sourceMaps
   } = buildResult;
   const migrations = !isDryRun ? await getMigrationsToUpload(scriptName, {
     accountId,
@@ -7778,15 +10629,15 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     env: props.env,
     dispatchNamespace: props.dispatchNamespace
   }) : void 0;
-  const assetsJwt = props.assetsOptions && !isDryRun ? await syncAssets(
+  const assetsJwt = assetsOptions && !isDryRun ? await syncAssets(
     config,
     accountId,
-    props.assetsOptions.directory,
+    assetsOptions.directory,
     scriptName,
     props.dispatchNamespace
   ) : void 0;
-  if (props.assetsOptions && isDryRun) {
-    await buildAssetManifest(props.assetsOptions.directory);
+  if (assetsOptions && isDryRun) {
+    await buildAssetManifest(assetsOptions.directory);
   }
   const workersSitesAssets = callbacks.syncWorkersSite ? await callbacks.syncWorkersSite(
     config,
@@ -7835,7 +10686,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     });
   }
   const placement = parseConfigPlacement(config);
-  const entryPointName = path5__default.basename(resolvedEntryPointPath);
+  const entryPointName = path__default.basename(resolvedEntryPointPath);
   const main = {
     name: entryPointName,
     filePath: resolvedEntryPointPath,
@@ -7848,7 +10699,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     migrations,
     modules,
     containers: config.containers,
-    sourceMaps: uploadSourceMaps ? loadSourceMaps(main, modules, bundle) : void 0,
+    sourceMaps,
     compatibility_date: compatibilityDate,
     compatibility_flags: compatibilityFlags,
     keepVars,
@@ -7862,13 +10713,13 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       "workers/message": props.message,
       "workers/tag": props.tag
     } : void 0,
-    assets: props.assetsOptions && assetsJwt ? {
+    assets: assetsOptions && assetsJwt ? {
       jwt: assetsJwt,
-      routerConfig: props.assetsOptions.routerConfig,
-      assetConfig: props.assetsOptions.assetConfig,
-      _redirects: props.assetsOptions._redirects,
-      _headers: props.assetsOptions._headers,
-      run_worker_first: props.assetsOptions.run_worker_first
+      routerConfig: assetsOptions.routerConfig,
+      assetConfig: assetsOptions.assetConfig,
+      _redirects: assetsOptions._redirects,
+      _headers: assetsOptions._headers,
+      run_worker_first: assetsOptions.run_worker_first
     } : void 0,
     observability: config.observability,
     cache: config.cache
@@ -7878,7 +10729,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     0
   );
   await printBundleSize(
-    { name: path5__default.basename(resolvedEntryPointPath), content },
+    { name: path__default.basename(resolvedEntryPointPath), content },
     modules
   );
   const canUseNewVersionsDeploymentsApi = workerExists && props.dispatchNamespace === void 0 && !useServiceEnvironments2 && format === "modules" && migrations === void 0 && !config.first_party_worker && config.containers === void 0;
@@ -7932,7 +10783,9 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     );
   } else {
     assert6(accountId, "Missing accountId");
-    if (props.resourcesProvision && callbacks.provisionBindings) {
+    if (assetsOptions?.routerConfig.has_user_worker === false) {
+      logger.debug("skipping provisioning on assets-only project");
+    } else if (props.resourcesProvision && callbacks.provisionBindings) {
       await callbacks.provisionBindings(
         bindings ?? {},
         accountId,
@@ -8124,7 +10977,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     }
   }
   if (props.outfile) {
-    mkdirSync(path5__default.dirname(props.outfile), { recursive: true });
+    mkdirSync(path__default.dirname(props.outfile), { recursive: true });
     const serializedFormData = await new Response(workerBundle).arrayBuffer();
     writeFileSync(props.outfile, Buffer.from(serializedFormData));
   }
@@ -8179,9 +11032,9 @@ async function versionsUpload(props, config, buildResult, callbacks) {
     compatibilityDate,
     compatibilityFlags,
     keepVars,
-    uploadSourceMaps,
     accountId
   } = props;
+  const assetsOptions = resolveAssetOptions(props, config);
   if (!props.dryRun) {
     assert6(accountId, "Missing account ID");
     await verifyWorkerMatchesCITag(config, accountId, name, config.configPath);
@@ -8286,7 +11139,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     resolvedEntryPointPath,
     bundleType,
     content,
-    bundle
+    sourceMaps
   } = buildResult;
   const bindings = getBindings(config);
   for (const [bindingName, value] of Object.entries(props.cliVars)) {
@@ -8303,12 +11156,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     env: props.env,
     dispatchNamespace: void 0
   }) : void 0;
-  const assetsJwt = props.assetsOptions && !props.dryRun ? await syncAssets(
-    config,
-    accountId,
-    props.assetsOptions.directory,
-    scriptName
-  ) : void 0;
+  const assetsJwt = assetsOptions && !props.dryRun ? await syncAssets(config, accountId, assetsOptions.directory, scriptName) : void 0;
   if (props.secretsFile) {
     const secretsResult = await parseBulkInputToObject(props.secretsFile);
     if (secretsResult) {
@@ -8324,7 +11172,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   }
   addRequiredSecretsInheritBindings(config, bindings, { type: "upload" });
   const placement = parseConfigPlacement(config);
-  const entryPointName = path5__default.basename(resolvedEntryPointPath);
+  const entryPointName = path__default.basename(resolvedEntryPointPath);
   const main = {
     name: entryPointName,
     filePath: resolvedEntryPointPath,
@@ -8336,7 +11184,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     migrations,
     modules,
     containers: config.containers,
-    sourceMaps: uploadSourceMaps ? loadSourceMaps(main, modules, bundle) : void 0,
+    sourceMaps,
     compatibility_date: compatibilityDate,
     compatibility_flags: compatibilityFlags,
     keepVars,
@@ -8351,13 +11199,13 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       "workers/tag": props.tag,
       "workers/alias": props.previewAlias
     },
-    assets: props.assetsOptions && assetsJwt ? {
+    assets: assetsOptions && assetsJwt ? {
       jwt: assetsJwt,
-      routerConfig: props.assetsOptions.routerConfig,
-      assetConfig: props.assetsOptions.assetConfig,
-      _redirects: props.assetsOptions._redirects,
-      _headers: props.assetsOptions._headers,
-      run_worker_first: props.assetsOptions.run_worker_first
+      routerConfig: assetsOptions.routerConfig,
+      assetConfig: assetsOptions.assetConfig,
+      _redirects: assetsOptions._redirects,
+      _headers: assetsOptions._headers,
+      run_worker_first: assetsOptions.run_worker_first
     } : void 0,
     logpush: void 0,
     // logpush and observability are non-versioned settings
@@ -8371,7 +11219,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     );
   }
   await printBundleSize(
-    { name: path5__default.basename(resolvedEntryPointPath), content },
+    { name: path__default.basename(resolvedEntryPointPath), content },
     modules
   );
   let workerBundle;
@@ -8389,7 +11237,9 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     );
   } else {
     assert6(accountId, "Missing accountId");
-    if (props.resourcesProvision && callbacks.provisionBindings) {
+    if (assetsOptions?.routerConfig.has_user_worker === false) {
+      logger.debug("skipping provisioning on assets-only project");
+    } else if (props.resourcesProvision && callbacks.provisionBindings) {
       await callbacks.provisionBindings(
         bindings,
         accountId,
@@ -8483,7 +11333,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     }
   }
   if (props.outfile) {
-    mkdirSync(path5__default.dirname(props.outfile), { recursive: true });
+    mkdirSync(path__default.dirname(props.outfile), { recursive: true });
     const serializedFormData = await new Response(workerBundle).arrayBuffer();
     writeFileSync(props.outfile, Buffer.from(serializedFormData));
   }
@@ -8639,4 +11489,4 @@ __name(validateNodeCompatMode, "validateNodeCompatMode");
  *  THE SOFTWARE.
  */
 
-export { INVALID_INHERIT_BINDING_CODE, NoInputError, WORKER_LEGACY_ENVIRONMENT_NOT_FOUND_ERR_CODE, WORKER_NOT_FOUND_ERR_CODE, WORKFLOW_NOT_FOUND_CODE, addRequiredSecretsInheritBindings, addWorkersSitesBindings, applyServiceAndEnvironmentTags, buildAssetManifest, checkRemoteSecretsOverride, checkWorkflowConflicts, confirmLatestDeploymentOverwrite, convertConfigToBindings, createDeployment, createTruncatedAlias, createWorkerUploadForm, deletePullConsumer, deleteWorkerConsumer, deploy, deployWfpUserWorker, diagnoseScriptSizeError, diagnoseStartupError, diffJsonObjects, downloadWorkerConfig, ensureQueuesExistByConfig, extractBindingsOfType, fetchDeployableVersions, fetchDeploymentVersions, fetchLatestDeployment, fetchLatestDeployments, fetchSecrets, fetchVersion, fetchVersions, fetchWorkerConfig, fromMimeType, generatePreviewAlias, getBindings, getBranchName, getConfigPatch, getDeployConfirmFunction, getMigrationsToUpload, getQueue, getRemoteConfigDiff, getSourceMappedStack, getSourceMappedString, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, handleMissingSecretsError, handleUnsafeCapnp, hasDefinedEnvironments, hashFile, helpIfErrorIsSizeOrScriptStartup, isJwtExpired, isModifiedDiffValue, isNonDestructive, isUnsafeBindingType, isWorkerNotFoundError, listConsumers, listQueues, loadSourceMaps, maybeRetrieveFileSourceMap, moduleTypeMimeType, parseBulkInputToObject, parseConfigPlacement, patchNonVersionedScriptSettings, postConsumer, printBindings, printBundleSize, printVersions, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, sanitizeBranchName, syncAssets, tagsAreEqual, triggersDeploy, tryAttachSourcemapToModule, updateQueueConsumers, useServiceEnvironments, validateFileSecrets, validateNodeCompatMode, validateRoutes, verifyWorkerMatchesCITag, versionsUpload, warnOnErrorUpdatingServiceAndEnvironmentTags, warnOrError, workerNotFoundErrorMessage };
+export { INVALID_INHERIT_BINDING_CODE, InputWorkerSchema, NoInputError, OutputWorkerSchema, WORKER_LEGACY_ENVIRONMENT_NOT_FOUND_ERR_CODE, WORKER_NOT_FOUND_ERR_CODE, WORKFLOW_NOT_FOUND_CODE, addRequiredSecretsInheritBindings, addWorkersSitesBindings, applyServiceAndEnvironmentTags, buildAssetManifest, checkRemoteSecretsOverride, checkWorkflowConflicts, confirmLatestDeploymentOverwrite, convertConfigToBindings, convertToWranglerConfig, createDeployment, createTruncatedAlias, createWorkerUploadForm, deletePullConsumer, deleteWorkerConsumer, deploy, deployWfpUserWorker, diagnoseScriptSizeError, diagnoseStartupError, diffJsonObjects, downloadWorkerConfig, ensureQueuesExistByConfig, extractBindingsOfType, fetchDeployableVersions, fetchDeploymentVersions, fetchLatestDeployment, fetchLatestDeployments, fetchSecrets, fetchVersion, fetchVersions, fetchWorkerConfig, fromMimeType, generatePreviewAlias, getBindings, getBranchName, getConfigPatch, getDeployConfirmFunction, getMigrationsToUpload, getQueue, getRemoteConfigDiff, getSourceMappedStack, getSourceMappedString, getSubdomainValues, getSubdomainValuesAPIMock, getWorkersDevSubdomain, getZoneForRoute, getZoneIdFromHost, handleMissingSecretsError, handleUnsafeCapnp, hasDefinedEnvironments, hashFile, helpIfErrorIsSizeOrScriptStartup, isJwtExpired, isModifiedDiffValue, isNonDestructive, isUnsafeBindingType, isWorkerNotFoundError, listConsumers, listQueues, maybeRetrieveFileSourceMap, moduleTypeMimeType, parseBulkInputToObject, parseConfigPlacement, patchNonVersionedScriptSettings, postConsumer, printBindings, printBundleSize, printVersions, publishCustomDomains, publishRoutes, putConsumer, putConsumerById, renderRoute, resolveAssetOptions, sanitizeBranchName, syncAssets, tagsAreEqual, triggersDeploy, updateQueueConsumers, useServiceEnvironments, validateFileSecrets, validateNodeCompatMode, validateRoutes, verifyWorkerMatchesCITag, versionsUpload, warnOnErrorUpdatingServiceAndEnvironmentTags, warnOrError, workerNotFoundErrorMessage };