wrangler 0.0.0-e178d6fb → 0.0.0-e1c2f5b9

package/miniflare-dist/index.mjs

@@ -11,9 +11,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,7 +29,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // ../../node_modules/mime/Mime.js
 var require_Mime = __commonJS({
@@ -50,7 +60,9 @@ var require_Mime = __commonJS({
             continue;
           }
           if (!force && ext in this._types) {
-            throw new Error('Attempt to change mapping for "' + ext + '" extension from "' + this._types[ext] + '" to "' + type + '". Pass `force=true` to allow this, otherwise remove "' + ext + '" from the list of extensions for "' + type + '".');
+            throw new Error(
+              'Attempt to change mapping for "' + ext + '" extension from "' + this._types[ext] + '" to "' + type + '". Pass `force=true` to allow this, otherwise remove "' + ext + '" from the list of extensions for "' + type + '".'
+            );
           }
           this._types[ext] = type;
         }
@@ -99,8 +111,686 @@ var require_mime = __commonJS({
   }
 });
 
+// ../pages-shared/environment-polyfills/index.ts
+var polyfill;
+var init_environment_polyfills = __esm({
+  "../pages-shared/environment-polyfills/index.ts"() {
+    polyfill = (environment) => {
+      Object.entries(environment).map(([name, value]) => {
+        Object.defineProperty(globalThis, name, {
+          value,
+          configurable: true,
+          enumerable: true,
+          writable: true
+        });
+      });
+    };
+  }
+});
+
+// ../pages-shared/environment-polyfills/miniflare-tre.ts
+var miniflare_tre_exports = {};
+__export(miniflare_tre_exports, {
+  default: () => miniflare_tre_default
+});
+var miniflare_tre_default;
+var init_miniflare_tre = __esm({
+  "../pages-shared/environment-polyfills/miniflare-tre.ts"() {
+    init_environment_polyfills();
+    miniflare_tre_default = async () => {
+      const mf = await import("@miniflare/tre");
+      polyfill({
+        fetch: mf.fetch,
+        Headers: mf.Headers,
+        Request: mf.Request,
+        Response: mf.Response
+      });
+    };
+  }
+});
+
+// ../pages-shared/environment-polyfills/miniflare.ts
+var miniflare_exports = {};
+__export(miniflare_exports, {
+  default: () => miniflare_default
+});
+var miniflare_default;
+var init_miniflare = __esm({
+  "../pages-shared/environment-polyfills/miniflare.ts"() {
+    init_environment_polyfills();
+    miniflare_default = async () => {
+      const mf = await import("@miniflare/core");
+      polyfill({
+        fetch: mf.fetch,
+        Headers: mf.Headers,
+        Request: mf.Request,
+        Response: mf.Response
+      });
+    };
+  }
+});
+
+// ../pages-shared/asset-server/responses.ts
+function mergeHeaders(base, extra) {
+  base = new Headers(base ?? {});
+  extra = new Headers(extra ?? {});
+  return new Headers({
+    ...Object.fromEntries(base.entries()),
+    ...Object.fromEntries(extra.entries())
+  });
+}
+var OkResponse, MovedPermanentlyResponse, FoundResponse, NotModifiedResponse, PermanentRedirectResponse, NotFoundResponse, MethodNotAllowedResponse, NotAcceptableResponse, InternalServerErrorResponse, SeeOtherResponse, TemporaryRedirectResponse;
+var init_responses = __esm({
+  "../pages-shared/asset-server/responses.ts"() {
+    OkResponse = class extends Response {
+      constructor(...[body, init]) {
+        super(body, {
+          ...init,
+          status: 200,
+          statusText: "OK"
+        });
+      }
+    };
+    MovedPermanentlyResponse = class extends Response {
+      constructor(location, init) {
+        super(`Redirecting to ${location}`, {
+          ...init,
+          status: 301,
+          statusText: "Moved Permanently",
+          headers: mergeHeaders(init?.headers, {
+            location
+          })
+        });
+      }
+    };
+    FoundResponse = class extends Response {
+      constructor(location, init) {
+        super(`Redirecting to ${location}`, {
+          ...init,
+          status: 302,
+          statusText: "Found",
+          headers: mergeHeaders(init?.headers, {
+            location
+          })
+        });
+      }
+    };
+    NotModifiedResponse = class extends Response {
+      constructor(...[_body, _init]) {
+        super(void 0, {
+          status: 304,
+          statusText: "Not Modified"
+        });
+      }
+    };
+    PermanentRedirectResponse = class extends Response {
+      constructor(location, init) {
+        super(void 0, {
+          ...init,
+          status: 308,
+          statusText: "Permanent Redirect",
+          headers: mergeHeaders(init?.headers, {
+            location
+          })
+        });
+      }
+    };
+    NotFoundResponse = class extends Response {
+      constructor(...[body, init]) {
+        super(body, {
+          ...init,
+          status: 404,
+          statusText: "Not Found"
+        });
+      }
+    };
+    MethodNotAllowedResponse = class extends Response {
+      constructor(...[body, init]) {
+        super(body, {
+          ...init,
+          status: 405,
+          statusText: "Method Not Allowed"
+        });
+      }
+    };
+    NotAcceptableResponse = class extends Response {
+      constructor(...[body, init]) {
+        super(body, {
+          ...init,
+          status: 406,
+          statusText: "Not Acceptable"
+        });
+      }
+    };
+    InternalServerErrorResponse = class extends Response {
+      constructor(err, init) {
+        let body = void 0;
+        if (globalThis.DEBUG) {
+          body = `${err.message}
+
+${err.stack}`;
+        }
+        super(body, {
+          ...init,
+          status: 500,
+          statusText: "Internal Server Error"
+        });
+      }
+    };
+    SeeOtherResponse = class extends Response {
+      constructor(location, init) {
+        super(`Redirecting to ${location}`, {
+          ...init,
+          status: 303,
+          statusText: "See Other",
+          headers: mergeHeaders(init?.headers, { location })
+        });
+      }
+    };
+    TemporaryRedirectResponse = class extends Response {
+      constructor(location, init) {
+        super(`Redirecting to ${location}`, {
+          ...init,
+          status: 307,
+          statusText: "Temporary Redirect",
+          headers: mergeHeaders(init?.headers, { location })
+        });
+      }
+    };
+  }
+});
+
+// ../pages-shared/asset-server/rulesEngine.ts
+var ESCAPE_REGEX_CHARACTERS, escapeRegex, HOST_PLACEHOLDER_REGEX, PLACEHOLDER_REGEX2, replacer, generateRulesMatcher;
+var init_rulesEngine = __esm({
+  "../pages-shared/asset-server/rulesEngine.ts"() {
+    ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+    escapeRegex = (str) => {
+      return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+    };
+    HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g;
+    PLACEHOLDER_REGEX2 = /:(\w+)/g;
+    replacer = (str, replacements) => {
+      for (const [replacement, value] of Object.entries(replacements)) {
+        str = str.replaceAll(`:${replacement}`, value);
+      }
+      return str;
+    };
+    generateRulesMatcher = (rules, replacerFn = (match) => match) => {
+      if (!rules)
+        return () => [];
+      const compiledRules = Object.entries(rules).map(([rule, match]) => {
+        const crossHost = rule.startsWith("https://");
+        rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
+        const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
+        for (const host_match of host_matches) {
+          rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
+        }
+        const path_matches = rule.matchAll(PLACEHOLDER_REGEX2);
+        for (const path_match of path_matches) {
+          rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
+        }
+        rule = "^" + rule + "$";
+        try {
+          const regExp = new RegExp(rule);
+          return [{ crossHost, regExp }, match];
+        } catch {
+        }
+      }).filter((value) => value !== void 0);
+      return ({ request }) => {
+        const { pathname, host } = new URL(request.url);
+        return compiledRules.map(([{ crossHost, regExp }, match]) => {
+          const test = crossHost ? `https://${host}${pathname}` : pathname;
+          const result = regExp.exec(test);
+          if (result) {
+            return replacerFn(match, result.groups || {});
+          }
+        }).filter((value) => value !== void 0);
+      };
+    };
+  }
+});
+
+// ../pages-shared/asset-server/url.ts
+function stringifyURLToRootRelativePathname(url) {
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+var init_url = __esm({
+  "../pages-shared/asset-server/url.ts"() {
+  }
+});
+
+// ../pages-shared/asset-server/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  ANALYTICS_VERSION: () => ANALYTICS_VERSION2,
+  ASSET_PRESERVATION_CACHE: () => ASSET_PRESERVATION_CACHE,
+  CACHE_CONTROL_BROWSER: () => CACHE_CONTROL_BROWSER,
+  HEADERS_VERSION: () => HEADERS_VERSION2,
+  HEADERS_VERSION_V1: () => HEADERS_VERSION_V1,
+  REDIRECTS_VERSION: () => REDIRECTS_VERSION2,
+  generateHandler: () => generateHandler,
+  getResponseFromMatch: () => getResponseFromMatch,
+  normaliseHeaders: () => normaliseHeaders,
+  parseQualityWeightedList: () => parseQualityWeightedList
+});
+function normaliseHeaders(headers) {
+  if (headers.version === HEADERS_VERSION2) {
+    return headers.rules;
+  } else if (headers.version === HEADERS_VERSION_V1) {
+    return Object.keys(headers.rules).reduce(
+      (acc, key) => {
+        acc[key] = {
+          set: headers.rules[key]
+        };
+        return acc;
+      },
+      {}
+    );
+  } else {
+    return {};
+  }
+}
+async function generateHandler({
+  request,
+  metadata,
+  xServerEnvHeader,
+  logError,
+  findAssetEntryForPath,
+  getAssetKey,
+  negotiateContent,
+  fetchAsset,
+  generateNotFoundResponse = async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
+    let assetEntry;
+    if (assetEntry = await notFoundFindAssetEntryForPath("/index.html")) {
+      return notFoundServeAsset(assetEntry, { preserve: false });
+    }
+    return new NotFoundResponse();
+  },
+  attachAdditionalHeaders = () => {
+  },
+  caches,
+  waitUntil
+}) {
+  const url = new URL(request.url);
+  const { protocol, host, search } = url;
+  let { pathname } = url;
+  const earlyHintsCache = metadata.deploymentId ? await caches?.open(`eh:${metadata.deploymentId}`) : void 0;
+  const headerRules = metadata.headers ? normaliseHeaders(metadata.headers) : {};
+  const staticRules = metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.staticRules || {} : {};
+  const staticRedirectsMatcher = () => {
+    const withHostMatch = staticRules[`https://${host}${pathname}`];
+    const withoutHostMatch = staticRules[pathname];
+    if (withHostMatch && withoutHostMatch) {
+      if (withHostMatch.lineNumber < withoutHostMatch.lineNumber) {
+        return withHostMatch;
+      } else {
+        return withoutHostMatch;
+      }
+    }
+    return withHostMatch || withoutHostMatch;
+  };
+  const generateRedirectsMatcher = () => generateRulesMatcher(
+    metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.rules : {},
+    ({ status, to }, replacements) => ({
+      status,
+      to: replacer(to, replacements)
+    })
+  );
+  let assetEntry;
+  async function generateResponse() {
+    const match = staticRedirectsMatcher() || generateRedirectsMatcher()({ request })[0];
+    if (match) {
+      return getResponseFromMatch(match, url);
+    }
+    if (!request.method.match(/^(get|head)$/i)) {
+      return new MethodNotAllowedResponse();
+    }
+    try {
+      pathname = globalThis.decodeURIComponent(pathname);
+    } catch (err) {
+    }
+    if (pathname.endsWith("/")) {
+      if (assetEntry = await findAssetEntryForPath(`${pathname}index.html`)) {
+        return serveAsset(assetEntry);
+      } else if (pathname.endsWith("/index/")) {
+        return new PermanentRedirectResponse(
+          `/${pathname.slice(1, -"index/".length)}${search}`
+        );
+      } else if (assetEntry = await findAssetEntryForPath(
+        `${pathname.replace(/\/$/, ".html")}`
+      )) {
+        return new PermanentRedirectResponse(
+          `/${pathname.slice(1, -1)}${search}`
+        );
+      } else {
+        return notFound();
+      }
+    }
+    if (assetEntry = await findAssetEntryForPath(pathname)) {
+      if (pathname.endsWith(".html")) {
+        const extensionlessPath = pathname.slice(0, -".html".length);
+        if (extensionlessPath.endsWith("/index")) {
+          return new PermanentRedirectResponse(
+            `${extensionlessPath.replace(/\/index$/, "/")}${search}`
+          );
+        } else if (await findAssetEntryForPath(extensionlessPath) || extensionlessPath === "/") {
+          return serveAsset(assetEntry);
+        } else {
+          return new PermanentRedirectResponse(`${extensionlessPath}${search}`);
+        }
+      } else {
+        return serveAsset(assetEntry);
+      }
+    } else if (pathname.endsWith("/index")) {
+      return new PermanentRedirectResponse(
+        `/${pathname.slice(1, -"index".length)}${search}`
+      );
+    } else if (assetEntry = await findAssetEntryForPath(`${pathname}.html`)) {
+      return serveAsset(assetEntry);
+    } else if (hasFileExtension(pathname)) {
+      return notFound();
+    }
+    if (assetEntry = await findAssetEntryForPath(`${pathname}/index.html`)) {
+      return new PermanentRedirectResponse(`${pathname}/${search}`);
+    } else {
+      return notFound();
+    }
+  }
+  async function attachHeaders(response) {
+    const existingHeaders = new Headers(response.headers);
+    const extraHeaders = new Headers({
+      "access-control-allow-origin": "*",
+      "referrer-policy": "strict-origin-when-cross-origin",
+      ...existingHeaders.has("content-type") ? { "x-content-type-options": "nosniff" } : {}
+    });
+    const headers = new Headers({
+      ...Object.fromEntries(existingHeaders.entries()),
+      ...Object.fromEntries(extraHeaders.entries())
+    });
+    if (earlyHintsCache) {
+      const preEarlyHintsHeaders = new Headers(headers);
+      const earlyHintsCacheKey = `${protocol}//${host}${pathname}`;
+      const earlyHintsResponse = await earlyHintsCache.match(
+        earlyHintsCacheKey
+      );
+      if (earlyHintsResponse) {
+        const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
+        if (earlyHintsLinkHeader) {
+          headers.set("Link", earlyHintsLinkHeader);
+        }
+      }
+      const clonedResponse = response.clone();
+      if (waitUntil) {
+        waitUntil(
+          (async () => {
+            try {
+              const links = [];
+              const transformedResponse = new HTMLRewriter().on("link[rel~=preconnect],link[rel~=preload]", {
+                element(element) {
+                  for (const [attributeName] of element.attributes) {
+                    if (!ALLOWED_EARLY_HINT_LINK_ATTRIBUTES.includes(
+                      attributeName.toLowerCase()
+                    )) {
+                      return;
+                    }
+                  }
+                  const href = element.getAttribute("href") || void 0;
+                  const rel = element.getAttribute("rel") || void 0;
+                  const as = element.getAttribute("as") || void 0;
+                  if (href && !href.startsWith("data:") && rel) {
+                    links.push({ href, rel, as });
+                  }
+                }
+              }).transform(clonedResponse);
+              await transformedResponse.text();
+              links.forEach(({ href, rel, as }) => {
+                let link = `<${href}>; rel="${rel}"`;
+                if (as) {
+                  link += `; as=${as}`;
+                }
+                preEarlyHintsHeaders.append("Link", link);
+              });
+              const linkHeader = preEarlyHintsHeaders.get("Link");
+              if (linkHeader) {
+                await earlyHintsCache.put(
+                  earlyHintsCacheKey,
+                  new Response(null, { headers: { Link: linkHeader } })
+                );
+              }
+            } catch (err) {
+            }
+          })()
+        );
+      }
+    }
+    const headersMatcher = generateRulesMatcher(
+      headerRules,
+      ({ set = {}, unset = [] }, replacements) => {
+        const replacedSet = {};
+        Object.keys(set).forEach((key) => {
+          replacedSet[key] = replacer(set[key], replacements);
+        });
+        return {
+          set: replacedSet,
+          unset
+        };
+      }
+    );
+    const matches = headersMatcher({ request });
+    const setMap = /* @__PURE__ */ new Set();
+    matches.forEach(({ set = {}, unset = [] }) => {
+      unset.forEach((key) => {
+        headers.delete(key);
+      });
+      Object.keys(set).forEach((key) => {
+        if (setMap.has(key.toLowerCase())) {
+          headers.append(key, set[key]);
+        } else {
+          headers.set(key, set[key]);
+          setMap.add(key.toLowerCase());
+        }
+      });
+    });
+    return new Response(
+      [101, 204, 205, 304].includes(response.status) ? null : response.body,
+      {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+      }
+    );
+  }
+  return await attachHeaders(await generateResponse());
+  async function serveAsset(servingAssetEntry, options = { preserve: true }) {
+    let content;
+    try {
+      content = negotiateContent(request, servingAssetEntry);
+    } catch (err) {
+      return new NotAcceptableResponse();
+    }
+    const assetKey = getAssetKey(servingAssetEntry, content);
+    const etag = `"${assetKey}"`;
+    const weakEtag = `W/${etag}`;
+    const ifNoneMatch = request.headers.get("if-none-match");
+    if (ifNoneMatch === weakEtag || ifNoneMatch === etag) {
+      return new NotModifiedResponse();
+    }
+    try {
+      const asset = await fetchAsset(assetKey);
+      const headers = {
+        etag,
+        "content-type": asset.contentType
+      };
+      let encodeBody = "automatic";
+      if (xServerEnvHeader) {
+        headers["x-server-env"] = xServerEnvHeader;
+      }
+      if (content.encoding) {
+        encodeBody = "manual";
+        headers["cache-control"] = "no-transform";
+        headers["content-encoding"] = content.encoding;
+      }
+      const response = new OkResponse(
+        request.method === "HEAD" ? null : asset.body,
+        {
+          headers,
+          encodeBody
+        }
+      );
+      if (isCacheable(request)) {
+        response.headers.append("cache-control", CACHE_CONTROL_BROWSER);
+      }
+      attachAdditionalHeaders(response, content, servingAssetEntry, asset);
+      if (isPreview(new URL(request.url))) {
+        response.headers.set("x-robots-tag", "noindex");
+      }
+      if (options.preserve) {
+        const preservedResponse = new Response(
+          [101, 204, 205, 304].includes(response.status) ? null : response.clone().body,
+          response
+        );
+        preservedResponse.headers.set(
+          "cache-control",
+          CACHE_CONTROL_PRESERVATION
+        );
+        preservedResponse.headers.set("x-robots-tag", "noindex");
+        if (waitUntil && caches) {
+          waitUntil(
+            caches.open(ASSET_PRESERVATION_CACHE).then(
+              (assetPreservationCache) => assetPreservationCache.put(request.url, preservedResponse)
+            ).catch((err) => {
+              logError(err);
+            })
+          );
+        }
+      }
+      if (asset.contentType.startsWith("text/html") && metadata.analytics?.version === ANALYTICS_VERSION2) {
+        return new HTMLRewriter().on("body", {
+          element(e) {
+            e.append(
+              `<!-- Cloudflare Pages Analytics --><script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "${metadata.analytics?.token}"}'><\/script><!-- Cloudflare Pages Analytics -->`,
+              { html: true }
+            );
+          }
+        }).transform(response);
+      }
+      return response;
+    } catch (err) {
+      logError(err);
+      return new InternalServerErrorResponse(err);
+    }
+  }
+  async function notFound() {
+    if (caches) {
+      const assetPreservationCache = await caches.open(
+        ASSET_PRESERVATION_CACHE
+      );
+      const preservedResponse = await assetPreservationCache.match(request.url);
+      if (preservedResponse) {
+        return preservedResponse;
+      }
+    }
+    let cwd = pathname;
+    while (cwd) {
+      cwd = cwd.slice(0, cwd.lastIndexOf("/"));
+      if (assetEntry = await findAssetEntryForPath(`${cwd}/404.html`)) {
+        let content;
+        try {
+          content = negotiateContent(request, assetEntry);
+        } catch (err) {
+          return new NotAcceptableResponse();
+        }
+        const assetKey = getAssetKey(assetEntry, content);
+        try {
+          const { body, contentType } = await fetchAsset(assetKey);
+          const response = new NotFoundResponse(body);
+          response.headers.set("content-type", contentType);
+          return response;
+        } catch (err) {
+          logError(err);
+          return new InternalServerErrorResponse(err);
+        }
+      }
+    }
+    return await generateNotFoundResponse(
+      request,
+      findAssetEntryForPath,
+      serveAsset
+    );
+  }
+}
+function getResponseFromMatch({
+  status,
+  to
+}, requestUrl) {
+  const destination = new URL(to, requestUrl);
+  destination.search = destination.search || requestUrl.search;
+  const location = destination.origin === requestUrl.origin ? stringifyURLToRootRelativePathname(destination) : destination.toString();
+  switch (status) {
+    case 301:
+      return new MovedPermanentlyResponse(location);
+    case 303:
+      return new SeeOtherResponse(location);
+    case 307:
+      return new TemporaryRedirectResponse(location);
+    case 308:
+      return new PermanentRedirectResponse(location);
+    case 302:
+    default:
+      return new FoundResponse(location);
+  }
+}
+function parseQualityWeightedList(list = "") {
+  const items = {};
+  list.replace(/\s/g, "").split(",").forEach((el) => {
+    const [item, weight] = el.split(";q=");
+    items[item] = weight ? parseFloat(weight) : 1;
+  });
+  return items;
+}
+function isCacheable(request) {
+  return !request.headers.has("authorization") && !request.headers.has("range");
+}
+function hasFileExtension(path) {
+  return /\/.+\.[a-z0-9]+$/i.test(path);
+}
+function isPreview(url) {
+  if (url.hostname.endsWith(".pages.dev")) {
+    return url.hostname.split(".").length > 3 ? true : false;
+  }
+  return false;
+}
+var ASSET_PRESERVATION_CACHE, CACHE_CONTROL_PRESERVATION, CACHE_CONTROL_BROWSER, REDIRECTS_VERSION2, HEADERS_VERSION2, HEADERS_VERSION_V1, ANALYTICS_VERSION2, ALLOWED_EARLY_HINT_LINK_ATTRIBUTES;
+var init_handler = __esm({
+  "../pages-shared/asset-server/handler.ts"() {
+    init_responses();
+    init_rulesEngine();
+    init_url();
+    ASSET_PRESERVATION_CACHE = "assetPreservationCache";
+    CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800";
+    CACHE_CONTROL_BROWSER = "public, max-age=0, must-revalidate";
+    REDIRECTS_VERSION2 = 1;
+    HEADERS_VERSION2 = 2;
+    HEADERS_VERSION_V1 = 1;
+    ANALYTICS_VERSION2 = 1;
+    ALLOWED_EARLY_HINT_LINK_ATTRIBUTES = ["rel", "as", "href"];
+  }
+});
+
 // src/miniflare-cli/index.ts
-import { Log, LogLevel, Miniflare } from "miniflare";
+import { fetch } from "@miniflare/core";
+import {
+  DurableObjectNamespace,
+  DurableObjectStub
+} from "@miniflare/durable-objects";
+import {
+  Log as MiniflareLog,
+  LogLevel as MiniflareLogLevel,
+  Miniflare,
+  Request as MiniflareRequest,
+  Response as MiniflareResponse
+} from "miniflare";
 
 // ../../node_modules/yargs/lib/platform-shims/esm.mjs
 import { notStrictEqual, strictEqual } from "assert";
@@ -4909,365 +5599,580 @@ function isYargsInstance(y) {
 var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 
+// src/errors.ts
+var FatalError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+
 // src/miniflare-cli/assets.ts
-var import_mime = __toESM(require_mime());
-import { existsSync, lstatSync, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync, lstatSync, readFileSync as readFileSync5 } from "node:fs";
 import { join } from "node:path";
-import { fetch as miniflareFetch } from "@miniflare/core";
-import { watch } from "chokidar";
-import { Response } from "miniflare";
-async function generateASSETSBinding(options) {
-  const assetsFetch = options.directory !== void 0 ? await generateAssetsFetch(options.directory, options.log) : invalidAssetsFetch;
-  return async function(request) {
-    if (options.proxyPort) {
-      try {
-        const url = new URL(request.url);
-        url.host = `localhost:${options.proxyPort}`;
-        return await miniflareFetch(url, request);
-      } catch (thrown) {
-        options.log.error(new Error(`Could not proxy request: ${thrown}`));
-        return new Response(`[wrangler] Could not proxy request: ${thrown}`, {
-          status: 502
-        });
-      }
-    } else {
-      try {
-        return await assetsFetch(request);
-      } catch (thrown) {
-        options.log.error(new Error(`Could not serve static asset: ${thrown}`));
-        return new Response(`[wrangler] Could not serve static asset: ${thrown}`, { status: 502 });
-      }
-    }
-  };
-}
-function escapeRegex(str) {
-  return str.replace(/[-/\\^$*+?.()|[]{}]/g, "\\$&");
-}
-function replacer(str, replacements) {
-  for (const [replacement, value] of Object.entries(replacements)) {
-    str = str.replace(`:${replacement}`, value);
+
+// ../pages-shared/metadata-generator/constants.ts
+var REDIRECTS_VERSION = 1;
+var HEADERS_VERSION = 2;
+var ANALYTICS_VERSION = 1;
+var PERMITTED_STATUS_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var HEADER_SEPARATOR = ":";
+var MAX_LINE_LENGTH = 2e3;
+var MAX_HEADER_RULES = 100;
+var MAX_DYNAMIC_REDIRECT_RULES = 100;
+var MAX_STATIC_REDIRECT_RULES = 2e3;
+var UNSET_OPERATOR = "! ";
+var SPLAT_REGEX = /\*/g;
+var PLACEHOLDER_REGEX = /:\w+/g;
+
+// ../pages-shared/metadata-generator/createMetadataObject.ts
+function createMetadataObject({
+  redirects,
+  headers,
+  webAnalyticsToken,
+  deploymentId,
+  failOpen,
+  logger = (_message) => {
   }
-  return str;
-}
-function generateRulesMatcher(rules, replacerFn = (match) => match) {
-  if (!rules)
-    return () => [];
-  const compiledRules = Object.entries(rules).map(([rule, match]) => {
-    const crossHost = rule.startsWith("https://");
-    rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
-    const host_matches = rule.matchAll(/(?<=^https:\\\/\\\/[^/]*?):([^\\]+)(?=\\)/g);
-    for (const hostMatch of host_matches) {
-      rule = rule.split(hostMatch[0]).join(`(?<${hostMatch[1]}>[^/.]+)`);
-    }
-    const path_matches = rule.matchAll(/:(\w+)/g);
-    for (const pathMatch of path_matches) {
-      rule = rule.split(pathMatch[0]).join(`(?<${pathMatch[1]}>[^/]+)`);
-    }
-    rule = "^" + rule + "$";
-    try {
-      const regExp = new RegExp(rule);
-      return [{ crossHost, regExp }, match];
-    } catch {
-    }
-  }).filter((value) => value !== void 0);
-  return ({ request }) => {
-    const { pathname, host } = new URL(request.url);
-    return compiledRules.map(([{ crossHost, regExp }, match]) => {
-      const test = crossHost ? `https://${host}${pathname}` : pathname;
-      const result = regExp.exec(test);
-      if (result) {
-        return replacerFn(match, result.groups || {});
-      }
-    }).filter((value) => value !== void 0);
+}) {
+  return {
+    ...constructRedirects({ redirects, logger }),
+    ...constructHeaders({ headers, logger }),
+    ...constructWebAnalytics({ webAnalyticsToken, logger }),
+    deploymentId,
+    failOpen
   };
 }
-function generateHeadersMatcher(headersFile) {
-  if (existsSync(headersFile)) {
-    const contents = readFileSync4(headersFile).toString();
-    const lines = contents.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("#") && line !== "");
-    const rules = {};
-    let rule = void 0;
-    for (const line of lines) {
-      if (/^([^\s]+:\/\/|^\/)/.test(line)) {
-        if (rule && Object.keys(rule.headers).length > 0) {
-          rules[rule.path] = rule.headers;
-        }
-        const path = validateURL(line);
-        if (path) {
-          rule = {
-            path,
-            headers: {}
-          };
-          continue;
-        }
-      }
-      if (!line.includes(":"))
-        continue;
-      const [rawName, ...rawValue] = line.split(":");
-      const name = rawName.trim().toLowerCase();
-      const value = rawValue.join(":").trim();
-      if (name === "")
-        continue;
-      if (!rule)
+function constructRedirects({
+  redirects,
+  logger
+}) {
+  if (!redirects)
+    return {};
+  const num_valid = redirects.rules.length;
+  const num_invalid = redirects.invalid.length;
+  logger(
+    `Parsed ${num_valid} valid redirect rule${num_valid === 1 ? "" : "s"}.`
+  );
+  if (num_invalid > 0) {
+    logger(`Found invalid redirect lines:`);
+    for (const { line, lineNumber, message } of redirects.invalid) {
+      if (line)
+        logger(`  - ${lineNumber ? `#${lineNumber}: ` : ""}${line}`);
+      logger(`    ${message}`);
+    }
+  }
+  if (num_valid === 0) {
+    return {};
+  }
+  const staticRedirects = {};
+  const dynamicRedirects = {};
+  let canCreateStaticRule = true;
+  for (const rule of redirects.rules) {
+    if (!rule.from.match(SPLAT_REGEX) && !rule.from.match(PLACEHOLDER_REGEX)) {
+      if (canCreateStaticRule) {
+        staticRedirects[rule.from] = {
+          status: rule.status,
+          to: rule.to,
+          lineNumber: rule.lineNumber
+        };
         continue;
-      const existingValues = rule.headers[name];
-      rule.headers[name] = existingValues ? `${existingValues}, ${value}` : value;
-    }
-    if (rule && Object.keys(rule.headers).length > 0) {
-      rules[rule.path] = rule.headers;
-    }
-    const rulesMatcher = generateRulesMatcher(rules, (match, replacements) => Object.fromEntries(Object.entries(match).map(([name, value]) => [
-      name,
-      replacer(value, replacements)
-    ])));
-    return (request) => {
-      const matches = rulesMatcher({
-        request
-      });
-      if (matches)
-        return matches;
-    };
-  } else {
-    return () => void 0;
+      } else {
+        logger(
+          `Info: the redirect rule ${rule.from} \u2192 ${rule.status} ${rule.to} could be made more performant by bringing it above any lines with splats or placeholders.`
+        );
+      }
+    }
+    dynamicRedirects[rule.from] = { status: rule.status, to: rule.to };
+    canCreateStaticRule = false;
   }
+  return {
+    redirects: {
+      version: REDIRECTS_VERSION,
+      staticRules: staticRedirects,
+      rules: dynamicRedirects
+    }
+  };
 }
-function generateRedirectsMatcher(redirectsFile) {
-  if (existsSync(redirectsFile)) {
-    const contents = readFileSync4(redirectsFile).toString();
-    const lines = contents.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("#") && line !== "");
-    const rules = Object.fromEntries(lines.map((line) => line.split(" ")).filter((tokens) => tokens.length === 2 || tokens.length === 3).map((tokens) => {
-      const from = validateURL(tokens[0], true, false, false);
-      const to = validateURL(tokens[1], false, true, true);
-      let status = parseInt(tokens[2]) || 302;
-      status = [301, 302, 303, 307, 308].includes(status) ? status : void 0;
-      return from && to && status ? [from, { to, status }] : void 0;
-    }).filter((rule) => rule !== void 0));
-    const rulesMatcher = generateRulesMatcher(rules, ({ status, to }, replacements) => ({
-      status,
-      to: replacer(to, replacements)
-    }));
-    return (request) => {
-      const match = rulesMatcher({
-        request
-      })[0];
-      if (match)
-        return match;
-    };
-  } else {
-    return () => void 0;
+function constructHeaders({
+  headers,
+  logger
+}) {
+  if (!headers)
+    return {};
+  const num_valid = headers.rules.length;
+  const num_invalid = headers.invalid.length;
+  logger(`Parsed ${num_valid} valid header rule${num_valid === 1 ? "" : "s"}.`);
+  if (num_invalid > 0) {
+    logger(`Found invalid header lines:`);
+    for (const { line, lineNumber, message } of headers.invalid) {
+      if (line)
+        logger(`  - ${lineNumber ? `#${lineNumber}: ` : ""} ${line}`);
+      logger(`    ${message}`);
+    }
+  }
+  if (num_valid === 0) {
+    return {};
+  }
+  const rules = {};
+  for (const rule of headers.rules) {
+    rules[rule.path] = {};
+    if (Object.keys(rule.headers).length) {
+      rules[rule.path].set = rule.headers;
+    }
+    if (rule.unsetHeaders.length) {
+      rules[rule.path].unset = rule.unsetHeaders;
+    }
   }
+  return {
+    headers: {
+      version: HEADERS_VERSION,
+      rules
+    }
+  };
+}
+function constructWebAnalytics({
+  webAnalyticsToken
+}) {
+  if (!webAnalyticsToken)
+    return {};
+  return {
+    analytics: {
+      version: ANALYTICS_VERSION,
+      token: webAnalyticsToken
+    }
+  };
 }
-function extractPathname(path = "/", includeSearch, includeHash) {
+
+// ../pages-shared/metadata-generator/validateURL.ts
+var extractPathname = (path = "/", includeSearch, includeHash) => {
   if (!path.startsWith("/"))
     path = `/${path}`;
   const url = new URL(`//${path}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
-}
-function validateURL(token, onlyRelative = false, includeSearch = false, includeHash = false) {
-  const host = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/.exec(token);
+};
+var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
+var PATH_REGEX = /^\//;
+var validateUrl = (token, onlyRelative = false, includeSearch = false, includeHash = false) => {
+  const host = URL_REGEX.exec(token);
   if (host && host.groups && host.groups.host) {
     if (onlyRelative)
-      return;
-    return `https://${host.groups.host}${extractPathname(host.groups.path, includeSearch, includeHash)}`;
+      return [
+        void 0,
+        `Only relative URLs are allowed. Skipping absolute URL ${token}.`
+      ];
+    return [
+      `https://${host.groups.host}${extractPathname(
+        host.groups.path,
+        includeSearch,
+        includeHash
+      )}`,
+      void 0
+    ];
   } else {
     if (!token.startsWith("/") && onlyRelative)
       token = `/${token}`;
-    const path = /^\//.exec(token);
+    const path = PATH_REGEX.exec(token);
     if (path) {
       try {
-        return extractPathname(token, includeSearch, includeHash);
+        return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
+        return [void 0, `Error parsing URL segment ${token}. Skipping.`];
       }
     }
   }
-  return "";
-}
-function hasFileExtension(pathname) {
-  return /\/.+\.[a-z0-9]+$/i.test(pathname);
-}
-async function generateAssetsFetch(directory, log) {
-  const { Headers, Request } = await import("@miniflare/core");
-  const headersFile = join(directory, "_headers");
-  const redirectsFile = join(directory, "_redirects");
-  const workerFile = join(directory, "_worker.js");
-  const ignoredFiles = [headersFile, redirectsFile, workerFile];
-  const assetExists = (path) => {
-    path = join(directory, path);
-    return existsSync(path) && lstatSync(path).isFile() && !ignoredFiles.includes(path);
-  };
-  const getAsset = (path) => {
-    if (assetExists(path)) {
-      return join(directory, path);
+  return [
+    void 0,
+    onlyRelative ? "URLs should begin with a forward-slash." : 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").'
+  ];
+};
+
+// ../pages-shared/metadata-generator/parseHeaders.ts
+var LINE_IS_PROBABLY_A_PATH = new RegExp(/^([^\s]+:\/\/|^\/)/);
+function parseHeaders(input) {
+  const lines = input.split("\n");
+  const rules = [];
+  const invalid = [];
+  let rule = void 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0 || line.startsWith("#"))
+      continue;
+    if (line.length > MAX_LINE_LENGTH) {
+      invalid.push({
+        message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
+      });
+      continue;
     }
-  };
-  let redirectsMatcher = generateRedirectsMatcher(redirectsFile);
-  let headersMatcher = generateHeadersMatcher(headersFile);
-  watch([headersFile, redirectsFile], {
-    persistent: true
-  }).on("change", (path) => {
-    switch (path) {
-      case headersFile: {
-        log.log("_headers modified. Re-evaluating...");
-        headersMatcher = generateHeadersMatcher(headersFile);
+    if (LINE_IS_PROBABLY_A_PATH.test(line)) {
+      if (rules.length >= MAX_HEADER_RULES) {
+        invalid.push({
+          message: `Maximum number of rules supported is ${MAX_HEADER_RULES}. Skipping remaining ${lines.length - i} lines of file.`
+        });
         break;
       }
-      case redirectsFile: {
-        log.log("_redirects modified. Re-evaluating...");
-        redirectsMatcher = generateRedirectsMatcher(redirectsFile);
-        break;
+      if (rule) {
+        if (isValidRule(rule)) {
+          rules.push({
+            path: rule.path,
+            headers: rule.headers,
+            unsetHeaders: rule.unsetHeaders
+          });
+        } else {
+          invalid.push({
+            line: rule.line,
+            lineNumber: i + 1,
+            message: "No headers specified"
+          });
+        }
       }
-    }
-  });
-  const serveAsset = (file) => {
-    return readFileSync4(file);
-  };
-  const generateResponse = (request) => {
-    const url = new URL(request.url);
-    const deconstructedResponse = {
-      status: 200,
-      headers: new Headers(),
-      body: void 0
-    };
-    const match = redirectsMatcher(request);
-    if (match) {
-      const { status, to } = match;
-      let location = to;
-      let search;
-      if (to.startsWith("/")) {
-        search = new URL(location, "http://fakehost").search;
-      } else {
-        search = new URL(location).search;
+      const [path, pathError] = validateUrl(line);
+      if (pathError) {
+        invalid.push({
+          line,
+          lineNumber: i + 1,
+          message: pathError
+        });
+        rule = void 0;
+        continue;
       }
-      location = `${location}${search ? "" : url.search}`;
-      if (status && [301, 302, 303, 307, 308].includes(status)) {
-        deconstructedResponse.status = status;
+      rule = {
+        path,
+        line,
+        headers: {},
+        unsetHeaders: []
+      };
+      continue;
+    }
+    if (!line.includes(HEADER_SEPARATOR)) {
+      if (!rule) {
+        invalid.push({
+          line,
+          lineNumber: i + 1,
+          message: "Expected a path beginning with at least one forward-slash"
+        });
       } else {
-        deconstructedResponse.status = 302;
-      }
-      deconstructedResponse.headers.set("Location", location);
-      return deconstructedResponse;
-    }
-    if (!request.method?.match(/^(get|head)$/i)) {
-      deconstructedResponse.status = 405;
-      return deconstructedResponse;
-    }
-    const notFound = () => {
-      let cwd = url.pathname;
-      while (cwd) {
-        cwd = cwd.slice(0, cwd.lastIndexOf("/"));
-        if (asset = getAsset(`${cwd}/404.html`)) {
-          deconstructedResponse.status = 404;
-          deconstructedResponse.body = serveAsset(asset);
-          deconstructedResponse.headers.set("Content-Type", (0, import_mime.getType)(asset) || "application/octet-stream");
-          return deconstructedResponse;
+        if (line.trim().startsWith(UNSET_OPERATOR)) {
+          rule.unsetHeaders.push(line.trim().replace(UNSET_OPERATOR, ""));
+        } else {
+          invalid.push({
+            line,
+            lineNumber: i + 1,
+            message: "Expected a colon-separated header pair (e.g. name: value)"
+          });
         }
       }
-      if (asset = getAsset(`/index.html`)) {
-        deconstructedResponse.body = serveAsset(asset);
-        deconstructedResponse.headers.set("Content-Type", (0, import_mime.getType)(asset) || "application/octet-stream");
-        return deconstructedResponse;
+      continue;
+    }
+    const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR);
+    const name = rawName.trim().toLowerCase();
+    if (name.includes(" ")) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: "Header name cannot include spaces"
+      });
+      continue;
+    }
+    const value = rawValue.join(HEADER_SEPARATOR).trim();
+    if (name === "") {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: "No header name specified"
+      });
+      continue;
+    }
+    if (value === "") {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: "No header value specified"
+      });
+      continue;
+    }
+    if (!rule) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: `Path should come before header (${name}: ${value})`
+      });
+      continue;
+    }
+    const existingValues = rule.headers[name];
+    rule.headers[name] = existingValues ? `${existingValues}, ${value}` : value;
+  }
+  if (rule) {
+    if (isValidRule(rule)) {
+      rules.push({
+        path: rule.path,
+        headers: rule.headers,
+        unsetHeaders: rule.unsetHeaders
+      });
+    } else {
+      invalid.push({ line: rule.line, message: "No headers specified" });
+    }
+  }
+  return {
+    rules,
+    invalid
+  };
+}
+function isValidRule(rule) {
+  return Object.keys(rule.headers).length > 0 || rule.unsetHeaders.length > 0;
+}
+
+// ../pages-shared/metadata-generator/parseRedirects.ts
+function parseRedirects(input) {
+  const lines = input.split("\n");
+  const rules = [];
+  const seen_paths = /* @__PURE__ */ new Set();
+  const invalid = [];
+  let staticRules = 0;
+  let dynamicRules = 0;
+  let canCreateStaticRule = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0 || line.startsWith("#"))
+      continue;
+    if (line.length > MAX_LINE_LENGTH) {
+      invalid.push({
+        message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
+      });
+      continue;
+    }
+    const tokens = line.split(/\s+/);
+    if (tokens.length < 2 || tokens.length > 3) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`
+      });
+      continue;
+    }
+    const [str_from, str_to, str_status = "302"] = tokens;
+    const fromResult = validateUrl(str_from, true, false, false);
+    if (fromResult[0] === void 0) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: fromResult[1]
+      });
+      continue;
+    }
+    const from = fromResult[0];
+    if (canCreateStaticRule && !from.match(SPLAT_REGEX) && !from.match(PLACEHOLDER_REGEX)) {
+      staticRules += 1;
+      if (staticRules > MAX_STATIC_REDIRECT_RULES) {
+        invalid.push({
+          message: `Maximum number of static rules supported is ${MAX_STATIC_REDIRECT_RULES}. Skipping line.`
+        });
+        continue;
       }
-      deconstructedResponse.status = 404;
-      return deconstructedResponse;
-    };
-    let asset;
-    if (url.pathname.endsWith("/")) {
-      if (asset = getAsset(`${url.pathname}/index.html`)) {
-        deconstructedResponse.body = serveAsset(asset);
-        deconstructedResponse.headers.set("Content-Type", (0, import_mime.getType)(asset) || "application/octet-stream");
-        return deconstructedResponse;
-      } else if (asset = getAsset(`${url.pathname.replace(/\/$/, ".html")}`)) {
-        deconstructedResponse.status = 301;
-        deconstructedResponse.headers.set("Location", `${url.pathname.slice(0, -1)}${url.search}`);
-        return deconstructedResponse;
-      }
-    }
-    if (url.pathname.endsWith("/index")) {
-      deconstructedResponse.status = 301;
-      deconstructedResponse.headers.set("Location", `${url.pathname.slice(0, -"index".length)}${url.search}`);
-      return deconstructedResponse;
-    }
-    if (asset = getAsset(url.pathname)) {
-      if (url.pathname.endsWith(".html")) {
-        const extensionlessPath = url.pathname.slice(0, -".html".length);
-        if (getAsset(extensionlessPath) || extensionlessPath === "/") {
-          deconstructedResponse.body = serveAsset(asset);
-          deconstructedResponse.headers.set("Content-Type", (0, import_mime.getType)(asset) || "application/octet-stream");
-          return deconstructedResponse;
-        } else {
-          deconstructedResponse.status = 301;
-          deconstructedResponse.headers.set("Location", `${extensionlessPath}${url.search}`);
-          return deconstructedResponse;
+    } else {
+      dynamicRules += 1;
+      canCreateStaticRule = false;
+      if (dynamicRules > MAX_DYNAMIC_REDIRECT_RULES) {
+        invalid.push({
+          message: `Maximum number of dynamic rules supported is ${MAX_DYNAMIC_REDIRECT_RULES}. Skipping remaining ${lines.length - i} lines of file.`
+        });
+        break;
+      }
+    }
+    const toResult = validateUrl(str_to, false, true, true);
+    if (toResult[0] === void 0) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: toResult[1]
+      });
+      continue;
+    }
+    const to = toResult[0];
+    const status = Number(str_status);
+    if (isNaN(status) || !PERMITTED_STATUS_CODES.has(status)) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: `Valid status codes are 301, 302 (default), 303, 307, or 308. Got ${str_status}.`
+      });
+      continue;
+    }
+    if (seen_paths.has(from)) {
+      invalid.push({
+        line,
+        lineNumber: i + 1,
+        message: `Ignoring duplicate rule for path ${from}.`
+      });
+      continue;
+    }
+    seen_paths.add(from);
+    rules.push({ from, to, status, lineNumber: i + 1 });
+  }
+  return {
+    rules,
+    invalid
+  };
+}
+
+// src/miniflare-cli/assets.ts
+var import_mime = __toESM(require_mime());
+import { watch } from "chokidar";
+
+// src/pages/hash.tsx
+import { readFileSync as readFileSync4 } from "node:fs";
+import { extname as extname2 } from "node:path";
+import { hash as blake3hash } from "blake3-wasm";
+var hashFile = (filepath) => {
+  const contents = readFileSync4(filepath);
+  const base64Contents = contents.toString("base64");
+  const extension = extname2(filepath).substring(1);
+  return blake3hash(base64Contents + extension).toString("hex").slice(0, 32);
+};
+
+// src/miniflare-cli/assets.ts
+async function generateASSETSBinding(options) {
+  const assetsFetch = options.directory !== void 0 ? await generateAssetsFetch(options.directory, options.log, options.tre) : invalidAssetsFetch;
+  const miniflare = options.tre ? await import("@miniflare/tre") : await import("@miniflare/core");
+  const Request = miniflare.Request;
+  const Response2 = miniflare.Response;
+  const fetch2 = options.tre ? miniflare.fetch : (await import("@miniflare/web-sockets")).upgradingFetch;
+  return async function(miniflareRequest) {
+    if (options.proxyPort) {
+      try {
+        const url = new URL(miniflareRequest.url);
+        url.host = `localhost:${options.proxyPort}`;
+        const proxyRequest = new Request(url, miniflareRequest);
+        if (proxyRequest.headers.get("Upgrade") === "websocket") {
+          proxyRequest.headers.delete("Sec-WebSocket-Accept");
+          proxyRequest.headers.delete("Sec-WebSocket-Key");
         }
-      } else {
-        deconstructedResponse.body = serveAsset(asset);
-        deconstructedResponse.headers.set("Content-Type", (0, import_mime.getType)(asset) || "application/octet-stream");
-        return deconstructedResponse;
-      }
-    } else if (hasFileExtension(url.pathname)) {
-      notFound();
-      return deconstructedResponse;
-    }
-    if (asset = getAsset(`${url.pathname}.html`)) {
-      deconstructedResponse.body = serveAsset(asset);
-      deconstructedResponse.headers.set("Content-Type", (0, import_mime.getType)(asset) || "application/octet-stream");
-      return deconstructedResponse;
-    }
-    if (asset = getAsset(`${url.pathname}/index.html`)) {
-      deconstructedResponse.status = 301;
-      deconstructedResponse.headers.set("Location", `${url.pathname}/${url.search}`);
-      return deconstructedResponse;
+        return await fetch2(proxyRequest);
+      } catch (thrown) {
+        options.log.error(new Error(`Could not proxy request: ${thrown}`));
+        return new Response2(`[wrangler] Could not proxy request: ${thrown}`, {
+          status: 502
+        });
+      }
     } else {
-      notFound();
-      return deconstructedResponse;
+      try {
+        return await assetsFetch(miniflareRequest);
+      } catch (thrown) {
+        options.log.error(new Error(`Could not serve static asset: ${thrown}`));
+        return new Response2(
+          `[wrangler] Could not serve static asset: ${thrown}`,
+          { status: 502 }
+        );
+      }
     }
   };
-  const attachHeaders = (request, deconstructedResponse) => {
-    const headers = deconstructedResponse.headers;
-    const newHeaders = new Headers({});
-    const matches = headersMatcher(request) || [];
-    matches.forEach((match) => {
-      Object.entries(match).forEach(([name, value]) => {
-        newHeaders.append(name, `${value}`);
+}
+async function generateAssetsFetch(directory, log, tre) {
+  const polyfill2 = tre ? (await Promise.resolve().then(() => (init_miniflare_tre(), miniflare_tre_exports))).default : (await Promise.resolve().then(() => (init_miniflare(), miniflare_exports))).default;
+  await polyfill2();
+  const miniflare = tre ? await import("@miniflare/tre") : await import("@miniflare/core");
+  const Request = miniflare.Request;
+  const { generateHandler: generateHandler2, parseQualityWeightedList: parseQualityWeightedList2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
+  const headersFile = join(directory, "_headers");
+  const redirectsFile = join(directory, "_redirects");
+  const workerFile = join(directory, "_worker.js");
+  const ignoredFiles = [headersFile, redirectsFile, workerFile];
+  let redirects;
+  if (existsSync(redirectsFile)) {
+    const contents = readFileSync5(redirectsFile, "utf-8");
+    redirects = parseRedirects(contents);
+  }
+  let headers;
+  if (existsSync(headersFile)) {
+    const contents = readFileSync5(headersFile, "utf-8");
+    headers = parseHeaders(contents);
+  }
+  let metadata = createMetadataObject({
+    redirects,
+    headers,
+    logger: log.warn.bind(log)
+  });
+  watch([headersFile, redirectsFile], { persistent: true }).on(
+    "change",
+    (path) => {
+      switch (path) {
+        case headersFile: {
+          log.log("_headers modified. Re-evaluating...");
+          const contents = readFileSync5(headersFile).toString();
+          headers = parseHeaders(contents);
+          break;
+        }
+        case redirectsFile: {
+          log.log("_redirects modified. Re-evaluating...");
+          const contents = readFileSync5(redirectsFile).toString();
+          redirects = parseRedirects(contents);
+          break;
+        }
+      }
+      metadata = createMetadataObject({
+        redirects,
+        headers,
+        logger: log.warn
       });
-    });
-    const combinedHeaders = {
-      ...Object.fromEntries(headers.entries()),
-      ...Object.fromEntries(newHeaders.entries())
-    };
-    deconstructedResponse.headers = new Headers({});
-    Object.entries(combinedHeaders).forEach(([name, value]) => {
-      if (value)
-        deconstructedResponse.headers.set(name, value);
+    }
+  );
+  const generateResponse = async (request) => {
+    const assetKeyEntryMap = /* @__PURE__ */ new Map();
+    return await generateHandler2({
+      request,
+      metadata,
+      xServerEnvHeader: "dev",
+      logError: console.error,
+      findAssetEntryForPath: async (path) => {
+        const filepath = join(directory, path);
+        if (existsSync(filepath) && lstatSync(filepath).isFile() && !ignoredFiles.includes(filepath)) {
+          const hash = hashFile(filepath);
+          assetKeyEntryMap.set(hash, filepath);
+          return hash;
+        }
+        return null;
+      },
+      getAssetKey: (assetEntry) => {
+        return assetEntry;
+      },
+      negotiateContent: (contentRequest) => {
+        let rawAcceptEncoding;
+        if (contentRequest.cf && "clientAcceptEncoding" in contentRequest.cf && contentRequest.cf.clientAcceptEncoding) {
+          rawAcceptEncoding = contentRequest.cf.clientAcceptEncoding;
+        } else {
+          rawAcceptEncoding = contentRequest.headers.get("Accept-Encoding") || void 0;
+        }
+        const acceptEncoding = parseQualityWeightedList2(rawAcceptEncoding);
+        if (acceptEncoding["identity"] === 0 || acceptEncoding["*"] === 0 && acceptEncoding["identity"] === void 0) {
+          throw new Error("No acceptable encodings available");
+        }
+        return { encoding: null };
+      },
+      fetchAsset: async (assetKey) => {
+        const filepath = assetKeyEntryMap.get(assetKey);
+        if (!filepath) {
+          throw new Error(
+            "Could not fetch asset. Please file an issue on GitHub (https://github.com/cloudflare/wrangler2/issues/new/choose) with reproduction steps."
+          );
+        }
+        const body = readFileSync5(filepath);
+        let contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+        if (contentType.startsWith("text/") && !contentType.includes("charset")) {
+          contentType = `${contentType}; charset=utf-8`;
+        }
+        return { body, contentType };
+      }
     });
   };
   return async (input, init) => {
     const request = new Request(input, init);
-    const deconstructedResponse = generateResponse(request);
-    attachHeaders(request, deconstructedResponse);
-    const headers = new Headers();
-    [...deconstructedResponse.headers.entries()].forEach(([name, value]) => {
-      if (value)
-        headers.set(name, value);
-    });
-    return new Response(deconstructedResponse.body, {
-      headers,
-      status: deconstructedResponse.status
-    });
+    return await generateResponse(request);
   };
 }
 var invalidAssetsFetch = () => {
-  throw new Error("Trying to fetch assets directly when there is no `directory` option specified.");
-};
-
-// src/miniflare-cli/enum-keys.ts
-var enumObject = (e) => {
-  const copy = { ...e };
-  Object.values(e).forEach((value) => typeof value === "number" && delete copy[value]);
-  return copy;
-};
-var enumKeys = (e) => {
-  return Object.keys(enumObject(e));
+  throw new Error(
+    "Trying to fetch assets directly when there is no `directory` option specified."
+  );
 };
 
 // src/miniflare-cli/request-context.ts
@@ -5290,7 +6195,7 @@ var getRequestContextCheckOptions = async () => {
 };
 
 // src/miniflare-cli/index.ts
-var NoOpLog = class extends Log {
+var MiniflareNoOpLog = class extends MiniflareLog {
   log() {
   }
   error(message) {
@@ -5298,30 +6203,76 @@ var NoOpLog = class extends Log {
   }
 };
 async function main() {
-  const args = await yargs_default(hideBin(process.argv)).help(false).version(false).option("log", {
-    choices: enumKeys(LogLevel)
-  }).argv;
-  const logLevel = LogLevel[args.log ?? "INFO"];
+  const args = await yargs_default(hideBin(process.argv)).help(false).version(false).argv;
   const requestContextCheckOptions = await getRequestContextCheckOptions();
   const config = {
     ...JSON.parse(args._[0] ?? "{}"),
     ...requestContextCheckOptions
   };
-  config.log = config.disableLogs ? new NoOpLog() : new Log(logLevel, config.logOptions);
-  if (logLevel > LogLevel.INFO) {
-    console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
-  }
+  let logLevelString = config.logLevel.toUpperCase();
+  if (logLevelString === "LOG")
+    logLevelString = "INFO";
+  const logLevel = MiniflareLogLevel[logLevelString];
+  config.log = logLevel === MiniflareLogLevel.NONE ? new MiniflareNoOpLog() : new MiniflareLog(logLevel, config.logOptions);
+  if (logLevel === MiniflareLogLevel.DEBUG) {
+    console.log("MINIFLARE OPTIONS:\n", JSON.stringify(config, null, 2));
+  }
+  config.bindings = {
+    ...config.bindings,
+    ...config.externalDurableObjects && Object.fromEntries(
+      Object.entries(
+        config.externalDurableObjects
+      ).map(([binding, { name, host, port }]) => {
+        const factory = () => {
+          throw new FatalError(
+            "An external Durable Object instance's state has somehow been attempted to be accessed.",
+            1
+          );
+        };
+        const namespace = new DurableObjectNamespace(name, factory);
+        namespace.get = (id) => {
+          const stub = new DurableObjectStub(factory, id);
+          stub.fetch = (...reqArgs) => {
+            const requestFromArgs = new MiniflareRequest(...reqArgs);
+            const url = new URL(requestFromArgs.url);
+            url.host = host;
+            if (port !== void 0)
+              url.port = port.toString();
+            const request = new MiniflareRequest(
+              url.toString(),
+              requestFromArgs
+            );
+            request.headers.set("x-miniflare-durable-object-name", name);
+            request.headers.set(
+              "x-miniflare-durable-object-id",
+              id.toString()
+            );
+            return fetch(request);
+          };
+          return stub;
+        };
+        return [binding, namespace];
+      })
+    )
+  };
   let mf;
+  let durableObjectsMf = void 0;
+  let durableObjectsMfPort = void 0;
   try {
     if (args._[1]) {
-      const opts = JSON.parse(args._[1]);
+      const opts = JSON.parse(
+        args._[1]
+      );
       if (isNaN(opts.proxyPort || NaN) && !opts.directory) {
-        throw new Error("MiniflareCLIOptions: built in service bindings set to true, but no port or directory provided");
+        throw new Error(
+          "MiniflareCLIOptions: built in service bindings set to true, but no port or directory provided"
+        );
       }
       const options = {
         log: config.log,
         proxyPort: opts.proxyPort,
-        directory: opts.directory
+        directory: opts.directory,
+        tre: false
       };
       config.serviceBindings = {
         ...config.serviceBindings,
@@ -5329,13 +6280,72 @@ async function main() {
       };
     }
     mf = new Miniflare(config);
-    await mf.startServer();
+    const mfServer = await mf.startServer();
+    const mfPort = mfServer.address().port;
     await mf.startScheduler();
-    process.send && process.send("ready");
+    const internalDurableObjectClassNames = Object.values(
+      config.durableObjects
+    );
+    if (internalDurableObjectClassNames.length > 0) {
+      durableObjectsMf = new Miniflare({
+        host: config.host,
+        port: 0,
+        script: `
+				export default {
+					fetch(request, env) {
+						return env.DO.fetch(request)
+					}
+				}`,
+        serviceBindings: {
+          DO: async (request) => {
+            request = new MiniflareRequest(request);
+            const name = request.headers.get("x-miniflare-durable-object-name");
+            const idString = request.headers.get(
+              "x-miniflare-durable-object-id"
+            );
+            request.headers.delete("x-miniflare-durable-object-name");
+            request.headers.delete("x-miniflare-durable-object-id");
+            if (!name || !idString) {
+              return new MiniflareResponse(
+                "[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
+                { status: 400 }
+              );
+            }
+            const namespace = await mf?.getDurableObjectNamespace(name);
+            const id = namespace?.idFromString(idString);
+            if (!id) {
+              return new MiniflareResponse(
+                "[durable-object-proxy-err] Could not generate an ID. Possibly due to a mismatched DO name and ID?",
+                { status: 500 }
+              );
+            }
+            const stub = namespace?.get(id);
+            if (!stub) {
+              return new MiniflareResponse(
+                "[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
+                { status: 500 }
+              );
+            }
+            return stub.fetch(request);
+          }
+        },
+        modules: true
+      });
+      const server = await durableObjectsMf.startServer();
+      durableObjectsMfPort = server.address().port;
+    }
+    process.send && process.send(
+      JSON.stringify({
+        port: mfPort,
+        ready: true,
+        durableObjectsPort: durableObjectsMfPort
+      })
+    );
   } catch (e) {
     mf?.log.error(e);
     process.exitCode = 1;
     await mf?.dispose();
+    await durableObjectsMf?.dispose();
   }
 }
 await main();