wrangler 2.0.27 → 2.1.0

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))
@@ -104,6 +111,626 @@ var require_mime = __commonJS({
   }
 });
 
+// ../pages-shared/src/environment-polyfills/index.ts
+var polyfill;
+var init_environment_polyfills = __esm({
+  "../pages-shared/src/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/src/environment-polyfills/miniflare.ts
+var miniflare_exports = {};
+import {
+  fetch as miniflareFetch,
+  Headers as MiniflareHeaders,
+  Request as MiniflareRequest,
+  Response as MiniflareResponse
+} from "@miniflare/core";
+var init_miniflare = __esm({
+  "../pages-shared/src/environment-polyfills/miniflare.ts"() {
+    init_environment_polyfills();
+    polyfill({
+      fetch: miniflareFetch,
+      Headers: MiniflareHeaders,
+      Request: MiniflareRequest,
+      Response: MiniflareResponse
+    });
+  }
+});
+
+// ../pages-shared/src/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/src/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/src/asset-server/rulesEngine.ts
+var ESCAPE_REGEX_CHARACTERS, escapeRegex, HOST_PLACEHOLDER_REGEX, PLACEHOLDER_REGEX2, replacer, generateRulesMatcher;
+var init_rulesEngine = __esm({
+  "../pages-shared/src/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/src/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,
+  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) {
+      const { status, to } = match;
+      const destination = new URL(to, request.url);
+      const location = destination.origin === new URL(request.url).origin ? `${destination.pathname}${destination.search || search}${destination.hash}` : `${destination.href}${destination.search ? "" : search}${destination.hash}`;
+      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);
+      }
+    }
+    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())
+    });
+    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 = [] }) => {
+      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());
+        }
+      });
+      unset.forEach((key) => {
+        headers.delete(key);
+      });
+    });
+    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) {
+                  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) {
+            }
+          })()
+        );
+      }
+    }
+    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 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;
+var init_handler = __esm({
+  "../pages-shared/src/asset-server/handler.ts"() {
+    init_responses();
+    init_rulesEngine();
+    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;
+  }
+});
+
 // src/miniflare-cli/index.ts
 import { fetch } from "@miniflare/core";
 import {
@@ -114,8 +741,8 @@ import {
   Log,
   LogLevel,
   Miniflare,
-  Response as MiniflareResponse,
-  Request as MiniflareRequest
+  Response as MiniflareResponse3,
+  Request as MiniflareRequest3
 } from "miniflare";
 
 // ../../node_modules/yargs/lib/platform-shims/esm.mjs
@@ -4934,412 +5561,552 @@ var FatalError = class extends Error {
 };
 
 // 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 }
+
+// ../pages-shared/src/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/src/metadata-generator/createMetadataObject.ts
+function createMetadataObject({
+  redirects,
+  headers,
+  webAnalyticsToken,
+  deploymentId,
+  logger = (_message) => {
+  }
+}) {
+  return {
+    ...constructRedirects({ redirects, logger }),
+    ...constructHeaders({ headers, logger }),
+    ...constructWebAnalytics({ webAnalyticsToken, logger }),
+    deploymentId
+  };
+}
+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 };
+        continue;
+      } 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 escapeRegex(str) {
-  return str.replace(/[-/\\^$*+?.()|[]{}]/g, "\\$&");
-}
-function replacer(str, replacements) {
-  for (const [replacement, value] of Object.entries(replacements)) {
-    str = str.replace(`:${replacement}`, value);
+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}`);
+    }
   }
-  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]}>[^/.]+)`);
+  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;
     }
-    const path_matches = rule.matchAll(/:(\w+)/g);
-    for (const pathMatch of path_matches) {
-      rule = rule.split(pathMatch[0]).join(`(?<${pathMatch[1]}>[^/]+)`);
+    if (rule.unsetHeaders.length) {
+      rules[rule.path].unset = rule.unsetHeaders;
     }
-    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);
-  };
-}
-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)
-        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;
   }
+  return {
+    headers: {
+      version: HEADERS_VERSION,
+      rules
+    }
+  };
 }
-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 constructWebAnalytics({
+  webAnalyticsToken
+}) {
+  if (!webAnalyticsToken)
+    return {};
+  return {
+    analytics: {
+      version: ANALYTICS_VERSION,
+      token: webAnalyticsToken
+    }
+  };
 }
-function extractPathname(path = "/", includeSearch, includeHash) {
+
+// ../pages-shared/src/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/src/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 [path, pathError] = validateUrl(line);
+      if (pathError) {
+        invalid.push({
+          line,
+          lineNumber: i + 1,
+          message: pathError
+        });
+        rule = void 0;
+        continue;
       }
+      rule = {
+        path,
+        line,
+        headers: {},
+        unsetHeaders: []
+      };
+      continue;
     }
-  });
-  const serveAsset = (file) => {
-    return readFileSync4(file);
+    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 {
+        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)"
+          });
+        }
+      }
+      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
   };
-  const generateResponse = (request) => {
-    const url = new URL(request.url);
-    let assetName = url.pathname;
-    try {
-      assetName = decodeURIComponent(url.pathname);
-    } catch {
+}
+function isValidRule(rule) {
+  return Object.keys(rule.headers).length > 0 || rule.unsetHeaders.length > 0;
+}
+
+// ../pages-shared/src/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 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 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;
       }
-      location = `${location}${search ? "" : url.search}`;
-      if (status && [301, 302, 303, 307, 308].includes(status)) {
-        deconstructedResponse.status = status;
-      } 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 = assetName;
-      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;
-        }
+    } 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;
       }
-      if (asset = getAsset(`/index.html`)) {
-        deconstructedResponse.body = serveAsset(asset);
-        deconstructedResponse.headers.set(
-          "Content-Type",
-          (0, import_mime.getType)(asset) || "application/octet-stream"
+    }
+    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 { fetch as miniflareFetch2 } from "@miniflare/core";
+import {
+  Response as MiniflareResponse2,
+  Request as MiniflareRequest2
+} from "@miniflare/core";
+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) : invalidAssetsFetch;
+  return async function(miniflareRequest) {
+    if (options.proxyPort) {
+      try {
+        const url = new URL(miniflareRequest.url);
+        url.host = `localhost:${options.proxyPort}`;
+        return await miniflareFetch2(url, miniflareRequest);
+      } catch (thrown) {
+        options.log.error(new Error(`Could not proxy request: ${thrown}`));
+        return new MiniflareResponse2(
+          `[wrangler] Could not proxy request: ${thrown}`,
+          {
+            status: 502
+          }
         );
-        return deconstructedResponse;
       }
-      deconstructedResponse.status = 404;
-      return deconstructedResponse;
-    };
-    let asset;
-    if (assetName.endsWith("/")) {
-      if (asset = getAsset(`${assetName}/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(`${assetName.replace(/\/$/, ".html")}`)) {
-        deconstructedResponse.status = 301;
-        deconstructedResponse.headers.set(
-          "Location",
-          `${assetName.slice(0, -1)}${url.search}`
+    } else {
+      try {
+        return await assetsFetch(miniflareRequest);
+      } catch (thrown) {
+        options.log.error(new Error(`Could not serve static asset: ${thrown}`));
+        return new MiniflareResponse2(
+          `[wrangler] Could not serve static asset: ${thrown}`,
+          { status: 502 }
         );
-        return deconstructedResponse;
       }
     }
-    if (assetName.endsWith("/index")) {
-      deconstructedResponse.status = 301;
-      deconstructedResponse.headers.set(
-        "Location",
-        `${assetName.slice(0, -"index".length)}${url.search}`
-      );
-      return deconstructedResponse;
-    }
-    if (asset = getAsset(assetName)) {
-      if (assetName.endsWith(".html")) {
-        const extensionlessPath = assetName.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;
+  };
+}
+async function generateAssetsFetch(directory, log) {
+  await Promise.resolve().then(() => (init_miniflare(), miniflare_exports));
+  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
+  });
+  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 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 {
-          deconstructedResponse.status = 301;
-          deconstructedResponse.headers.set(
-            "Location",
-            `${extensionlessPath}${url.search}`
+          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."
           );
-          return deconstructedResponse;
         }
-      } else {
-        deconstructedResponse.body = serveAsset(asset);
-        deconstructedResponse.headers.set(
-          "Content-Type",
-          (0, import_mime.getType)(asset) || "application/octet-stream"
-        );
-        return deconstructedResponse;
-      }
-    } else if (hasFileExtension(assetName)) {
-      if (asset = getAsset(assetName + ".html")) {
-        deconstructedResponse.body = serveAsset(asset);
-        deconstructedResponse.headers.set(
-          "Content-Type",
-          (0, import_mime.getType)(asset) || "application/octet-stream"
-        );
-        return deconstructedResponse;
+        const body = readFileSync5(filepath);
+        const contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+        return { body, contentType };
       }
-      notFound();
-      return deconstructedResponse;
-    }
-    if (asset = getAsset(`${assetName}.html`)) {
-      deconstructedResponse.body = serveAsset(asset);
-      deconstructedResponse.headers.set(
-        "Content-Type",
-        (0, import_mime.getType)(asset) || "application/octet-stream"
-      );
-      return deconstructedResponse;
-    }
-    if (asset = getAsset(`${assetName}/index.html`)) {
-      deconstructedResponse.status = 301;
-      deconstructedResponse.headers.set(
-        "Location",
-        `${assetName}/${url.search}`
-      );
-      return deconstructedResponse;
-    } else {
-      notFound();
-      return deconstructedResponse;
-    }
-  };
-  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}`);
-      });
-    });
-    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);
     });
   };
   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
-    });
+    const request = new MiniflareRequest2(input, init);
+    return await generateResponse(request);
   };
 }
 var invalidAssetsFetch = () => {
@@ -5403,7 +6170,7 @@ async function main() {
   }
   config.bindings = {
     ...config.bindings,
-    ...Object.fromEntries(
+    ...config.externalDurableObjects && Object.fromEntries(
       Object.entries(
         config.externalDurableObjects
       ).map(([binding, { name, host, port }]) => {
@@ -5417,17 +6184,20 @@ async function main() {
         namespace.get = (id) => {
           const stub = new DurableObjectStub(factory, id);
           stub.fetch = (...reqArgs) => {
-            const requestFromArgs = new MiniflareRequest(...reqArgs);
+            const requestFromArgs = new MiniflareRequest3(...reqArgs);
             const url = new URL(requestFromArgs.url);
             url.host = host;
             if (port !== void 0)
               url.port = port.toString();
-            const request = new MiniflareRequest(
+            const request = new MiniflareRequest3(
               url.toString(),
               requestFromArgs
             );
             request.headers.set("x-miniflare-durable-object-name", name);
-            request.headers.set("x-miniflare-durable-object-id", id.toString());
+            request.headers.set(
+              "x-miniflare-durable-object-id",
+              id.toString()
+            );
             return fetch(request);
           };
           return stub;
@@ -5460,7 +6230,8 @@ async function main() {
       };
     }
     mf = new Miniflare(config);
-    await mf.startServer();
+    const mfServer = await mf.startServer();
+    const mfPort = mfServer.address().port;
     await mf.startScheduler();
     const internalDurableObjectClassNames = Object.values(
       config.durableObjects
@@ -5477,7 +6248,7 @@ async function main() {
 				}`,
         serviceBindings: {
           DO: async (request) => {
-            request = new MiniflareRequest(request);
+            request = new MiniflareRequest3(request);
             const name = request.headers.get("x-miniflare-durable-object-name");
             const idString = request.headers.get(
               "x-miniflare-durable-object-id"
@@ -5485,7 +6256,7 @@ async function main() {
             request.headers.delete("x-miniflare-durable-object-name");
             request.headers.delete("x-miniflare-durable-object-id");
             if (!name || !idString) {
-              return new MiniflareResponse(
+              return new MiniflareResponse3(
                 "[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
                 { status: 400 }
               );
@@ -5493,14 +6264,14 @@ async function main() {
             const namespace = await mf?.getDurableObjectNamespace(name);
             const id = namespace?.idFromString(idString);
             if (!id) {
-              return new MiniflareResponse(
+              return new MiniflareResponse3(
                 "[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(
+              return new MiniflareResponse3(
                 "[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
                 { status: 500 }
               );
@@ -5515,6 +6286,7 @@ async function main() {
     }
     process.send && process.send(
       JSON.stringify({
+        mfPort,
         ready: true,
         durableObjectsPort: durableObjectsMfPort
       })