@void/platform 0.20.0

package/dist/runtime/dispatch/index.js

@@ -0,0 +1,3289 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/platform/dist/index.mjs
+var CORE_CAPABILITIES = {
+  ai: true,
+  customDomains: false,
+  email: false,
+  githubActions: false,
+  githubOAuth: true,
+  googleOAuth: false,
+  managedBuilds: false,
+  sandbox: false
+};
+var CONTROL_PLANE_DEFAULTS = {
+  apiHostname: null,
+  dashboardHostname: null,
+  proxyHostname: null
+};
+function requiredString$1(value, label) {
+  if (typeof value !== "string" || value.trim() === "") throw new Error(`${label} must be a non-empty string.`);
+  return value;
+}
+__name(requiredString$1, "requiredString$1");
+function normalizeInstallationSlug(value) {
+  const slug = value.trim().toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "").replaceAll(/-{2,}/g, "-");
+  if (!slug) throw new Error("The installation name must contain a letter or number.");
+  if (slug.length > 40) throw new Error("The installation name must be 40 characters or fewer after normalization.");
+  return slug;
+}
+__name(normalizeInstallationSlug, "normalizeInstallationSlug");
+function normalizeApplicationDomain(value) {
+  let domain = value.trim().toLowerCase();
+  if (domain.endsWith(".")) domain = domain.slice(0, -1);
+  if (domain.length > 253 || !domain.includes(".") || domain.split(".").some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label))) throw new Error(`Invalid domain: ${JSON.stringify(value)}.`);
+  return domain;
+}
+__name(normalizeApplicationDomain, "normalizeApplicationDomain");
+function createPlatformResourceNames(installationSlug) {
+  const prefix = `void-${normalizeInstallationSlug(installationSlug)}`;
+  const datasetPrefix = prefix.replaceAll("-", "_");
+  return {
+    aiGateway: prefix,
+    apiWorker: `${prefix}-api`,
+    assetsBucket: `${prefix}-assets`,
+    cronQueue: `${prefix}-cron-fires`,
+    dashboardWorker: `${prefix}-dashboard`,
+    dispatchNamespace: `${prefix}-users`,
+    dispatchWorker: `${prefix}-dispatch`,
+    hyperdrive: `${prefix}-database`,
+    isrCacheKv: `${prefix}-isr-cache`,
+    legacyAssetsKv: `${prefix}-legacy-assets`,
+    logsDataset: `${datasetPrefix}_logs`,
+    proxyWorker: `${prefix}-proxy`,
+    requestsDataset: `${datasetPrefix}_requests`,
+    routingKv: `${prefix}-routing`,
+    tailWorker: `${prefix}-tail`,
+    usageQueue: `${prefix}-usage-events`
+  };
+}
+__name(createPlatformResourceNames, "createPlatformResourceNames");
+function createApplicationRoutes(application) {
+  if (!application.zoneName && application.workersDev) {
+    if (application.dedicatedZone) throw new Error("workers.dev cannot use a dedicated-zone catch-all.");
+    return [];
+  }
+  const baseDomain = normalizeApplicationDomain(application.baseDomain);
+  const zoneName = normalizeApplicationDomain(application.zoneName);
+  if (baseDomain !== zoneName && !baseDomain.endsWith(`.${zoneName}`)) throw new Error(`Application domain ${baseDomain} is not inside zone ${zoneName}.`);
+  const routes = [{
+    pattern: `*.${baseDomain}/*`,
+    zoneName
+  }, {
+    pattern: `*.${baseDomain}`,
+    zoneName
+  }];
+  if (application.dedicatedZone) {
+    if (baseDomain !== zoneName) throw new Error("A dedicated-zone catch-all requires the application domain to be the zone.");
+    routes.push({
+      pattern: "*/*",
+      zoneName
+    }, {
+      pattern: "*",
+      zoneName
+    });
+  }
+  return routes;
+}
+__name(createApplicationRoutes, "createApplicationRoutes");
+function createPlatformDeploymentManifest(input) {
+  const installationSlug = normalizeInstallationSlug(input.installationSlug);
+  const baseDomain = normalizeApplicationDomain(input.application.baseDomain);
+  const workersDev = input.application.workersDev;
+  if (workersDev && (!/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(workersDev.subdomain) || !/^[a-z0-9][a-z0-9-]{0,80}$/.test(workersDev.installationId))) throw new Error("Invalid workers.dev installation identity.");
+  const zoneName = workersDev && input.application.zoneName === "" ? "" : normalizeApplicationDomain(input.application.zoneName);
+  if (!zoneName && baseDomain !== `${workersDev.subdomain}.workers.dev`) throw new Error("workers.dev application domain must match its account subdomain.");
+  const resources = {
+    ...createPlatformResourceNames(installationSlug),
+    ...input.resources
+  };
+  const capabilities = {
+    ...CORE_CAPABILITIES,
+    ...input.capabilities
+  };
+  if (capabilities.managedBuilds && !capabilities.githubActions) throw new Error("Managed builds require the GitHub Actions capability.");
+  const providers = input.authentication?.providers ?? ["github"];
+  if (providers.length === 0) throw new Error("At least one authentication provider is required.");
+  if (providers.includes("github") !== capabilities.githubOAuth) throw new Error("The GitHub provider and githubOAuth capability must agree.");
+  if (providers.includes("google") !== capabilities.googleOAuth) throw new Error("The Google provider and googleOAuth capability must agree.");
+  const manifest = {
+    application: {
+      baseDomain,
+      dedicatedZone: input.application.dedicatedZone ?? false,
+      zoneName,
+      ...workersDev ? { workersDev: { ...workersDev } } : {},
+      ...input.application.zoneId ? { zoneId: requiredString$1(input.application.zoneId, "application.zoneId") } : {}
+    },
+    authentication: { providers: [...providers] },
+    capabilities,
+    controlPlane: {
+      ...CONTROL_PLANE_DEFAULTS,
+      ...input.controlPlane
+    },
+    displayName: requiredString$1(input.displayName, "displayName").trim(),
+    installationSlug,
+    resources,
+    schemaVersion: workersDev ? 2 : 1
+  };
+  createApplicationRoutes(manifest.application);
+  for (const [key, value] of Object.entries(manifest.controlPlane)) {
+    if (value !== null) normalizeApplicationDomain(value);
+    if (value === "") throw new Error(`controlPlane.${key} must be a hostname or null.`);
+  }
+  for (const [key, value] of Object.entries(manifest.resources)) requiredString$1(value, `resources.${key}`);
+  return manifest;
+}
+__name(createPlatformDeploymentManifest, "createPlatformDeploymentManifest");
+var PLATFORM_USAGE_PROTOCOL_VERSION = 1;
+function readPlatformApplication(env) {
+  const baseDomain = env.SITE_DOMAIN ?? env.BASE_HOSTNAME ?? "void.app";
+  if (!env.PLATFORM_APPLICATION) return {
+    baseDomain,
+    zoneName: baseDomain,
+    dedicatedZone: false
+  };
+  return createPlatformDeploymentManifest({
+    installationSlug: "runtime",
+    displayName: "Runtime",
+    application: JSON.parse(env.PLATFORM_APPLICATION)
+  }).application;
+}
+__name(readPlatformApplication, "readPlatformApplication");
+function platformWorkersDevAliasKey(hostname) {
+  return `workers-dev:${hostname}`;
+}
+__name(platformWorkersDevAliasKey, "platformWorkersDevAliasKey");
+var PLATFORM_APPLICATION_KEY = "__void/platform/application/v1";
+async function resolvePlatformApplicationEnvironment(env) {
+  if (!env.PLATFORM_APPLICATION) return env;
+  const raw = await env.ROUTING.get(PLATFORM_APPLICATION_KEY);
+  if (!raw) return env;
+  const previous = readPlatformApplication(env);
+  const next = readPlatformApplication({ PLATFORM_APPLICATION: raw });
+  if (!previous.workersDev || !next.workersDev || previous.workersDev.installationId !== next.workersDev.installationId || previous.workersDev.subdomain !== next.workersDev.subdomain) throw new Error("Application routing belongs to another platform installation.");
+  return {
+    ...env,
+    PLATFORM_APPLICATION: raw,
+    SITE_DOMAIN: next.baseDomain,
+    BASE_HOSTNAME: next.baseDomain,
+    ...next.zoneId ? { CF_ZONE_ID: next.zoneId } : {}
+  };
+}
+__name(resolvePlatformApplicationEnvironment, "resolvePlatformApplicationEnvironment");
+function platformProjectIngressName(project, workersDev) {
+  if (!/^proj_[a-z0-9]{1,32}$/.test(project.id) || !/^[a-z0-9][a-z0-9-]*$/.test(project.slug)) throw new Error("Invalid platform project identity.");
+  const prefix = `void-${workersDev.installationId.slice(-12)}-`;
+  const suffix = `-${project.id.slice(5)}`;
+  return `${prefix}${project.slug.slice(0, 63 - prefix.length - suffix.length).replace(/-+$/, "")}${suffix}`;
+}
+__name(platformProjectIngressName, "platformProjectIngressName");
+function platformProjectWorkersDevHostname(project, workersDev) {
+  return `${platformProjectIngressName(project, workersDev)}.${workersDev.subdomain}.workers.dev`;
+}
+__name(platformProjectWorkersDevHostname, "platformProjectWorkersDevHostname");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/error-page.ts
+var DEFAULT_FONT_STACK = 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif';
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+__name(escapeHtml, "escapeHtml");
+function renderDefaultErrorPage(status, title) {
+  const heading = `${status}: ${title}`;
+  const prefix = `${status}: `;
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${escapeHtml(heading)}</title>
+    <style>
+      :root {
+        color-scheme: light;
+        font-family: ${DEFAULT_FONT_STACK};
+        background: #f5f5f5;
+        color: #171717;
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        min-block-size: 100dvh;
+        display: grid;
+        place-items: center;
+        padding: 24px;
+        background:
+          radial-gradient(circle at top, rgba(255, 255, 255, 0.96), rgba(245, 245, 245, 0.96) 52%),
+          linear-gradient(180deg, #fafafa 0%, #f1f1f1 100%);
+        font: 500 16px/1.5 ${DEFAULT_FONT_STACK};
+      }
+
+      main {
+        inline-size: min(100%, 560px);
+        padding: 32px 36px;
+        border: 1px solid #d4d4d8;
+        border-radius: 32px;
+        corner-shape: squircle;
+        background: rgba(255, 255, 255, 0.88);
+        text-align: center;
+        backdrop-filter: blur(12px);
+      }
+
+      h1 {
+        margin: 0;
+        font: 400 clamp(1.5rem, 1.2rem + 1vw, 2rem) / 1.1 ${DEFAULT_FONT_STACK};
+        letter-spacing: -0.03em;
+      }
+
+      strong {
+        font-weight: 600;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1><strong>${escapeHtml(prefix)}</strong>${escapeHtml(title)}</h1>
+    </main>
+  </body>
+</html>`;
+}
+__name(renderDefaultErrorPage, "renderDefaultErrorPage");
+function shouldServeHtmlErrorPage(request) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return false;
+  }
+  const url = new URL(request.url);
+  if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
+    return false;
+  }
+  if (/\/[^/]+\.[^/]+$/.test(url.pathname)) {
+    return false;
+  }
+  const destination = request.headers.get("sec-fetch-dest");
+  if (destination && destination !== "document" && destination !== "empty") {
+    return false;
+  }
+  const accept = request.headers.get("accept");
+  return !accept || accept.includes("text/html") || accept.includes("*/*");
+}
+__name(shouldServeHtmlErrorPage, "shouldServeHtmlErrorPage");
+function createErrorResponse(request, status, title, headers) {
+  if (!shouldServeHtmlErrorPage(request)) {
+    return new Response(title, { status, headers });
+  }
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("content-type", "text/html; charset=utf-8");
+  return new Response(request.method === "HEAD" ? null : renderDefaultErrorPage(status, title), {
+    status,
+    headers: responseHeaders
+  });
+}
+__name(createErrorResponse, "createErrorResponse");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/edge/src/pattern.ts
+var MAX_CACHE = 256;
+var compileCache = /* @__PURE__ */ new Map();
+var REGEX_SPECIAL = /[.+?^${}()|[\]\\]/;
+var PARAM_CHAR = /[A-Za-z0-9_]/;
+function compilePattern(source) {
+  const cached = compileCache.get(source);
+  if (cached) {
+    compileCache.delete(source);
+    compileCache.set(source, cached);
+    return cached;
+  }
+  const paramNames = [];
+  let legacySplatCaptured = false;
+  let pattern = "";
+  let index = 0;
+  while (index < source.length) {
+    const character = source[index];
+    if (character === ":") {
+      let nameEnd = index + 1;
+      while (nameEnd < source.length && PARAM_CHAR.test(source[nameEnd])) {
+        nameEnd++;
+      }
+      const name = source.slice(index + 1, nameEnd);
+      if (!name) {
+        pattern += "\\:";
+        index++;
+        continue;
+      }
+      if (source[nameEnd] === "*") {
+        paramNames.push(name);
+        pattern += `(?<${name}>.*)`;
+        index = nameEnd + 1;
+      } else {
+        paramNames.push(name);
+        pattern += `(?<${name}>[^/]+)`;
+        index = nameEnd;
+      }
+    } else if (character === "*") {
+      if (legacySplatCaptured) {
+        pattern += `.*`;
+      } else {
+        paramNames.push("splat");
+        pattern += `(?<splat>.*)`;
+        legacySplatCaptured = true;
+      }
+      index++;
+    } else {
+      if (REGEX_SPECIAL.test(character)) {
+        pattern += "\\";
+      }
+      pattern += character;
+      index++;
+    }
+  }
+  const compiled = { regex: new RegExp(`^${pattern}$`), paramNames };
+  if (compileCache.size >= MAX_CACHE) {
+    const first = compileCache.keys().next();
+    if (!first.done) {
+      compileCache.delete(first.value);
+    }
+  }
+  compileCache.set(source, compiled);
+  return compiled;
+}
+__name(compilePattern, "compilePattern");
+var literalRegexCache = /* @__PURE__ */ new Map();
+function matchLiteralPattern(pattern, pathname) {
+  let regex = literalRegexCache.get(pattern);
+  if (regex) {
+    literalRegexCache.delete(pattern);
+    literalRegexCache.set(pattern, regex);
+  } else {
+    try {
+      const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
+      regex = new RegExp(`^${escaped}$`);
+    } catch {
+      return false;
+    }
+    if (literalRegexCache.size >= MAX_CACHE) {
+      const first = literalRegexCache.keys().next();
+      if (!first.done) {
+        literalRegexCache.delete(first.value);
+      }
+    }
+    literalRegexCache.set(pattern, regex);
+  }
+  try {
+    return regex.test(pathname);
+  } catch {
+    return false;
+  }
+}
+__name(matchLiteralPattern, "matchLiteralPattern");
+var segmentRegexCache = /* @__PURE__ */ new Map();
+function matchSegmentPattern(pattern, pathname) {
+  let regex = segmentRegexCache.get(pattern);
+  if (regex) {
+    segmentRegexCache.delete(pattern);
+    segmentRegexCache.set(pattern, regex);
+  } else {
+    try {
+      const escaped = pattern.replace(/(^|\/):[^/{}]+\{\.\+\}(?=\/|$)/g, "$1\uE001").replace(/(^|\/):[^/]+(?=\/|$)/g, "$1\uE000").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("\uE000", "[^/]+").replaceAll("\uE001", ".+");
+      regex = new RegExp(`^${escaped}$`);
+    } catch {
+      return false;
+    }
+    if (segmentRegexCache.size >= MAX_CACHE) {
+      const first = segmentRegexCache.keys().next();
+      if (!first.done) {
+        segmentRegexCache.delete(first.value);
+      }
+    }
+    segmentRegexCache.set(pattern, regex);
+  }
+  try {
+    return regex.test(pathname);
+  } catch {
+    return false;
+  }
+}
+__name(matchSegmentPattern, "matchSegmentPattern");
+function substituteParams(destination, params) {
+  return destination.replace(/:([A-Za-z0-9_]+)\*?/g, (whole, name) => {
+    return params[name] ?? whole;
+  });
+}
+__name(substituteParams, "substituteParams");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/edge/src/headers.ts
+var BLOCKED_HEADERS = /* @__PURE__ */ new Set(["set-cookie"]);
+function parseQuotedString(member) {
+  if (member.length < 2 || member[0] !== '"' || member[member.length - 1] !== '"') {
+    return null;
+  }
+  let content = "";
+  for (let i = 1; i < member.length - 1; i += 1) {
+    const char = member[i];
+    if (char === "\\") {
+      i += 1;
+      if (i >= member.length - 1) {
+        return null;
+      }
+      content += member[i];
+    } else if (char === '"') {
+      return null;
+    } else {
+      content += char;
+    }
+  }
+  return content;
+}
+__name(parseQuotedString, "parseQuotedString");
+function parseClearSiteData(value) {
+  const members = [];
+  const pushMember = /* @__PURE__ */ __name((slice) => {
+    const raw = slice.trim();
+    if (raw.length > 0) {
+      members.push({ raw, directive: parseQuotedString(raw) });
+    }
+  }, "pushMember");
+  let start = 0;
+  let inQuotes = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (inQuotes) {
+      if (char === "\\") {
+        i += 1;
+      } else if (char === '"') {
+        inQuotes = false;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      pushMember(value.slice(start, i));
+      start = i + 1;
+    }
+  }
+  pushMember(value.slice(start));
+  return members;
+}
+__name(parseClearSiteData, "parseClearSiteData");
+function sanitizeClearSiteData(value) {
+  const kept = [];
+  for (const { raw, directive } of parseClearSiteData(value)) {
+    const normalized = directive?.toLowerCase();
+    if (normalized === "*") {
+      return null;
+    }
+    if (directive === null || normalized === "cookies") {
+      continue;
+    }
+    kept.push(raw);
+  }
+  return kept.length > 0 ? kept.join(", ") : null;
+}
+__name(sanitizeClearSiteData, "sanitizeClearSiteData");
+function applyHeaderRules(response, pathname, rules, policy) {
+  if (!rules || rules.length === 0) {
+    return response;
+  }
+  const matched = [];
+  for (const rule of rules) {
+    if (matchLiteralPattern(rule.pattern, pathname)) {
+      matched.push(...rule.headers);
+    }
+  }
+  if (matched.length === 0) {
+    return response;
+  }
+  const newResponse = new Response(response.body, response);
+  const isolateSharedDomainCookies = policy?.cookieIsolation !== "origin";
+  const rawOriginClearSiteData = isolateSharedDomainCookies ? response.headers.get("clear-site-data") : null;
+  const originClearSiteData = rawOriginClearSiteData === null ? null : sanitizeClearSiteData(rawOriginClearSiteData);
+  for (const [name, value] of matched) {
+    const lowerName = name.toLowerCase();
+    if (isolateSharedDomainCookies && BLOCKED_HEADERS.has(lowerName)) {
+      continue;
+    }
+    if (isolateSharedDomainCookies && lowerName === "clear-site-data") {
+      const safe = sanitizeClearSiteData(value);
+      if (safe !== null) {
+        newResponse.headers.set(name, safe);
+      } else if (originClearSiteData !== null) {
+        newResponse.headers.set(name, originClearSiteData);
+      } else {
+        newResponse.headers.delete(name);
+      }
+      continue;
+    }
+    newResponse.headers.set(name, value);
+  }
+  return newResponse;
+}
+__name(applyHeaderRules, "applyHeaderRules");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/edge/src/routing-rules.ts
+function applyRoutingRules(pathname, rules, requestHost) {
+  if (!rules?.length) {
+    return null;
+  }
+  for (const rule of rules) {
+    if (rule.host && rule.host !== requestHost) {
+      continue;
+    }
+    let regex;
+    try {
+      ({ regex } = compilePattern(rule.source));
+    } catch (err) {
+      console.warn(
+        `[dispatch] skipping routing rule with invalid source ${JSON.stringify(rule.source)}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      continue;
+    }
+    const match = regex.exec(pathname);
+    if (!match) {
+      continue;
+    }
+    const destination = substituteParams(rule.destination, match.groups ?? {});
+    if (rule.status === 200) {
+      return { type: "rewrite", destination };
+    }
+    return { type: "redirect", destination, status: rule.status };
+  }
+  return null;
+}
+__name(applyRoutingRules, "applyRoutingRules");
+function mergeQueryIntoLocation(destination, requestSearch) {
+  if (!requestSearch || requestSearch === "?") {
+    return destination;
+  }
+  const fragIdx = destination.indexOf("#");
+  const base = fragIdx === -1 ? destination : destination.slice(0, fragIdx);
+  const fragment = fragIdx === -1 ? "" : destination.slice(fragIdx);
+  const destQueryIdx = base.indexOf("?");
+  if (destQueryIdx === -1) {
+    return base + requestSearch + fragment;
+  }
+  if (destQueryIdx === base.length - 1) {
+    return base.slice(0, destQueryIdx) + fragment;
+  }
+  const reqParams = new URLSearchParams(requestSearch);
+  const destParams = new URLSearchParams(base.slice(destQueryIdx + 1));
+  for (const [key, value] of reqParams) {
+    if (!destParams.has(key)) {
+      destParams.append(key, value);
+    }
+  }
+  return base.slice(0, destQueryIdx) + "?" + destParams.toString() + fragment;
+}
+__name(mergeQueryIntoLocation, "mergeQueryIntoLocation");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/edge/src/static.ts
+function safeDecodePathname(pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return pathname;
+  }
+  if (decoded === pathname) {
+    return pathname;
+  }
+  const canonical = reencodePathname(decoded);
+  if (canonical === null) {
+    return pathname;
+  }
+  return normalizePercentCase(canonical) === normalizePercentCase(pathname) ? decoded : pathname;
+}
+__name(safeDecodePathname, "safeDecodePathname");
+function normalizePercentCase(pathname) {
+  return pathname.replace(/%[0-9a-fA-F]{2}/g, (escape) => escape.toUpperCase());
+}
+__name(normalizePercentCase, "normalizePercentCase");
+function reencodePathname(pathname) {
+  try {
+    const encoder2 = new URL("https://void.invalid/");
+    encoder2.pathname = pathname;
+    return encoder2.pathname;
+  } catch {
+    return null;
+  }
+}
+__name(reencodePathname, "reencodePathname");
+function matchManifestEntry(pathname, manifest, htmlHandling) {
+  if (manifest[pathname]) {
+    return { path: pathname, hash: manifest[pathname] };
+  }
+  switch (htmlHandling) {
+    case "auto-trailing-slash": {
+      const withHtml = pathname + ".html";
+      if (manifest[withHtml]) {
+        return { path: withHtml, hash: manifest[withHtml] };
+      }
+      const withIndex = (pathname.endsWith("/") ? pathname : pathname + "/") + "index.html";
+      if (manifest[withIndex]) {
+        return { path: withIndex, hash: manifest[withIndex] };
+      }
+      break;
+    }
+    case "force-trailing-slash": {
+      if (!pathname.endsWith("/") && pathname !== "/") {
+        const withIndex = pathname + "/index.html";
+        if (manifest[withIndex]) {
+          return {
+            path: withIndex,
+            hash: manifest[withIndex],
+            redirect: pathname + "/"
+          };
+        }
+      }
+      const indexPath = pathname + "index.html";
+      if (manifest[indexPath]) {
+        return { path: indexPath, hash: manifest[indexPath] };
+      }
+      break;
+    }
+    case "drop-trailing-slash": {
+      if (pathname === "/") {
+        if (manifest["/index.html"]) {
+          return { path: "/index.html", hash: manifest["/index.html"] };
+        }
+        break;
+      }
+      if (pathname.endsWith("/")) {
+        const withoutSlash = pathname.slice(0, -1);
+        const withHtml2 = withoutSlash + ".html";
+        if (manifest[withHtml2]) {
+          return {
+            path: withHtml2,
+            hash: manifest[withHtml2],
+            redirect: withoutSlash
+          };
+        }
+      }
+      const withHtml = pathname + ".html";
+      if (manifest[withHtml]) {
+        return { path: withHtml, hash: manifest[withHtml] };
+      }
+      break;
+    }
+    case "none":
+      break;
+  }
+  return null;
+}
+__name(matchManifestEntry, "matchManifestEntry");
+function resolveStaticPath(pathname, manifest, config) {
+  const htmlHandling = config.html_handling ?? "auto-trailing-slash";
+  let matched = matchManifestEntry(pathname, manifest, htmlHandling);
+  if (!matched) {
+    const decoded = safeDecodePathname(pathname);
+    if (decoded !== pathname) {
+      matched = matchManifestEntry(decoded, manifest, htmlHandling);
+      if (matched?.redirect !== void 0) {
+        const safeRedirect = reencodePathname(matched.redirect);
+        if (safeRedirect !== null) {
+          matched = { ...matched, redirect: safeRedirect };
+        }
+      }
+    }
+  }
+  if (matched) {
+    return matched;
+  }
+  switch (config.not_found_handling ?? "none") {
+    case "single-page-application":
+      if (manifest["/index.html"]) {
+        return {
+          path: "/index.html",
+          hash: manifest["/index.html"],
+          spa: true
+        };
+      }
+      break;
+    case "404-page":
+      if (manifest["/404.html"]) {
+        return {
+          path: "/404.html",
+          hash: manifest["/404.html"],
+          notFound: true
+        };
+      }
+      break;
+  }
+  return null;
+}
+__name(resolveStaticPath, "resolveStaticPath");
+var MIME_TYPES = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  json: "application/json; charset=utf-8",
+  xml: "application/xml; charset=utf-8",
+  svg: "image/svg+xml; charset=utf-8",
+  txt: "text/plain; charset=utf-8",
+  csv: "text/csv; charset=utf-8",
+  md: "text/markdown; charset=utf-8",
+  markdown: "text/markdown; charset=utf-8",
+  yaml: "text/yaml; charset=utf-8",
+  yml: "text/yaml; charset=utf-8",
+  toml: "application/toml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  webp: "image/webp",
+  avif: "image/avif",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  eot: "application/vnd.ms-fontobject",
+  pdf: "application/pdf",
+  wasm: "application/wasm",
+  webmanifest: "application/manifest+json; charset=utf-8",
+  map: "application/json; charset=utf-8",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  ogg: "audio/ogg"
+};
+function getContentType(path) {
+  const ext = path.split(".").pop()?.toLowerCase() ?? "";
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+__name(getContentType, "getContentType");
+function resolveAssetContentType(stored, path) {
+  if (stored === "application/null") {
+    return void 0;
+  }
+  if (!stored || stored === "application/octet-stream") {
+    return getContentType(path);
+  }
+  return stored;
+}
+__name(resolveAssetContentType, "resolveAssetContentType");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/isr/src/index.ts
+var ISR_CACHE_KEY_VERSION = "v3";
+function normalizeIsrPath(pathname) {
+  let normalized = pathname;
+  if (normalized === "/") {
+    normalized = "__index__";
+  } else {
+    normalized = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+    if (normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+  }
+  return normalized;
+}
+__name(normalizeIsrPath, "normalizeIsrPath");
+function denormalizeIsrPath(normalized) {
+  return normalized === "__index__" ? "/" : `/${normalized}`;
+}
+__name(denormalizeIsrPath, "denormalizeIsrPath");
+function canonicalIsrPathname(pathname) {
+  return denormalizeIsrPath(normalizeIsrPath(pathname));
+}
+__name(canonicalIsrPathname, "canonicalIsrPathname");
+function isrCacheVersionPrefix(projectId) {
+  return `${projectId}/isr/${ISR_CACHE_KEY_VERSION}/`;
+}
+__name(isrCacheVersionPrefix, "isrCacheVersionPrefix");
+function isrCachePrefix(projectId, deploymentId) {
+  if (deploymentId !== void 0) {
+    return `${isrCacheVersionPrefix(projectId)}${deploymentId}/`;
+  }
+  return `${projectId}/isr/`;
+}
+__name(isrCachePrefix, "isrCachePrefix");
+var ISR_VARIANT_SEPARATOR = "#rw=";
+function isrCacheKey(projectId, deploymentId, host, pathname, originalUrl) {
+  const base = `${isrCachePrefix(projectId, deploymentId)}${host}/${normalizeIsrPath(pathname)}`;
+  if (!originalUrl) {
+    return base;
+  }
+  return `${base}${ISR_VARIANT_SEPARATOR}${hashOriginalUrl(originalUrl)}`;
+}
+__name(isrCacheKey, "isrCacheKey");
+function isrCacheVariantPrefix(projectId, deploymentId, host, pathname) {
+  return `${isrCachePrefix(projectId, deploymentId)}${host}/${normalizeIsrPath(pathname)}${ISR_VARIANT_SEPARATOR}`;
+}
+__name(isrCacheVariantPrefix, "isrCacheVariantPrefix");
+var FNV_OFFSET_BASIS = 0xcbf29ce484222325n;
+var FNV_PRIME = 0x100000001b3n;
+var FNV_MASK = 0xffffffffffffffffn;
+function hashOriginalUrl(originalUrl) {
+  const bytes = new TextEncoder().encode(originalUrl);
+  let h = FNV_OFFSET_BASIS;
+  for (let i = 0; i < bytes.length; i++) {
+    h = (h ^ BigInt(bytes[i])) & FNV_MASK;
+    h = h * FNV_PRIME & FNV_MASK;
+  }
+  return h.toString(16).padStart(16, "0");
+}
+__name(hashOriginalUrl, "hashOriginalUrl");
+function isrEdgeCacheUrl(hostname, pathname, deploymentId, variant, originalUrl) {
+  return buildIsrEdgeCacheUrl(
+    hostname,
+    pathname,
+    deploymentId,
+    variant,
+    originalUrl ? hashOriginalUrl(originalUrl) : null
+  );
+}
+__name(isrEdgeCacheUrl, "isrEdgeCacheUrl");
+function buildIsrEdgeCacheUrl(hostname, pathname, deploymentId, variant, variantToken) {
+  const normalizedPathname = canonicalIsrPathname(pathname);
+  const url = new URL(`https://${hostname}${normalizedPathname}`);
+  if (variant === "json") {
+    url.searchParams.set("__void", "json");
+  }
+  url.searchParams.set("__void_isr", deploymentId);
+  if (variantToken) {
+    url.searchParams.set("__void_orig", variantToken);
+  }
+  return url.toString();
+}
+__name(buildIsrEdgeCacheUrl, "buildIsrEdgeCacheUrl");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/packages/isr/src/core.ts
+var SHARED_CACHE_POLICY_VERSION = 1;
+var SHARED_CACHE_POLICY_HEADER = "x-void-shared-cache-policy";
+function markSharedCachePolicy(headers) {
+  headers.set(SHARED_CACHE_POLICY_HEADER, String(SHARED_CACHE_POLICY_VERSION));
+}
+__name(markSharedCachePolicy, "markSharedCachePolicy");
+function hasCurrentSharedCachePolicy(response) {
+  return response.headers.get(SHARED_CACHE_POLICY_HEADER) === String(SHARED_CACHE_POLICY_VERSION);
+}
+__name(hasCurrentSharedCachePolicy, "hasCurrentSharedCachePolicy");
+var PAGE_DATA_SCRIPT_RE = /<script\b[^>]*\bid=(["'])__VOID_PAGE_DATA__\1[^>]*>([\s\S]*?)<\/script>/i;
+var SKIP_HEADERS = /* @__PURE__ */ new Set(["cache-control", "x-isr-cache", "x-void-page-data", "set-cookie"]);
+function buildVariantOriginalUrl(requestUrl, pathname, queryAllowlist) {
+  const url = new URL(requestUrl);
+  if (!url.search) {
+    return url.toString();
+  }
+  const allowed = resolveQueryAllowlist(queryAllowlist, pathname);
+  if (allowed.size === 0) {
+    url.search = "";
+    return url.toString();
+  }
+  const keys = [...new Set(url.searchParams.keys())].filter((key) => allowed.has(key)).sort();
+  const filtered = new URLSearchParams();
+  for (const key of keys) {
+    for (const value of url.searchParams.getAll(key)) {
+      filtered.append(key, value);
+    }
+  }
+  const filteredString = filtered.toString();
+  url.search = filteredString ? `?${filteredString}` : "";
+  return url.toString();
+}
+__name(buildVariantOriginalUrl, "buildVariantOriginalUrl");
+function exactQueryAllowlist(allowlist) {
+  if (!allowlist) {
+    return void 0;
+  }
+  const exact = Object.fromEntries(
+    Object.entries(allowlist).filter(([pattern]) => !pattern.includes("*"))
+  );
+  return Object.keys(exact).length > 0 ? exact : void 0;
+}
+__name(exactQueryAllowlist, "exactQueryAllowlist");
+function resolveQueryAllowlist(allowlist, pathname) {
+  if (!allowlist) {
+    return /* @__PURE__ */ new Set();
+  }
+  for (const [pattern, params] of Object.entries(allowlist)) {
+    if (matchLiteralPattern(pattern, pathname)) {
+      return new Set(params);
+    }
+  }
+  return /* @__PURE__ */ new Set();
+}
+__name(resolveQueryAllowlist, "resolveQueryAllowlist");
+function packIsrValue(headers, body) {
+  const headerJson = new TextEncoder().encode(JSON.stringify(headers));
+  const buffer = new ArrayBuffer(4 + headerJson.byteLength + body.byteLength);
+  const view = new DataView(buffer);
+  view.setUint32(0, headerJson.byteLength, true);
+  new Uint8Array(buffer, 4, headerJson.byteLength).set(headerJson);
+  new Uint8Array(buffer, 4 + headerJson.byteLength).set(new Uint8Array(body));
+  return buffer;
+}
+__name(packIsrValue, "packIsrValue");
+function unpackIsrValue(buffer) {
+  if (buffer.byteLength < 4) {
+    return null;
+  }
+  const view = new DataView(buffer);
+  const headerLength = view.getUint32(0, true);
+  if (buffer.byteLength < 4 + headerLength) {
+    return null;
+  }
+  try {
+    const headerBytes = new Uint8Array(buffer, 4, headerLength);
+    const parsed = JSON.parse(new TextDecoder().decode(headerBytes));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(parsed)) {
+      if (typeof value !== "string") {
+        return null;
+      }
+      headers[name] = value;
+    }
+    return { headers, body: buffer.slice(4 + headerLength) };
+  } catch {
+    return null;
+  }
+}
+__name(unpackIsrValue, "unpackIsrValue");
+function decodeIsrCacheEntry(value, metadata) {
+  if (!value || !metadata) {
+    return null;
+  }
+  const unpacked = unpackIsrValue(value);
+  if (!unpacked) {
+    return null;
+  }
+  if (!Number.isInteger(metadata.s) || metadata.s < 200 || metadata.s > 599) {
+    return null;
+  }
+  if (!Number.isFinite(metadata.c) || metadata.c <= 0 || !Number.isFinite(metadata.t) || metadata.t <= 0 || metadata.p !== SHARED_CACHE_POLICY_VERSION) {
+    return null;
+  }
+  try {
+    new Headers(unpacked.headers);
+  } catch {
+    return null;
+  }
+  return {
+    body: new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(unpacked.body));
+        controller.close();
+      }
+    }),
+    status: metadata.s,
+    headers: unpacked.headers,
+    createdAt: metadata.c,
+    ttl: metadata.t
+  };
+}
+__name(decodeIsrCacheEntry, "decodeIsrCacheEntry");
+function isStale(entry, now = Date.now()) {
+  return now - entry.createdAt > entry.ttl * 1e3;
+}
+__name(isStale, "isStale");
+function isrCacheResponse(entry, stale, now = Date.now()) {
+  const headers = new Headers(entry.headers);
+  headers.set("x-isr-cache", stale ? "STALE" : "HIT");
+  if (stale) {
+    headers.set(
+      "Cache-Control",
+      `public, s-maxage=${Math.min(10, entry.ttl)}, max-age=0, must-revalidate`
+    );
+  } else {
+    const remainingSeconds = Math.max(
+      0,
+      Math.floor((entry.createdAt + entry.ttl * 1e3 - now) / 1e3)
+    );
+    headers.set(
+      "Cache-Control",
+      `public, s-maxage=${remainingSeconds}, max-age=0, must-revalidate`
+    );
+  }
+  markSharedCachePolicy(headers);
+  return new Response(entry.body, { status: entry.status, headers });
+}
+__name(isrCacheResponse, "isrCacheResponse");
+function resolveRevalidateTtl(response, defaultTtl) {
+  const header = response.headers.get("x-revalidate");
+  if (header === null) {
+    return defaultTtl;
+  }
+  const value = Number.parseInt(header, 10);
+  return Number.isNaN(value) || value < 0 ? defaultTtl : value;
+}
+__name(resolveRevalidateTtl, "resolveRevalidateTtl");
+function acceptsEventStream(request) {
+  return request.headers.get("Accept")?.toLowerCase().split(",").some((part) => part.split(";", 1)[0]?.trim() === "text/event-stream") ?? false;
+}
+__name(acceptsEventStream, "acceptsEventStream");
+function shouldBypassIsr(request) {
+  return request.headers.has("Cookie") || request.headers.has("Authorization") || acceptsEventStream(request);
+}
+__name(shouldBypassIsr, "shouldBypassIsr");
+function hasSharedCacheOptOut(response) {
+  if (response.headers.has("Set-Cookie")) {
+    return true;
+  }
+  const cacheControl = response.headers.get("Cache-Control");
+  if (!cacheControl) {
+    return false;
+  }
+  return cacheControl.split(",").some((part) => {
+    const directive = part.split("=", 1)[0]?.trim().toLowerCase();
+    return directive === "private" || directive === "no-store" || directive === "no-cache";
+  });
+}
+__name(hasSharedCacheOptOut, "hasSharedCacheOptOut");
+function resolvePathTtl(revalidate, pathname) {
+  if (revalidate == null) {
+    return 0;
+  }
+  if (typeof revalidate === "number") {
+    return revalidate;
+  }
+  for (const [pattern, ttl] of Object.entries(revalidate)) {
+    if (matchSegmentPattern(pattern, pathname)) {
+      return ttl;
+    }
+  }
+  return 0;
+}
+__name(resolvePathTtl, "resolvePathTtl");
+function resolvePageTtl(pages, revalidate, pathRevalidate, pathname) {
+  if (pages) {
+    for (const page of pages) {
+      if (!matchSegmentPattern(page.pattern, pathname)) {
+        continue;
+      }
+      return page.revalidate === void 0 ? resolvePathTtl(pathRevalidate, pathname) : page.revalidate > 0 ? page.revalidate : 0;
+    }
+  }
+  return resolvePathTtl(revalidate, pathname);
+}
+__name(resolvePageTtl, "resolvePageTtl");
+function serializeHeaders(response) {
+  const result = {};
+  response.headers.forEach((value, key) => {
+    if (!SKIP_HEADERS.has(key.toLowerCase())) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+__name(serializeHeaders, "serializeHeaders");
+function normalizePageDataForJsonCache(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed.deferred === void 0 && parsed.deferredKeys === void 0 ? raw : null;
+  } catch {
+    return null;
+  }
+}
+__name(normalizePageDataForJsonCache, "normalizePageDataForJsonCache");
+function extractPageDataFromHtml(html) {
+  const match = html.match(PAGE_DATA_SCRIPT_RE);
+  return match ? normalizePageDataForJsonCache(match[2]) : null;
+}
+__name(extractPageDataFromHtml, "extractPageDataFromHtml");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/isr.ts
+var MAX_ISR_VARIANTS_PER_PATH = 200;
+async function readIsrCache(env, projectId, deploymentId, host, pathname, originalUrl) {
+  const key = isrCacheKey(projectId, deploymentId, host, pathname, originalUrl);
+  const { value, metadata } = await env.ISR_CACHE.getWithMetadata(
+    key,
+    "arrayBuffer"
+  );
+  return decodeIsrCacheEntry(value, metadata);
+}
+__name(readIsrCache, "readIsrCache");
+async function deleteIsrCache(env, projectId, deploymentId, host, pathname, originalUrl) {
+  const key = isrCacheKey(projectId, deploymentId, host, pathname, originalUrl);
+  await env.ISR_CACHE.delete(key);
+}
+__name(deleteIsrCache, "deleteIsrCache");
+async function writeIsrCache(env, projectId, deploymentId, host, pathname, response, ttl, originalUrl) {
+  const key = isrCacheKey(projectId, deploymentId, host, pathname, originalUrl);
+  const responseClone = response.clone();
+  const headers = serializeHeaders(responseClone);
+  const status = responseClone.status;
+  if (originalUrl && !await isVariantWriteAllowed(env, projectId, deploymentId, host, pathname, key)) {
+    return;
+  }
+  const body = await responseClone.arrayBuffer();
+  const packed = packIsrValue(headers, body);
+  await env.ISR_CACHE.put(key, packed, {
+    metadata: {
+      s: status,
+      c: Date.now(),
+      t: ttl,
+      p: SHARED_CACHE_POLICY_VERSION
+    }
+  });
+}
+__name(writeIsrCache, "writeIsrCache");
+async function isVariantWriteAllowed(env, projectId, deploymentId, host, pathname, key) {
+  const prefix = isrCacheVariantPrefix(projectId, deploymentId, host, pathname);
+  const listed = await env.ISR_CACHE.list({ prefix, limit: 1e3 });
+  if (listed.keys.length < MAX_ISR_VARIANTS_PER_PATH) {
+    return true;
+  }
+  return listed.keys.some((cacheKey) => cacheKey.name === key);
+}
+__name(isVariantWriteAllowed, "isVariantWriteAllowed");
+function matchedPageTtl(page, pathRevalidate, pathname) {
+  if (page.revalidate === void 0) {
+    return resolvePathTtl(pathRevalidate, pathname);
+  }
+  return page.revalidate > 0 ? page.revalidate : 0;
+}
+__name(matchedPageTtl, "matchedPageTtl");
+function isLiteralPattern(pattern) {
+  return !/[:{*]/.test(pattern);
+}
+__name(isLiteralPattern, "isLiteralPattern");
+function matchesLiteralPage(pages, target, pathRevalidate) {
+  if (!pages) {
+    return false;
+  }
+  for (const page of pages) {
+    if (matchSegmentPattern(page.pattern, target)) {
+      return isLiteralPattern(page.pattern) && matchedPageTtl(page, pathRevalidate, target) > 0;
+    }
+  }
+  return false;
+}
+__name(matchesLiteralPage, "matchesLiteralPage");
+function isBroadCatchAll(pattern) {
+  return pattern.includes("*") || pattern.includes("{.+}");
+}
+__name(isBroadCatchAll, "isBroadCatchAll");
+function isDottedPathIsrEligible(pages, revalidate, pathRevalidate, pathname) {
+  if (pages && pages.length > 0) {
+    for (const page of pages) {
+      if (matchSegmentPattern(page.pattern, pathname)) {
+        return matchedPageTtl(page, pathRevalidate, pathname) > 0 && !isBroadCatchAll(page.pattern);
+      }
+    }
+  }
+  if (revalidate && typeof revalidate === "object") {
+    for (const [pattern, ttl] of Object.entries(revalidate)) {
+      if (matchSegmentPattern(pattern, pathname)) {
+        return ttl > 0 && !isBroadCatchAll(pattern);
+      }
+    }
+  }
+  return false;
+}
+__name(isDottedPathIsrEligible, "isDottedPathIsrEligible");
+function isrEdgeCacheKey(request, pathname, deploymentId, originalUrl) {
+  return new Request(
+    isrEdgeCacheUrl(new URL(request.url).hostname, pathname, deploymentId, "html", originalUrl),
+    { method: "GET" }
+  );
+}
+__name(isrEdgeCacheKey, "isrEdgeCacheKey");
+function isrEdgeCacheKeyJson(request, pathname, deploymentId, originalUrl) {
+  return new Request(
+    isrEdgeCacheUrl(new URL(request.url).hostname, pathname, deploymentId, "json", originalUrl),
+    { method: "GET" }
+  );
+}
+__name(isrEdgeCacheKeyJson, "isrEdgeCacheKeyJson");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/api/src/usage-auth.ts
+var USAGE_PROTOCOL_VERSION = PLATFORM_USAGE_PROTOCOL_VERSION;
+var USAGE_SIGNING_KEY_KV_KEY = "__void:usage-signing-key:v1";
+var SANDBOX_USAGE_RETENTION_MS = 8 * 24 * 60 * 6e4;
+var encoder = new TextEncoder();
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of new Uint8Array(bytes)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+__name(base64url, "base64url");
+async function hmac(data, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return crypto.subtle.sign("HMAC", key, encoder.encode(data));
+}
+__name(hmac, "hmac");
+async function readUsageSigningKey(routing) {
+  return routing.get(USAGE_SIGNING_KEY_KV_KEY, { cacheTtl: 60 });
+}
+__name(readUsageSigningKey, "readUsageSigningKey");
+function signedPayload(source, eventId, event) {
+  return JSON.stringify([USAGE_PROTOCOL_VERSION, source, eventId, event]);
+}
+__name(signedPayload, "signedPayload");
+async function signUsageEvent(key, source, eventId, event) {
+  return {
+    version: USAGE_PROTOCOL_VERSION,
+    source,
+    eventId,
+    event,
+    signature: base64url(await hmac(signedPayload(source, eventId, event), key))
+  };
+}
+__name(signUsageEvent, "signUsageEvent");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/metering.ts
+function recordRequest(env, data) {
+  env.ANALYTICS.writeDataPoint({
+    indexes: [data.projectId],
+    blobs: [
+      data.projectId,
+      data.type,
+      data.method,
+      String(data.status),
+      data.slug,
+      data.failureKind ?? ""
+    ],
+    doubles: [1, data.responseBytes, data.durationMs]
+  });
+}
+__name(recordRequest, "recordRequest");
+function splitWorkerName(workerName) {
+  if (!workerName.startsWith("user-")) {
+    return null;
+  }
+  const dplIndex = workerName.lastIndexOf("-dpl_");
+  if (dplIndex > 4) {
+    return {
+      projectKey: workerName.slice(0, dplIndex),
+      deployId: workerName.slice(dplIndex + 1)
+    };
+  }
+  return { projectKey: workerName, deployId: "" };
+}
+__name(splitWorkerName, "splitWorkerName");
+var MAX_LOG_URL_BYTES = 2048;
+var MAX_LOG_PATH_BYTES = 1024;
+function truncateUtf8(value, maxBytes) {
+  const encoded = new TextEncoder().encode(value);
+  if (encoded.length <= maxBytes) {
+    return value;
+  }
+  const ellipsis = "\u2026";
+  if (maxBytes < 3) {
+    return "";
+  }
+  let end = maxBytes - 3;
+  while (end > 0 && (encoded[end] & 192) === 128) {
+    end--;
+  }
+  return new TextDecoder().decode(encoded.slice(0, end)) + ellipsis;
+}
+__name(truncateUtf8, "truncateUtf8");
+function recordPlatformLog(env, data) {
+  if (!data.workerName) {
+    return;
+  }
+  const parsed = splitWorkerName(data.workerName);
+  if (!parsed) {
+    return;
+  }
+  let pathname = data.url;
+  try {
+    pathname = new URL(data.url).pathname;
+  } catch {
+  }
+  const message = `Void platform: your worker did not respond within ${data.timeoutMs} ms. ${data.method} ${truncateUtf8(pathname, MAX_LOG_PATH_BYTES)} was cut short and returned ${data.status}. Your code keeps running to completion; the platform does not cancel it.`;
+  try {
+    env.LOGS.writeDataPoint({
+      // `projectKey` is NOT truncated. It is the read key, so a shortened one
+      // would produce a row `GET /projects/:id/logs` can never select — worse
+      // than no row. It is bounded upstream by the project slug, and the tail
+      // worker writes the same value whole.
+      indexes: [parsed.projectKey],
+      blobs: [
+        "canceled",
+        JSON.stringify([{ level: "error", message: [message], timestamp: Date.now() }]),
+        "[]",
+        truncateUtf8(data.url, MAX_LOG_URL_BYTES),
+        data.method,
+        String(data.status),
+        parsed.deployId
+      ],
+      doubles: [Date.now(), data.status]
+    });
+  } catch {
+  }
+}
+__name(recordPlatformLog, "recordPlatformLog");
+async function sendUsageEvent(env, data) {
+  const key = await readUsageSigningKey(env.ROUTING);
+  if (!key) {
+    throw new Error("Usage metering is not initialized. Check the platform API /health endpoint.");
+  }
+  const eventId = crypto.randomUUID();
+  await env.USAGE_QUEUE.send(await signUsageEvent(key, "dispatch", eventId, data));
+}
+__name(sendUsageEvent, "sendUsageEvent");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/platform-lifecycle.ts
+var PLATFORM_DISABLED_KEY = "__void/platform/disabled/v1";
+var PLATFORM_DISABLED_VALUE = "disabled";
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/constants.ts
+var SITE_DOMAIN = "void.app";
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/hostname.ts
+function extractSlug(hostname, baseHostname = SITE_DOMAIN) {
+  const suffix = `.${baseHostname}`;
+  if (!hostname.endsWith(suffix)) {
+    return null;
+  }
+  const slug = hostname.slice(0, -suffix.length);
+  if (!slug || slug.includes(".")) {
+    return null;
+  }
+  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(slug)) {
+    return null;
+  }
+  return slug;
+}
+__name(extractSlug, "extractSlug");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/project-hostname.ts
+async function resolveProjectHostname(hostname, env) {
+  const application = readPlatformApplication(env);
+  const isWorkersDev = !!application.workersDev && hostname.endsWith(`.${application.workersDev.subdomain}.workers.dev`);
+  if (!isWorkersDev) {
+    return { slug: extractSlug(hostname, env.BASE_HOSTNAME), workersDev: false };
+  }
+  const raw = await env.ROUTING.get(platformWorkersDevAliasKey(hostname));
+  if (raw) {
+    const project = JSON.parse(raw);
+    if (platformProjectWorkersDevHostname(project, application.workersDev) === hostname) {
+      return { slug: project.slug, projectId: project.id, workersDev: true };
+    }
+  }
+  return { slug: null, workersDev: true };
+}
+__name(resolveProjectHostname, "resolveProjectHostname");
+function isTestHostname(request) {
+  return new URL(
+    typeof request === "string" || request instanceof URL ? request : request.url
+  ).hostname.endsWith(".workers.dev");
+}
+__name(isTestHostname, "isTestHostname");
+var applicationEdgeCache = {
+  async match(request, options) {
+    return isTestHostname(request) ? void 0 : caches.default.match(request, options);
+  },
+  async put(request, response) {
+    if (!isTestHostname(request)) {
+      await caches.default.put(request, response);
+    }
+  },
+  async delete(request, options) {
+    return isTestHostname(request) ? false : caches.default.delete(request, options);
+  }
+};
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/request-type.ts
+function hasExtension(pathname) {
+  return pathname.slice(pathname.lastIndexOf("/") + 1).includes(".");
+}
+__name(hasExtension, "hasExtension");
+function classifyDynamicRequestType(pathname, ssr) {
+  if (pathname.startsWith("/api/") || pathname === "/api") {
+    return "api";
+  }
+  if (ssr && !hasExtension(pathname)) {
+    return "ssr";
+  }
+  return null;
+}
+__name(classifyDynamicRequestType, "classifyDynamicRequestType");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/with-timeout.ts
+var DispatchTimeoutError = class extends Error {
+  static {
+    __name(this, "DispatchTimeoutError");
+  }
+  label;
+  constructor(label) {
+    super(`Dispatch operation timed out: ${label}`);
+    this.name = "DispatchTimeoutError";
+    this.label = label;
+  }
+};
+function withTimeout(promise, ms, label) {
+  if (!(ms > 0) || !Number.isFinite(ms)) {
+    return promise;
+  }
+  let timer = null;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new DispatchTimeoutError(label));
+    }, ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    clearTimeout(timer);
+  });
+}
+__name(withTimeout, "withTimeout");
+async function withDelayedHedge(operation, options) {
+  const hedgeEnabled = options.delayMs > 0 && Number.isFinite(options.delayMs);
+  const timeoutEnabled = options.timeoutMs > 0 && Number.isFinite(options.timeoutMs);
+  const run = /* @__PURE__ */ __name(async () => {
+    try {
+      return { ok: true, value: await operation() };
+    } catch (error) {
+      return { ok: false, error };
+    }
+  }, "run");
+  const attempts = [];
+  const startAttempt = /* @__PURE__ */ __name(() => {
+    const attempt = { id: attempts.length + 1, promise: run() };
+    attempts.push(attempt);
+    return attempt;
+  }, "startAttempt");
+  let hedgeTimer = null;
+  const hedgeSignal = hedgeEnabled ? new Promise((resolve) => {
+    hedgeTimer = setTimeout(() => resolve({ kind: "hedge" }), options.delayMs);
+  }) : null;
+  let timeoutTimer = null;
+  const timeoutSignal = timeoutEnabled ? new Promise((resolve) => {
+    timeoutTimer = setTimeout(() => resolve({ kind: "timeout" }), options.timeoutMs);
+  }) : null;
+  const clearTimers = /* @__PURE__ */ __name(() => {
+    clearTimeout(hedgeTimer);
+    clearTimeout(timeoutTimer);
+  }, "clearTimers");
+  const discardAttempt = /* @__PURE__ */ __name((attempt) => {
+    void attempt.promise.then(async (outcome) => {
+      if (outcome.ok && outcome.value !== null) {
+        await options.discard?.(outcome.value);
+      }
+    }).catch(() => {
+    });
+  }, "discardAttempt");
+  const finish = /* @__PURE__ */ __name((winnerId) => {
+    clearTimers();
+    for (const attempt of attempts) {
+      if (attempt.id !== winnerId) {
+        discardAttempt(attempt);
+      }
+    }
+  }, "finish");
+  const timeout = /* @__PURE__ */ __name(() => {
+    finish();
+    throw new DispatchTimeoutError(options.label);
+  }, "timeout");
+  const waitForAttempt = /* @__PURE__ */ __name((attempt) => attempt.promise.then((outcome) => ({
+    kind: "attempt",
+    attempt,
+    outcome
+  })), "waitForAttempt");
+  const first = startAttempt();
+  const initial = await Promise.race([
+    waitForAttempt(first),
+    ...hedgeSignal ? [hedgeSignal] : [],
+    ...timeoutSignal ? [timeoutSignal] : []
+  ]);
+  if (initial.kind === "timeout") {
+    return timeout();
+  }
+  if (initial.kind === "attempt") {
+    clearTimeout(hedgeTimer);
+    if (initial.outcome.ok) {
+      finish(first.id);
+      return initial.outcome.value;
+    }
+    if (!hedgeEnabled) {
+      finish();
+      throw initial.outcome.error;
+    }
+    options.onHedge?.();
+    const retry = startAttempt();
+    const retried = await Promise.race([
+      waitForAttempt(retry),
+      ...timeoutSignal ? [timeoutSignal] : []
+    ]);
+    if (retried.kind === "timeout") {
+      return timeout();
+    }
+    finish(retry.id);
+    if (retried.outcome.ok) {
+      return retried.outcome.value;
+    }
+    throw retried.outcome.error;
+  }
+  options.onHedge?.();
+  const second = startAttempt();
+  const winner = await Promise.race([
+    waitForAttempt(first),
+    waitForAttempt(second),
+    ...timeoutSignal ? [timeoutSignal] : []
+  ]);
+  if (winner.kind === "timeout") {
+    return timeout();
+  }
+  if (winner.outcome.ok && winner.outcome.value !== null) {
+    finish(winner.attempt.id);
+    return winner.outcome.value;
+  }
+  const peer = winner.attempt.id === first.id ? second : first;
+  const peerResult = await Promise.race([
+    waitForAttempt(peer),
+    ...timeoutSignal ? [timeoutSignal] : []
+  ]);
+  if (peerResult.kind === "timeout") {
+    return timeout();
+  }
+  if (peerResult.outcome.ok && peerResult.outcome.value !== null) {
+    finish(peer.id);
+    return peerResult.outcome.value;
+  }
+  finish();
+  if (winner.outcome.ok || peerResult.outcome.ok) {
+    return null;
+  }
+  throw winner.outcome.error;
+}
+__name(withDelayedHedge, "withDelayedHedge");
+function resolveTimeoutMs(raw, fallback = 1e4) {
+  return raw === void 0 ? fallback : Number(raw);
+}
+__name(resolveTimeoutMs, "resolveTimeoutMs");
+
+// ../../../../../../../Users/cnakazawa/Projects/void/platform/packages/dispatch/src/index.ts
+var CLIENT_REVALIDATE_CACHE_CONTROL = "public, max-age=0, must-revalidate";
+var STATIC_ASSET_HEDGE_DELAY_MS = 1e3;
+var PLATFORM_QUEUE_RETRY_DELAY_SECONDS = 300;
+var PLATFORM_STATIC_ASSET_TIMEOUT = "platform-static-asset-timeout";
+var PLATFORM_STATIC_ASSET_ERROR = "platform-static-asset-error";
+var PLATFORM_STATIC_ASSET_MISSING = "platform-static-asset-missing";
+var ISR_STALE_EVICT_GRACE_SECONDS = 86400;
+function clientRevalidateResponse(response) {
+  const res = new Response(response.body, response);
+  res.headers.set("Cache-Control", CLIENT_REVALIDATE_CACHE_CONTROL);
+  res.headers.delete(SHARED_CACHE_POLICY_HEADER);
+  return res;
+}
+__name(clientRevalidateResponse, "clientRevalidateResponse");
+function timeoutResponse(status, label) {
+  return new Response(null, {
+    status,
+    headers: {
+      "X-Void-Timeout": label,
+      ...status === 503 ? { "Retry-After": "5" } : {}
+    }
+  });
+}
+__name(timeoutResponse, "timeoutResponse");
+function staticAssetFailureResponse(kind) {
+  if (kind === PLATFORM_STATIC_ASSET_TIMEOUT) {
+    return timeoutResponse(503, "static-asset");
+  }
+  return new Response(null, {
+    status: 503,
+    headers: {
+      "X-Void-Storage-Error": kind === PLATFORM_STATIC_ASSET_MISSING ? "static-asset-missing" : "static-asset-read",
+      "Retry-After": "5"
+    }
+  });
+}
+__name(staticAssetFailureResponse, "staticAssetFailureResponse");
+function isEventStreamResponse(response) {
+  return response.headers.get("content-type")?.toLowerCase().split(";", 1)[0]?.trim() === "text/event-stream";
+}
+__name(isEventStreamResponse, "isEventStreamResponse");
+function isHtmlResponse(response) {
+  return response.headers.get("content-type")?.toLowerCase().split(";", 1)[0]?.trim() === "text/html";
+}
+__name(isHtmlResponse, "isHtmlResponse");
+function jsonCacheResponse(pageData, ttl, state) {
+  const response = new Response(pageData, {
+    headers: {
+      "content-type": "application/json",
+      "Cache-Control": `public, s-maxage=${ttl}, max-age=0, must-revalidate`,
+      "x-isr-cache": state
+    }
+  });
+  markSharedCachePolicy(response.headers);
+  return response;
+}
+__name(jsonCacheResponse, "jsonCacheResponse");
+async function populateJsonEdgeCache(cache, cacheKey, response, ttl, state) {
+  const fromHeader = response.headers.get("x-void-page-data");
+  const pageData = fromHeader ? normalizePageDataForJsonCache(fromHeader) : extractPageDataFromHtml(await response.clone().text());
+  if (!pageData) {
+    return;
+  }
+  await cache.put(cacheKey, jsonCacheResponse(pageData, ttl, state));
+}
+__name(populateJsonEdgeCache, "populateJsonEdgeCache");
+async function deleteSharedIsrEntry(env, entry) {
+  await Promise.all([
+    deleteIsrCache(
+      env,
+      entry.projectId,
+      entry.deploymentId,
+      entry.host,
+      entry.pathname,
+      entry.originalUrl
+    ),
+    applicationEdgeCache.delete(entry.htmlKey),
+    applicationEdgeCache.delete(entry.jsonKey)
+  ]);
+}
+__name(deleteSharedIsrEntry, "deleteSharedIsrEntry");
+async function applyWorkerFallbackRules(opts) {
+  if (opts.response.status !== 404 || !opts.routing.fallbackRules?.length) {
+    return {
+      response: opts.response,
+      pathname: opts.pathname,
+      originalUrlVariant: opts.originalUrlVariant,
+      applied: false
+    };
+  }
+  if (opts.routing.type === "void" && opts.response.headers.get("X-Void-No-Match") !== "1") {
+    return {
+      response: opts.response,
+      pathname: opts.pathname,
+      originalUrlVariant: opts.originalUrlVariant,
+      applied: false
+    };
+  }
+  const fallback = applyRoutingRules(opts.pathname, opts.routing.fallbackRules, opts.url.hostname);
+  if (fallback?.type !== "rewrite") {
+    return {
+      response: opts.response,
+      pathname: opts.pathname,
+      originalUrlVariant: opts.originalUrlVariant,
+      applied: false
+    };
+  }
+  const fallbackHeader = opts.originalUrlHeader ?? opts.originalRequestUrl;
+  const originalUrlVariant = opts.originalUrlVariant ?? buildVariantOriginalUrl(opts.originalRequestUrl, opts.pathname, opts.routing.queryAllowlist);
+  const fallbackUrl = new URL(opts.url.toString());
+  fallbackUrl.pathname = fallback.destination;
+  const fallbackRequest = rebuildRequest(
+    opts.dispatchReq,
+    fallbackUrl.toString(),
+    (headers) => headers.set("X-Void-Original-URL", fallbackHeader)
+  );
+  return {
+    response: opts.deadline === void 0 ? await opts.worker.fetch(fallbackRequest) : await withTimeout(
+      opts.worker.fetch(fallbackRequest),
+      remainingTimeoutBudget(opts.deadline.startedAt, opts.deadline.timeoutMs, "dispatch"),
+      "dispatch"
+    ),
+    pathname: fallback.destination,
+    originalUrlVariant,
+    applied: true
+  };
+}
+__name(applyWorkerFallbackRules, "applyWorkerFallbackRules");
+function buildFallbackOriginalUrlVariant(requestUrl, pathname, requestHost, routing, originalUrlVariant) {
+  if (originalUrlVariant || !routing.fallbackRules?.length) {
+    return originalUrlVariant;
+  }
+  const fallback = applyRoutingRules(pathname, routing.fallbackRules, requestHost);
+  if (fallback?.type !== "rewrite") {
+    return void 0;
+  }
+  return buildVariantOriginalUrl(requestUrl, pathname, routing.queryAllowlist);
+}
+__name(buildFallbackOriginalUrlVariant, "buildFallbackOriginalUrlVariant");
+function resolveCachedWfpFallbackPathname(pathname, routing, requestHost) {
+  const fallback = applyRoutingRules(pathname, routing.fallbackRules, requestHost);
+  return fallback?.type === "rewrite" ? fallback.destination : void 0;
+}
+__name(resolveCachedWfpFallbackPathname, "resolveCachedWfpFallbackPathname");
+var CF_ASSETS_STUB_MARKER = "Assets have not yet been deployed to this script";
+function isLikelyCfAssetStub(response) {
+  if (response.status !== 200) {
+    return false;
+  }
+  const contentType = response.headers.get("content-type")?.toLowerCase();
+  if (!contentType?.startsWith("text/plain")) {
+    return false;
+  }
+  const contentLengthRaw = response.headers.get("content-length");
+  if (!contentLengthRaw) {
+    return false;
+  }
+  const contentLength = Number.parseInt(contentLengthRaw, 10);
+  return contentLength > 0 && contentLength < 200;
+}
+__name(isLikelyCfAssetStub, "isLikelyCfAssetStub");
+function remainingTimeoutBudget(startedAt, timeoutMs, label = "static-asset") {
+  if (!(timeoutMs > 0 && Number.isFinite(timeoutMs))) {
+    return timeoutMs;
+  }
+  const remainingMs = timeoutMs - (Date.now() - startedAt);
+  if (remainingMs <= 0) {
+    throw new DispatchTimeoutError(label);
+  }
+  return remainingMs;
+}
+__name(remainingTimeoutBudget, "remainingTimeoutBudget");
+async function fetchAssetManifest(env, deploymentId, projectId, timeoutMs) {
+  const hedgeDelayMs = timeoutMs > 0 && Number.isFinite(timeoutMs) ? Math.min(STATIC_ASSET_HEDGE_DELAY_MS, timeoutMs / 2) : 0;
+  try {
+    const raw = await withDelayedHedge(
+      () => env.ROUTING.get(`manifest:${deploymentId}`, { cacheTtl: 86400 }),
+      {
+        delayMs: hedgeDelayMs,
+        timeoutMs,
+        label: "static-asset",
+        onHedge: /* @__PURE__ */ __name(() => {
+          console.warn(
+            JSON.stringify({
+              event: "wfp-asset-manifest-read-hedge",
+              projectId,
+              deploymentId,
+              delayMs: hedgeDelayMs,
+              ts: Date.now()
+            })
+          );
+        }, "onHedge")
+      }
+    );
+    if (!raw) {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        event: error instanceof DispatchTimeoutError ? "wfp-asset-manifest-timeout" : "wfp-asset-manifest-read-error",
+        projectId,
+        deploymentId,
+        error: error instanceof DispatchTimeoutError ? void 0 : error instanceof Error ? error.message : String(error),
+        ts: Date.now()
+      })
+    );
+    if (error instanceof DispatchTimeoutError) {
+      throw error;
+    }
+    throw new StaticAssetReadError(error);
+  }
+}
+__name(fetchAssetManifest, "fetchAssetManifest");
+async function serveWfpAssetFallback(env, routing, pathname, timeoutMs = 1e4, fallbackPathname) {
+  if (!routing.assetManifestId) {
+    return null;
+  }
+  const startedAt = Date.now();
+  const assetManifest = await fetchAssetManifest(
+    env,
+    routing.assetManifestId,
+    routing.projectId,
+    remainingTimeoutBudget(startedAt, timeoutMs)
+  );
+  if (!assetManifest) {
+    return null;
+  }
+  const assetConfig = routing.assetConfig ?? { not_found_handling: "none" };
+  let resolvedPathname = pathname;
+  let resolved = resolveStaticPath(pathname, assetManifest, assetConfig);
+  if ((!resolved || resolved.notFound) && fallbackPathname && fallbackPathname !== pathname) {
+    const fallbackResolved = resolveStaticPath(fallbackPathname, assetManifest, assetConfig);
+    if (fallbackResolved && !fallbackResolved.notFound) {
+      resolved = fallbackResolved;
+      resolvedPathname = fallbackPathname;
+    }
+  }
+  if (!resolved) {
+    return null;
+  }
+  if (resolved.redirect) {
+    return {
+      response: new Response(null, {
+        status: 308,
+        headers: { Location: resolved.redirect }
+      }),
+      pathname: resolvedPathname
+    };
+  }
+  const assetResponse = await fetchStaticAsset(
+    env,
+    resolved.hash,
+    resolved.path,
+    routing.projectId,
+    routing.assetManifestId,
+    remainingTimeoutBudget(startedAt, timeoutMs)
+  );
+  if (!assetResponse) {
+    return null;
+  }
+  return {
+    response: new Response(assetResponse.body, {
+      status: resolved.notFound ? 404 : 200,
+      headers: assetResponse.headers
+    }),
+    pathname: resolvedPathname
+  };
+}
+__name(serveWfpAssetFallback, "serveWfpAssetFallback");
+function logWfpAssetFallback(routing, pathname, userAgent) {
+  console.log(
+    JSON.stringify({
+      event: "wfp-asset-fallback",
+      projectId: routing.projectId,
+      deploymentId: routing.assetManifestId,
+      pathname,
+      userAgent,
+      ts: Date.now()
+    })
+  );
+}
+__name(logWfpAssetFallback, "logWfpAssetFallback");
+async function maybeServeWfpAssetFallback(opts) {
+  const startedAt = opts.deadline?.startedAt ?? Date.now();
+  const timeoutMs = opts.deadline?.timeoutMs ?? opts.timeoutMs ?? 1e4;
+  if (isEventStreamResponse(opts.response)) {
+    return { response: opts.response, pathname: opts.pathname };
+  }
+  if (!isLikelyCfAssetStub(opts.response)) {
+    return { response: opts.response, pathname: opts.pathname };
+  }
+  let stubConfirmed = false;
+  let fallback;
+  try {
+    const body = await withTimeout(
+      opts.response.clone().text(),
+      remainingTimeoutBudget(startedAt, timeoutMs),
+      "static-asset"
+    );
+    if (!body.includes(CF_ASSETS_STUB_MARKER)) {
+      return { response: opts.response, pathname: opts.pathname };
+    }
+    stubConfirmed = true;
+    fallback = await serveWfpAssetFallback(
+      opts.env,
+      opts.routing,
+      opts.pathname,
+      remainingTimeoutBudget(startedAt, timeoutMs),
+      opts.fallbackPathname
+    );
+  } catch (error) {
+    if (error instanceof DispatchTimeoutError) {
+      if (!stubConfirmed) {
+        return {
+          response: timeoutResponse(503, "dispatch"),
+          pathname: opts.pathname
+        };
+      }
+      return {
+        response: staticAssetFailureResponse(PLATFORM_STATIC_ASSET_TIMEOUT),
+        failureKind: PLATFORM_STATIC_ASSET_TIMEOUT,
+        pathname: opts.pathname
+      };
+    }
+    if (error instanceof StaticAssetReadError) {
+      return {
+        response: staticAssetFailureResponse(PLATFORM_STATIC_ASSET_ERROR),
+        failureKind: PLATFORM_STATIC_ASSET_ERROR,
+        pathname: opts.pathname
+      };
+    }
+    throw error;
+  }
+  if (!fallback) {
+    console.error(
+      JSON.stringify({
+        event: "wfp-asset-fallback-missing",
+        projectId: opts.routing.projectId,
+        deploymentId: opts.routing.assetManifestId,
+        pathname: opts.pathname,
+        ts: Date.now()
+      })
+    );
+    return {
+      response: staticAssetFailureResponse(PLATFORM_STATIC_ASSET_MISSING),
+      failureKind: PLATFORM_STATIC_ASSET_MISSING,
+      pathname: opts.pathname
+    };
+  }
+  logWfpAssetFallback(opts.routing, fallback.pathname, opts.userAgent);
+  return fallback;
+}
+__name(maybeServeWfpAssetFallback, "maybeServeWfpAssetFallback");
+function rebuildRequest(request, url, mutateHeaders) {
+  const headers = new Headers(request.headers);
+  mutateHeaders(headers);
+  const cfProperties = request.cf;
+  if (request.bodyUsed || request.body?.locked) {
+    headers.delete("content-length");
+    headers.delete("transfer-encoding");
+    return new Request(url, { method: request.method, headers, cf: cfProperties });
+  }
+  if (request.method === "GET" || request.method === "HEAD") {
+    return new Request(url, { method: request.method, headers, cf: cfProperties });
+  }
+  return new Request(url, {
+    method: request.method,
+    headers,
+    body: request.body,
+    cf: cfProperties,
+    // @ts-expect-error -- duplex required for streaming bodies in CF Workers
+    duplex: "half"
+  });
+}
+__name(rebuildRequest, "rebuildRequest");
+var index_default = {
+  async fetch(request, env, ctx) {
+    env = await resolvePlatformApplicationEnvironment(env);
+    const url = new URL(request.url);
+    if (!env.PLATFORM_INSTALLATION_ID && url.pathname === "/health" && request.headers.get("X-Health-Check") === "void-admin") {
+      return Response.json({ ok: true });
+    }
+    if (env.PLATFORM_HEALTH_PROBE_TOKEN && url.pathname === "/health" && request.headers.get("X-Void-Platform-Probe") === env.PLATFORM_HEALTH_PROBE_TOKEN) {
+      return Response.json({
+        ok: true,
+        ...env.PLATFORM_APPLICATION ? { installationId: env.PLATFORM_INSTALLATION_ID } : {}
+      });
+    }
+    if (env.PLATFORM_TRAFFIC_STATE === "staging" || env.PLATFORM_TRAFFIC_STATE === "sandbox-drain" || env.PLATFORM_INSTALLATION_ID && await env.ROUTING.get(PLATFORM_DISABLED_KEY) === PLATFORM_DISABLED_VALUE) {
+      return createErrorResponse(request, 503, "Platform disabled", {
+        "Cache-Control": "no-store"
+      });
+    }
+    const startTime = Date.now();
+    const timeoutMs = resolveTimeoutMs(env.DISPATCH_TIMEOUT_MS);
+    if (url.pathname.startsWith("/__void/") || // Legacy: old SDK versions register these top-level paths. Block them
+    // at the edge so we don't rely solely on worker-side token checks.
+    // TODO: remove once all deployed workers use /__void/* paths. See #88
+    url.pathname === "/__scheduled" || url.pathname === "/__queue") {
+      return createErrorResponse(request, 404, "Not Found");
+    }
+    const selected = await resolveProjectHostname(url.hostname, env);
+    const slug = selected.slug;
+    if (selected.workersDev && !selected.projectId) {
+      return createErrorResponse(request, 404, "Not Found");
+    }
+    const routingKey = slug ?? `domain:${url.hostname}`;
+    const routingRaw = await env.ROUTING.get(routingKey, { cacheTtl: 60 });
+    if (!routingRaw) {
+      return createErrorResponse(request, 404, "Not Found", {
+        "Cache-Control": "public, max-age=30"
+      });
+    }
+    const routing = JSON.parse(routingRaw);
+    if (selected.projectId && selected.projectId !== routing.projectId) {
+      return createErrorResponse(request, 404, "Not Found");
+    }
+    if (routing.suspended) {
+      return Response.json(
+        { error: "usage limit exceeded", reason: routing.suspended },
+        { status: 429, headers: { "Cache-Control": "public, s-maxage=30, max-age=0" } }
+      );
+    }
+    if (request.headers.has("X-Void-Original-URL")) {
+      request = rebuildRequest(
+        request,
+        request.url,
+        (headers) => headers.delete("X-Void-Original-URL")
+      );
+    }
+    let pathname = url.pathname;
+    let sharedIsrEntry;
+    let requestType = request.headers.get("upgrade")?.toLowerCase() === "websocket" ? "websocket" : "static";
+    const meter = /* @__PURE__ */ __name((response, options) => {
+      const responseBytes = isEventStreamResponse(response) ? 0 : Number(response.headers.get("content-length") ?? 0);
+      recordRequest(env, {
+        projectId: routing.projectId,
+        type: requestType,
+        method: request.method,
+        status: response.status,
+        responseBytes,
+        durationMs: Date.now() - startTime,
+        slug: slug ?? url.hostname,
+        ...options?.failureKind && { failureKind: options.failureKind }
+      });
+      if (routing.userId) {
+        ctx.waitUntil(
+          sendUsageEvent(env, {
+            projectId: routing.projectId,
+            userId: routing.userId,
+            slug: slug ?? url.hostname,
+            requests: 1,
+            responseBytes,
+            ...response.status >= 500 && { status: response.status },
+            ...options?.failureKind && { failureKind: options.failureKind }
+          })
+        );
+      }
+      const res = new Response(response.body, response);
+      res.headers.delete("X-Void-No-Match");
+      res.headers.set("X-Hosted-By", "void.cloud");
+      return res;
+    }, "meter");
+    const meterWorkerTimeout = /* @__PURE__ */ __name(() => {
+      recordPlatformLog(env, {
+        workerName: routing.workerName,
+        method: request.method,
+        url: request.url,
+        status: 503,
+        timeoutMs
+      });
+      return meter(timeoutResponse(503, "dispatch"));
+    }, "meterWorkerTimeout");
+    let originalUrlVariant;
+    let originalUrlHeader;
+    if (routing.redirectRules?.length) {
+      const result = applyRoutingRules(pathname, routing.redirectRules, url.hostname);
+      if (result?.type === "redirect") {
+        const location = mergeQueryIntoLocation(result.destination, url.search);
+        return meter(
+          new Response(null, { status: result.status, headers: { Location: location } })
+        );
+      }
+      if (result?.type === "rewrite") {
+        originalUrlHeader = request.url;
+        originalUrlVariant = buildVariantOriginalUrl(request.url, pathname, routing.queryAllowlist);
+        pathname = result.destination;
+        url.pathname = pathname;
+      }
+    }
+    let workerRequest = request;
+    if (originalUrlHeader) {
+      workerRequest = rebuildRequest(
+        request,
+        url.toString(),
+        (headers) => headers.set("X-Void-Original-URL", originalUrlHeader)
+      );
+    }
+    if (routing.hashedAssetsPrefix && isSharedStaticCacheRequestEligible(request)) {
+      const prefix = "/" + routing.hashedAssetsPrefix + "/";
+      if (pathname.startsWith(prefix)) {
+        const cacheUrl = new URL(url.toString());
+        cacheUrl.search = "";
+        const cacheKey = new Request(cacheUrl.toString());
+        const MANAGED_ASSET_HEADERS = [
+          "cache-control",
+          "content-type",
+          "content-encoding",
+          "content-length",
+          "content-range",
+          "accept-ranges",
+          "transfer-encoding"
+        ];
+        const finalizeAsset = /* @__PURE__ */ __name((assetResponse, failureKind) => {
+          const ruled = applyHeaderRules(assetResponse, pathname, routing.headerRules);
+          if (ruled !== assetResponse) {
+            for (const name of MANAGED_ASSET_HEADERS) {
+              const managed = assetResponse.headers.get(name);
+              if (managed === null) {
+                ruled.headers.delete(name);
+              } else {
+                ruled.headers.set(name, managed);
+              }
+            }
+          }
+          ruled.headers.delete(SHARED_CACHE_POLICY_HEADER);
+          return meter(ruled, failureKind ? { failureKind } : void 0);
+        }, "finalizeAsset");
+        const cache = applicationEdgeCache;
+        const cached = await cache.match(cacheKey);
+        if (cached?.headers.get("Cache-Control")?.includes("immutable") && isCurrentStaticCacheResponse(cached)) {
+          if (!routing.staticDeploymentId) {
+            const repairResult = await maybeServeWfpAssetFallback({
+              env,
+              routing,
+              pathname,
+              response: cached,
+              userAgent: request.headers.get("user-agent"),
+              timeoutMs
+            });
+            if (repairResult.response !== cached) {
+              if (isStaticCacheResponseEligible(repairResult.response)) {
+                const repaired = new Response(repairResult.response.body, repairResult.response);
+                repaired.headers.set("Cache-Control", "public, max-age=31536000, immutable");
+                markSharedCachePolicy(repaired.headers);
+                const repairedForCache = repaired.clone();
+                ctx.waitUntil(
+                  cache.delete(cacheKey).then(() => cache.put(cacheKey, repairedForCache))
+                );
+                return finalizeAsset(repaired, repairResult.failureKind);
+              }
+              ctx.waitUntil(cache.delete(cacheKey));
+              return finalizeAsset(repairResult.response, repairResult.failureKind);
+            }
+          }
+          return finalizeAsset(cached);
+        }
+        if (cached) {
+          await cache.delete(cacheKey);
+        }
+        if (routing.staticDeploymentId) {
+          const staticAssetStartedAt = Date.now();
+          let assetManifest;
+          try {
+            assetManifest = await fetchAssetManifest(
+              env,
+              routing.staticDeploymentId,
+              routing.projectId,
+              remainingTimeoutBudget(staticAssetStartedAt, timeoutMs)
+            );
+          } catch (err) {
+            if (err instanceof DispatchTimeoutError) {
+              return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_TIMEOUT), {
+                failureKind: PLATFORM_STATIC_ASSET_TIMEOUT
+              });
+            }
+            if (err instanceof StaticAssetReadError) {
+              return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_ERROR), {
+                failureKind: PLATFORM_STATIC_ASSET_ERROR
+              });
+            }
+            throw err;
+          }
+          if (!assetManifest) {
+            return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_MISSING), {
+              failureKind: PLATFORM_STATIC_ASSET_MISSING
+            });
+          }
+          let assetPath = pathname;
+          let hash = assetManifest[pathname];
+          if (!hash) {
+            const decoded = safeDecodePathname(pathname);
+            if (decoded !== pathname && assetManifest[decoded]) {
+              assetPath = decoded;
+              hash = assetManifest[decoded];
+            }
+          }
+          let response;
+          if (hash) {
+            try {
+              const assetResponse = await fetchStaticAsset(
+                env,
+                hash,
+                assetPath,
+                routing.projectId,
+                routing.staticDeploymentId,
+                remainingTimeoutBudget(staticAssetStartedAt, timeoutMs)
+              );
+              if (!assetResponse) {
+                logStaticAssetMissing(routing, assetPath, hash);
+                return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_MISSING), {
+                  failureKind: PLATFORM_STATIC_ASSET_MISSING
+                });
+              }
+              response = assetResponse;
+            } catch (err) {
+              if (err instanceof DispatchTimeoutError) {
+                return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_TIMEOUT), {
+                  failureKind: PLATFORM_STATIC_ASSET_TIMEOUT
+                });
+              }
+              if (err instanceof StaticAssetReadError) {
+                return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_ERROR), {
+                  failureKind: PLATFORM_STATIC_ASSET_ERROR
+                });
+              }
+              throw err;
+            }
+          } else {
+            response = createErrorResponse(request, 404, "Not Found");
+          }
+          if (isStaticCacheResponseEligible(response)) {
+            const res = new Response(response.body, response);
+            res.headers.set("Cache-Control", "public, max-age=31536000, immutable");
+            markSharedCachePolicy(res.headers);
+            ctx.waitUntil(cache.put(cacheKey, res.clone()));
+            return finalizeAsset(res);
+          }
+          return finalizeAsset(response);
+        }
+        try {
+          const worker2 = getWorker(env, routing);
+          const wfpAssetStartedAt = Date.now();
+          let response = await withTimeout(
+            worker2.fetch(workerRequest),
+            remainingTimeoutBudget(wfpAssetStartedAt, timeoutMs),
+            "static-asset"
+          );
+          const fallbackResult = await maybeServeWfpAssetFallback({
+            env,
+            routing,
+            pathname,
+            response,
+            userAgent: request.headers.get("user-agent"),
+            deadline: { startedAt: wfpAssetStartedAt, timeoutMs }
+          });
+          response = fallbackResult.response;
+          const failureKind = fallbackResult.failureKind;
+          if (isStaticCacheResponseEligible(response)) {
+            const res = new Response(response.body, response);
+            res.headers.set("Cache-Control", "public, max-age=31536000, immutable");
+            markSharedCachePolicy(res.headers);
+            ctx.waitUntil(cache.put(cacheKey, res.clone()));
+            return finalizeAsset(res, failureKind);
+          }
+          return finalizeAsset(response, failureKind);
+        } catch (err) {
+          if (err instanceof DispatchTimeoutError) {
+            return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_TIMEOUT), {
+              failureKind: PLATFORM_STATIC_ASSET_TIMEOUT
+            });
+          }
+          if (err instanceof Error && err.message.includes("Worker exceeded")) {
+            return meter(Response.json({ error: "CPU limit exceeded" }, { status: 429 }));
+          }
+          throw err;
+        }
+      }
+    }
+    const isSsrPath = routing.ssr === true && isIsrEligiblePath(pathname, routing.pages, routing.revalidate, routing.pathRevalidate);
+    if (isSsrPath && (routing.revalidate || routing.pages?.length)) {
+      const isrTtl = resolvePageTtl(
+        routing.pages,
+        routing.revalidate,
+        routing.pathRevalidate,
+        pathname
+      );
+      if (isrTtl > 0 && request.method === "GET" && !request.headers.has("Range") && !shouldBypassIsr(request)) {
+        const isPagesRequest = request.headers.has("X-VoidPages");
+        const isrDeploymentId = routing.version ?? "legacy";
+        const cache = applicationEdgeCache;
+        const isrOriginalUrlVariant = buildFallbackOriginalUrlVariant(
+          request.url,
+          pathname,
+          url.hostname,
+          routing,
+          originalUrlVariant
+        );
+        const cacheKey = isrEdgeCacheKey(request, pathname, isrDeploymentId, isrOriginalUrlVariant);
+        const jsonCacheKey = isrEdgeCacheKeyJson(
+          request,
+          pathname,
+          isrDeploymentId,
+          isrOriginalUrlVariant
+        );
+        sharedIsrEntry = {
+          projectId: routing.projectId,
+          deploymentId: isrDeploymentId,
+          host: url.hostname,
+          pathname,
+          originalUrl: isrOriginalUrlVariant,
+          htmlKey: cacheKey,
+          jsonKey: jsonCacheKey
+        };
+        if (isPagesRequest) {
+          const jsonCached = await cache.match(jsonCacheKey);
+          if (jsonCached && hasCurrentSharedCachePolicy(jsonCached)) {
+            requestType = "isr";
+            return meter(clientRevalidateResponse(jsonCached));
+          }
+          if (jsonCached) {
+            await cache.delete(jsonCacheKey);
+          }
+        } else {
+          const purgePoisonedIsrEntry = /* @__PURE__ */ __name(async () => {
+            await deleteSharedIsrEntry(env, sharedIsrEntry);
+          }, "purgePoisonedIsrEntry");
+          const edgeCached = await cache.match(cacheKey);
+          if (edgeCached && hasCurrentSharedCachePolicy(edgeCached)) {
+            requestType = "isr";
+            const repairResult = await maybeServeWfpAssetFallback({
+              env,
+              routing,
+              pathname,
+              response: edgeCached,
+              userAgent: request.headers.get("user-agent"),
+              timeoutMs,
+              fallbackPathname: resolveCachedWfpFallbackPathname(pathname, routing, url.hostname)
+            });
+            if (repairResult.response !== edgeCached) {
+              ctx.waitUntil(purgePoisonedIsrEntry());
+              return meter(
+                repairResult.response.ok ? clientRevalidateResponse(repairResult.response) : repairResult.response,
+                repairResult.failureKind ? { failureKind: repairResult.failureKind } : void 0
+              );
+            }
+            return meter(clientRevalidateResponse(edgeCached));
+          }
+          if (edgeCached) {
+            await cache.delete(cacheKey);
+          }
+          const cached = await readIsrCache(
+            env,
+            routing.projectId,
+            isrDeploymentId,
+            url.hostname,
+            pathname,
+            isrOriginalUrlVariant
+          );
+          if (cached) {
+            const stale = isStale(cached);
+            const cacheResponse = isrCacheResponse(cached, stale);
+            const repairResult = await maybeServeWfpAssetFallback({
+              env,
+              routing,
+              pathname,
+              response: cacheResponse,
+              userAgent: request.headers.get("user-agent"),
+              timeoutMs,
+              fallbackPathname: resolveCachedWfpFallbackPathname(pathname, routing, url.hostname)
+            });
+            if (repairResult.response !== cacheResponse) {
+              ctx.waitUntil(purgePoisonedIsrEntry());
+              requestType = "isr";
+              return meter(
+                repairResult.response.ok ? clientRevalidateResponse(repairResult.response) : repairResult.response,
+                repairResult.failureKind ? { failureKind: repairResult.failureKind } : void 0
+              );
+            }
+            if (stale) {
+              const staleCacheResponse = cacheResponse.clone();
+              ctx.waitUntil(
+                revalidateInBackground(
+                  env,
+                  routing,
+                  workerRequest,
+                  url.hostname,
+                  pathname,
+                  isrTtl,
+                  cacheKey,
+                  jsonCacheKey,
+                  cached.createdAt + cached.ttl * 1e3,
+                  isrOriginalUrlVariant,
+                  timeoutMs
+                ).then(async (sharedEntryChanged) => {
+                  if (!sharedEntryChanged) {
+                    await cache.put(cacheKey, staleCacheResponse);
+                  }
+                })
+              );
+            }
+            requestType = "isr";
+            if (!stale) {
+              ctx.waitUntil(cache.put(cacheKey, cacheResponse.clone()));
+            }
+            return meter(clientRevalidateResponse(cacheResponse));
+          }
+          requestType = "isr";
+          const worker2 = getWorker(env, routing);
+          const isrWorkerStartedAt = Date.now();
+          let workerResponse;
+          try {
+            workerResponse = await withTimeout(
+              worker2.fetch(workerRequest),
+              remainingTimeoutBudget(isrWorkerStartedAt, timeoutMs, "dispatch"),
+              "dispatch"
+            );
+          } catch (error) {
+            if (error instanceof DispatchTimeoutError) {
+              return meterWorkerTimeout();
+            }
+            throw error;
+          }
+          let isWorkerEventStream = isEventStreamResponse(workerResponse);
+          let workerResponseFailureKind;
+          const cachePathname = pathname;
+          const cacheOriginalUrlVariant = isrOriginalUrlVariant;
+          const cacheKeyForWrite = cacheKey;
+          const jsonCacheKeyForWrite = jsonCacheKey;
+          let effectiveMissPathname = cachePathname;
+          let missFallbackApplied = false;
+          if (!isWorkerEventStream) {
+            const assetFallbackResult = await maybeServeWfpAssetFallback({
+              env,
+              routing,
+              pathname,
+              response: workerResponse,
+              userAgent: request.headers.get("user-agent"),
+              deadline: { startedAt: isrWorkerStartedAt, timeoutMs }
+            });
+            workerResponse = assetFallbackResult.response;
+            workerResponseFailureKind = assetFallbackResult.failureKind;
+            isWorkerEventStream = isEventStreamResponse(workerResponse);
+          }
+          if (!isWorkerEventStream) {
+            let fallbackResult;
+            try {
+              fallbackResult = await applyWorkerFallbackRules({
+                response: workerResponse,
+                worker: worker2,
+                dispatchReq: workerRequest,
+                routing,
+                pathname,
+                url,
+                originalRequestUrl: request.url,
+                originalUrlHeader,
+                originalUrlVariant: isrOriginalUrlVariant,
+                deadline: { startedAt: isrWorkerStartedAt, timeoutMs }
+              });
+            } catch (error) {
+              if (error instanceof DispatchTimeoutError) {
+                return meterWorkerTimeout();
+              }
+              throw error;
+            }
+            if (fallbackResult.applied) {
+              missFallbackApplied = true;
+              effectiveMissPathname = fallbackResult.pathname;
+              workerResponse = fallbackResult.response;
+              isWorkerEventStream = isEventStreamResponse(workerResponse);
+              if (!isWorkerEventStream) {
+                const assetFallbackResult = await maybeServeWfpAssetFallback({
+                  env,
+                  routing,
+                  pathname: fallbackResult.pathname,
+                  response: workerResponse,
+                  userAgent: request.headers.get("user-agent"),
+                  deadline: { startedAt: isrWorkerStartedAt, timeoutMs }
+                });
+                workerResponse = assetFallbackResult.response;
+                workerResponseFailureKind = assetFallbackResult.failureKind;
+                isWorkerEventStream = isEventStreamResponse(workerResponse);
+              }
+            }
+          }
+          if (isWorkerEventStream) {
+            return meter(workerResponse);
+          }
+          const ttl = resolveRevalidateTtl(workerResponse, isrTtl);
+          if (ttl > 0 && workerResponse.status === 200 && !isApiPath(effectiveMissPathname) && !hasSharedCacheOptOut(workerResponse) && (!missFallbackApplied || isFallbackTargetCacheable(
+            routing.pages,
+            effectiveMissPathname,
+            workerResponse,
+            routing.pathRevalidate
+          ))) {
+            ctx.waitUntil(
+              writeIsrCache(
+                env,
+                routing.projectId,
+                isrDeploymentId,
+                url.hostname,
+                cachePathname,
+                workerResponse,
+                ttl,
+                cacheOriginalUrlVariant
+              )
+            );
+            ctx.waitUntil(
+              populateJsonEdgeCache(cache, jsonCacheKeyForWrite, workerResponse, ttl, "MISS")
+            );
+            const cacheHeaders = new Headers(workerResponse.headers);
+            cacheHeaders.set(
+              "Cache-Control",
+              `public, s-maxage=${ttl}, max-age=0, must-revalidate`
+            );
+            cacheHeaders.set("x-isr-cache", "MISS");
+            markSharedCachePolicy(cacheHeaders);
+            cacheHeaders.delete("x-void-page-data");
+            cacheHeaders.delete("set-cookie");
+            const cacheResponse = new Response(workerResponse.clone().body, {
+              status: workerResponse.status,
+              headers: cacheHeaders
+            });
+            ctx.waitUntil(cache.put(cacheKeyForWrite, cacheResponse.clone()));
+            const clientHeaders = new Headers(cacheHeaders);
+            clientHeaders.set("Cache-Control", CLIENT_REVALIDATE_CACHE_CONTROL);
+            clientHeaders.delete(SHARED_CACHE_POLICY_HEADER);
+            const clientResponse = new Response(workerResponse.body, {
+              status: workerResponse.status,
+              headers: clientHeaders
+            });
+            return meter(
+              clientResponse,
+              workerResponseFailureKind ? { failureKind: workerResponseFailureKind } : void 0
+            );
+          }
+          if (workerResponse.status === 200 && !missFallbackApplied && (ttl === 0 || hasSharedCacheOptOut(workerResponse))) {
+            ctx.waitUntil(purgePoisonedIsrEntry());
+          }
+          return meter(
+            workerResponse,
+            workerResponseFailureKind ? { failureKind: workerResponseFailureKind } : void 0
+          );
+        }
+      }
+    }
+    const staticCachePathname = pathname;
+    const isStaticCandidate = isStaticCacheRequestEligible(request, staticCachePathname, routing) && await isKnownStaticAssetPath(env, staticCachePathname, routing, timeoutMs);
+    let staticCacheKey;
+    if (isStaticCandidate) {
+      const cacheUrl = new URL(
+        buildVariantOriginalUrl(
+          request.url,
+          new URL(request.url).pathname,
+          exactQueryAllowlist(routing.queryAllowlist)
+        )
+      );
+      cacheUrl.searchParams.set("_v", String(routing.version));
+      const candidateCacheKey = new Request(cacheUrl.toString());
+      staticCacheKey = candidateCacheKey;
+      const staticCache = applicationEdgeCache;
+      const cached = await staticCache.match(candidateCacheKey);
+      if (cached && isCurrentStaticCacheResponse(cached)) {
+        requestType = "static";
+        if (!routing.staticDeploymentId) {
+          const repairResult = await maybeServeWfpAssetFallback({
+            env,
+            routing,
+            pathname,
+            response: cached,
+            userAgent: request.headers.get("user-agent"),
+            timeoutMs,
+            fallbackPathname: resolveCachedWfpFallbackPathname(pathname, routing, url.hostname)
+          });
+          if (repairResult.response !== cached) {
+            if (isStaticCacheResponseEligible(repairResult.response)) {
+              const finalRes = applyHeaderRules(
+                repairResult.response,
+                repairResult.pathname,
+                routing.headerRules
+              );
+              const repaired = new Response(finalRes.clone().body, finalRes);
+              repaired.headers.set(
+                "Cache-Control",
+                "public, s-maxage=31536000, max-age=0, must-revalidate"
+              );
+              markSharedCachePolicy(repaired.headers);
+              const repairedForCache = repaired.clone();
+              ctx.waitUntil(
+                staticCache.delete(candidateCacheKey).then(() => staticCache.put(candidateCacheKey, repairedForCache))
+              );
+              return meter(clientRevalidateResponse(finalRes));
+            }
+            ctx.waitUntil(staticCache.delete(candidateCacheKey));
+            return meter(
+              repairResult.response,
+              repairResult.failureKind ? { failureKind: repairResult.failureKind } : void 0
+            );
+          }
+        }
+        return meter(clientRevalidateResponse(cached));
+      }
+      if (cached) {
+        await staticCache.delete(candidateCacheKey);
+      }
+    }
+    if (routing.staticDeploymentId) {
+      const staticAssetStartedAt = Date.now();
+      let assetManifest;
+      try {
+        assetManifest = await fetchAssetManifest(
+          env,
+          routing.staticDeploymentId,
+          routing.projectId,
+          remainingTimeoutBudget(staticAssetStartedAt, timeoutMs)
+        );
+      } catch (err) {
+        if (err instanceof DispatchTimeoutError) {
+          return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_TIMEOUT), {
+            failureKind: PLATFORM_STATIC_ASSET_TIMEOUT
+          });
+        }
+        if (err instanceof StaticAssetReadError) {
+          return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_ERROR), {
+            failureKind: PLATFORM_STATIC_ASSET_ERROR
+          });
+        }
+        throw err;
+      }
+      if (!assetManifest) {
+        return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_MISSING), {
+          failureKind: PLATFORM_STATIC_ASSET_MISSING
+        });
+      }
+      const assetConfig = routing.assetConfig ?? {};
+      const fallbackOriginPathname = pathname;
+      let resolved = resolveStaticPath(pathname, assetManifest, assetConfig);
+      if (!resolved && routing.fallbackRules?.length) {
+        const fallback = applyRoutingRules(pathname, routing.fallbackRules, url.hostname);
+        if (fallback?.type === "rewrite") {
+          pathname = fallback.destination;
+          url.pathname = pathname;
+          resolved = resolveStaticPath(pathname, assetManifest, assetConfig);
+        }
+      }
+      if (!resolved) {
+        return meter(createErrorResponse(request, 404, "Not Found"));
+      }
+      if (resolved.redirect) {
+        return meter(
+          new Response(null, {
+            status: 308,
+            headers: { Location: resolved.redirect }
+          })
+        );
+      }
+      let assetResponse;
+      try {
+        assetResponse = await fetchStaticAsset(
+          env,
+          resolved.hash,
+          resolved.path,
+          routing.projectId,
+          routing.staticDeploymentId,
+          remainingTimeoutBudget(staticAssetStartedAt, timeoutMs)
+        );
+      } catch (err) {
+        if (err instanceof DispatchTimeoutError) {
+          return meter(
+            timeoutResponse(resolved.notFound ? 404 : 503, "static-asset"),
+            resolved.notFound ? void 0 : { failureKind: PLATFORM_STATIC_ASSET_TIMEOUT }
+          );
+        }
+        if (err instanceof StaticAssetReadError) {
+          return meter(
+            resolved.notFound ? createErrorResponse(request, 404, "Not Found") : staticAssetFailureResponse(PLATFORM_STATIC_ASSET_ERROR),
+            resolved.notFound ? void 0 : { failureKind: PLATFORM_STATIC_ASSET_ERROR }
+          );
+        }
+        throw err;
+      }
+      if (!assetResponse) {
+        if (resolved.notFound) {
+          return meter(createErrorResponse(request, 404, "Not Found"));
+        }
+        logStaticAssetMissing(routing, resolved.path, resolved.hash);
+        return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_MISSING), {
+          failureKind: PLATFORM_STATIC_ASSET_MISSING
+        });
+      }
+      const status = resolved.notFound ? 404 : 200;
+      const response = new Response(assetResponse.body, {
+        status,
+        headers: assetResponse.headers
+      });
+      const finalRes = applyHeaderRules(response, pathname, routing.headerRules);
+      const edgeCacheKey = staticCacheKey ?? (isSharedStaticCacheRequestEligible(request) ? new Request(`${url.origin}${fallbackOriginPathname}?_v=${routing.staticDeploymentId}`) : void 0);
+      if (edgeCacheKey && isStaticCacheResponseEligible(finalRes)) {
+        const cached = new Response(finalRes.clone().body, finalRes);
+        cached.headers.set(
+          "Cache-Control",
+          "public, s-maxage=31536000, max-age=0, must-revalidate"
+        );
+        markSharedCachePolicy(cached.headers);
+        ctx.waitUntil(applicationEdgeCache.put(edgeCacheKey, cached.clone()));
+      }
+      return meter(clientRevalidateResponse(finalRes));
+    }
+    const worker = getWorker(env, routing);
+    try {
+      let dispatchReq = workerRequest;
+      if (dispatchReq.bodyUsed) {
+        dispatchReq = rebuildRequest(dispatchReq, dispatchReq.url, () => {
+        });
+      }
+      const hasBodyMethod = dispatchReq.method !== "GET" && dispatchReq.method !== "HEAD";
+      const dispatchReqForFallback = hasBodyMethod && routing.fallbackRules?.length ? dispatchReq.clone() : dispatchReq;
+      const workerDispatchStartedAt = Date.now();
+      let response = await withTimeout(
+        worker.fetch(dispatchReq),
+        remainingTimeoutBudget(workerDispatchStartedAt, timeoutMs, "dispatch"),
+        "dispatch"
+      );
+      let isEventStream = isEventStreamResponse(response);
+      let responseFailureKind;
+      if (!isEventStream) {
+        const assetFallbackResult = await maybeServeWfpAssetFallback({
+          env,
+          routing,
+          pathname,
+          response,
+          userAgent: request.headers.get("user-agent"),
+          deadline: { startedAt: workerDispatchStartedAt, timeoutMs }
+        });
+        response = assetFallbackResult.response;
+        responseFailureKind = assetFallbackResult.failureKind;
+        isEventStream = isEventStreamResponse(response);
+      }
+      let writebackFallbackApplied = false;
+      if (!isEventStream) {
+        const fallbackResult = await applyWorkerFallbackRules({
+          response,
+          worker,
+          dispatchReq: dispatchReqForFallback,
+          routing,
+          pathname,
+          url,
+          originalRequestUrl: request.url,
+          originalUrlHeader,
+          originalUrlVariant,
+          deadline: { startedAt: workerDispatchStartedAt, timeoutMs }
+        });
+        if (fallbackResult.applied) {
+          writebackFallbackApplied = true;
+          pathname = fallbackResult.pathname;
+          url.pathname = pathname;
+          originalUrlVariant = fallbackResult.originalUrlVariant;
+          response = fallbackResult.response;
+          isEventStream = isEventStreamResponse(response);
+          if (!isEventStream) {
+            const assetFallbackResult = await maybeServeWfpAssetFallback({
+              env,
+              routing,
+              pathname,
+              response,
+              userAgent: request.headers.get("user-agent"),
+              deadline: { startedAt: workerDispatchStartedAt, timeoutMs }
+            });
+            response = assetFallbackResult.response;
+            responseFailureKind = assetFallbackResult.failureKind;
+            isEventStream = isEventStreamResponse(response);
+          }
+        }
+      }
+      if (sharedIsrEntry && response.status === 200 && !writebackFallbackApplied && (resolveRevalidateTtl(
+        response,
+        resolvePageTtl(
+          routing.pages,
+          routing.revalidate,
+          routing.pathRevalidate,
+          sharedIsrEntry.pathname
+        )
+      ) === 0 || hasSharedCacheOptOut(response))) {
+        ctx.waitUntil(deleteSharedIsrEntry(env, sharedIsrEntry));
+      }
+      if (staticCacheKey && !writebackFallbackApplied && isStaticCacheResponseEligible(response)) {
+        const res = new Response(response.body, response);
+        res.headers.delete("x-void-page-data");
+        const finalRes = applyHeaderRules(res, pathname, routing.headerRules);
+        const cacheRes = new Response(finalRes.clone().body, finalRes);
+        cacheRes.headers.set(
+          "Cache-Control",
+          "public, s-maxage=31536000, max-age=0, must-revalidate"
+        );
+        markSharedCachePolicy(cacheRes.headers);
+        ctx.waitUntil(applicationEdgeCache.put(staticCacheKey, cacheRes.clone()));
+        return meter(
+          clientRevalidateResponse(finalRes),
+          responseFailureKind ? { failureKind: responseFailureKind } : void 0
+        );
+      }
+      const dynamicType = classifyDynamicRequestType(pathname, routing.ssr);
+      if (dynamicType) {
+        requestType = dynamicType;
+      }
+      if ((routing.revalidate || routing.pages?.length) && !isEventStream && !request.headers.has("X-VoidPages") && request.method === "GET" && !request.headers.has("Range") && !shouldBypassIsr(request)) {
+        const configTtl = resolvePageTtl(
+          routing.pages,
+          routing.revalidate,
+          routing.pathRevalidate,
+          pathname
+        );
+        const isrTtl = configTtl > 0 ? resolveRevalidateTtl(response, configTtl) : 0;
+        if (isrTtl > 0 && response.status === 200 && requestType === "ssr" && !hasSharedCacheOptOut(response) && (!writebackFallbackApplied || isFallbackTargetCacheable(routing.pages, pathname, response, routing.pathRevalidate))) {
+          const isrDeploymentId = routing.version ?? "legacy";
+          ctx.waitUntil(
+            writeIsrCache(
+              env,
+              routing.projectId,
+              isrDeploymentId,
+              url.hostname,
+              pathname,
+              response,
+              isrTtl,
+              originalUrlVariant
+            )
+          );
+          const jsonCacheKey = isrEdgeCacheKeyJson(
+            request,
+            pathname,
+            isrDeploymentId,
+            originalUrlVariant
+          );
+          ctx.waitUntil(
+            populateJsonEdgeCache(applicationEdgeCache, jsonCacheKey, response, isrTtl, "MISS")
+          );
+        }
+      }
+      if (response.headers.has("x-void-page-data")) {
+        const stripped = new Response(response.body, response);
+        stripped.headers.delete("x-void-page-data");
+        return meter(
+          applyHeaderRules(stripped, pathname, routing.headerRules),
+          responseFailureKind ? { failureKind: responseFailureKind } : void 0
+        );
+      }
+      return meter(
+        applyHeaderRules(response, pathname, routing.headerRules),
+        responseFailureKind ? { failureKind: responseFailureKind } : void 0
+      );
+    } catch (err) {
+      if (err instanceof DispatchTimeoutError) {
+        if (err.label === "static-asset") {
+          return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_TIMEOUT), {
+            failureKind: PLATFORM_STATIC_ASSET_TIMEOUT
+          });
+        }
+        const dynamicType = classifyDynamicRequestType(pathname, routing.ssr);
+        if (dynamicType) {
+          requestType = dynamicType;
+        }
+        return meterWorkerTimeout();
+      }
+      if (err instanceof StaticAssetReadError) {
+        return meter(staticAssetFailureResponse(PLATFORM_STATIC_ASSET_ERROR), {
+          failureKind: PLATFORM_STATIC_ASSET_ERROR
+        });
+      }
+      if (err instanceof Error && err.message.includes("Worker exceeded")) {
+        return meter(Response.json({ error: "CPU limit exceeded" }, { status: 429 }));
+      }
+      throw err;
+    }
+  },
+  async queue(batch, env) {
+    if (env.PLATFORM_TRAFFIC_STATE === "staging" || env.PLATFORM_TRAFFIC_STATE === "sandbox-drain") {
+      console.warn(
+        `[queue-relay] platform traffic is staging; retrying queue="${batch.queue}" in ${PLATFORM_QUEUE_RETRY_DELAY_SECONDS}s`
+      );
+      batch.retryAll({ delaySeconds: PLATFORM_QUEUE_RETRY_DELAY_SECONDS });
+      return;
+    }
+    if (env.PLATFORM_INSTALLATION_ID) {
+      let disabled;
+      try {
+        disabled = await env.ROUTING.get(PLATFORM_DISABLED_KEY);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(
+          `[queue-relay] platform traffic gate read failed; retrying queue="${batch.queue}" in ${PLATFORM_QUEUE_RETRY_DELAY_SECONDS}s error=${JSON.stringify(message)}`
+        );
+        batch.retryAll({ delaySeconds: PLATFORM_QUEUE_RETRY_DELAY_SECONDS });
+        return;
+      }
+      if (disabled === PLATFORM_DISABLED_VALUE) {
+        console.warn(
+          `[queue-relay] platform traffic is disabled; retrying queue="${batch.queue}" in ${PLATFORM_QUEUE_RETRY_DELAY_SECONDS}s`
+        );
+        batch.retryAll({ delaySeconds: PLATFORM_QUEUE_RETRY_DELAY_SECONDS });
+        return;
+      }
+    }
+    const routingRaw = await env.ROUTING.get(`queue:${batch.queue}`, { cacheTtl: 60 });
+    if (!routingRaw) {
+      console.error(
+        `[queue-relay] missing routing entry for queue="${batch.queue}"; retrying all messages`
+      );
+      batch.retryAll();
+      return;
+    }
+    const { workerName, queueName, proxyToken } = JSON.parse(routingRaw);
+    const messages = Array.from(batch.messages, (message) => ({
+      id: message.id,
+      timestamp: message.timestamp.toISOString(),
+      body: message.body,
+      attempts: message.attempts
+    }));
+    const worker = env.DISPATCH.get(workerName);
+    try {
+      const body = JSON.stringify({ queue: queueName, messages });
+      const queueHeaders = { "Content-Type": "application/json" };
+      if (proxyToken) {
+        queueHeaders["x-void-internal"] = proxyToken;
+      }
+      let res = await worker.fetch(
+        new Request("https://internal/__void/queue", {
+          method: "POST",
+          headers: queueHeaders,
+          body
+        })
+      );
+      if (res.status === 404) {
+        res = await worker.fetch(
+          new Request("https://internal/__queue", {
+            method: "POST",
+            headers: queueHeaders,
+            body
+          })
+        );
+      }
+      if (!res.ok) {
+        let snippet = "";
+        try {
+          snippet = (await res.clone().text()).slice(0, 200);
+        } catch {
+        }
+        console.error(
+          `[queue-relay] relay failed queue="${queueName}" worker="${workerName}" status=${res.status} body=${JSON.stringify(snippet)}`
+        );
+        batch.retryAll();
+        return;
+      }
+      let result;
+      try {
+        result = await res.json();
+      } catch {
+        batch.ackAll();
+        return;
+      }
+      if (!result.decisions) {
+        if (result.ok !== false) {
+          batch.ackAll();
+        } else {
+          batch.retryAll();
+        }
+        return;
+      }
+      const messageMap = new Map(batch.messages.map((message) => [message.id, message]));
+      for (const [id, decision] of Object.entries(result.decisions)) {
+        const cfMessage = messageMap.get(id);
+        if (!cfMessage) {
+          continue;
+        }
+        if (decision.action === "ack") {
+          cfMessage.ack();
+        } else if (decision.action === "retry") {
+          cfMessage.retry(
+            decision.delaySeconds != null ? { delaySeconds: decision.delaySeconds } : void 0
+          );
+        }
+      }
+      if (result.ok === false) {
+        batch.retryAll();
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[queue-relay] relay threw queue="${queueName}" worker="${workerName}" error=${JSON.stringify(msg)}`
+      );
+      batch.retryAll();
+    }
+  }
+};
+var StaticAssetReadError = class extends Error {
+  static {
+    __name(this, "StaticAssetReadError");
+  }
+  constructor(cause) {
+    super("Static asset storage read failed", { cause });
+    this.name = "StaticAssetReadError";
+  }
+};
+function logStaticAssetMissing(routing, pathname, hash) {
+  console.error(
+    JSON.stringify({
+      event: "static-asset-missing",
+      store: hash.startsWith("!") ? "r2" : "kv",
+      projectId: routing.projectId,
+      deploymentId: routing.staticDeploymentId ?? routing.assetManifestId,
+      pathname,
+      ts: Date.now()
+    })
+  );
+}
+__name(logStaticAssetMissing, "logStaticAssetMissing");
+async function fetchStaticAsset(env, hash, path, projectId, deploymentId, timeoutMs = 1e4) {
+  const hedgeDelayMs = timeoutMs > 0 && Number.isFinite(timeoutMs) ? Math.min(STATIC_ASSET_HEDGE_DELAY_MS, timeoutMs / 2) : 0;
+  const startedAt = Date.now();
+  let hedged = false;
+  try {
+    const result = await withDelayedHedge(() => fetchStaticAssetOnce(env, hash, path, projectId), {
+      delayMs: hedgeDelayMs,
+      timeoutMs,
+      label: "static-asset",
+      discard: /* @__PURE__ */ __name(async (late) => {
+        await late.body?.cancel();
+      }, "discard"),
+      onHedge: /* @__PURE__ */ __name(() => {
+        hedged = true;
+        console.warn(
+          JSON.stringify({
+            event: "static-asset-read-hedge",
+            store: hash.startsWith("!") ? "r2" : "kv",
+            projectId,
+            deploymentId,
+            pathname: path,
+            delayMs: hedgeDelayMs,
+            ts: Date.now()
+          })
+        );
+      }, "onHedge")
+    });
+    if (hedged) {
+      console.warn(
+        JSON.stringify({
+          event: "static-asset-read-hedge-result",
+          store: hash.startsWith("!") ? "r2" : "kv",
+          projectId,
+          deploymentId,
+          pathname: path,
+          outcome: result === null ? "miss" : "hit",
+          elapsedMs: Date.now() - startedAt,
+          ts: Date.now()
+        })
+      );
+    }
+    return result;
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        event: error instanceof DispatchTimeoutError ? "static-asset-timeout" : "static-asset-read-error",
+        store: hash.startsWith("!") ? "r2" : "kv",
+        projectId,
+        deploymentId,
+        pathname: path,
+        hedged,
+        elapsedMs: Date.now() - startedAt,
+        error: error instanceof DispatchTimeoutError ? void 0 : error instanceof Error ? error.message : String(error),
+        ts: Date.now()
+      })
+    );
+    if (error instanceof DispatchTimeoutError) {
+      throw error;
+    }
+    throw new StaticAssetReadError(error);
+  }
+}
+__name(fetchStaticAsset, "fetchStaticAsset");
+async function fetchStaticAssetOnce(env, hash, path, projectId) {
+  const isLarge = hash.startsWith("!");
+  const cleanHash = isLarge ? hash.slice(1) : hash;
+  const scopedKey = projectId ? `assets/${projectId}/${cleanHash}` : null;
+  const legacyKey = `assets/${cleanHash}`;
+  if (isLarge) {
+    const obj = scopedKey ? await env.STATIC_ASSETS_R2.get(scopedKey) ?? await env.STATIC_ASSETS_R2.get(legacyKey) : await env.STATIC_ASSETS_R2.get(legacyKey);
+    if (!obj) {
+      return null;
+    }
+    const contentType2 = resolveAssetContentType(obj.httpMetadata?.contentType, path);
+    const headers2 = {
+      ETag: obj.httpEtag,
+      ...obj.size ? { "Content-Length": String(obj.size) } : {}
+    };
+    if (contentType2) {
+      headers2["Content-Type"] = contentType2;
+    }
+    return new Response(obj.body, { headers: headers2 });
+  }
+  if (scopedKey) {
+    const scoped = await env.STATIC_ASSETS.getWithMetadata(scopedKey, {
+      type: "arrayBuffer",
+      cacheTtl: 86400
+    });
+    if (scoped.value) {
+      const contentType2 = resolveAssetContentType(scoped.metadata?.ct, path);
+      const headers2 = {
+        "Content-Length": String(scoped.value.byteLength)
+      };
+      if (contentType2) {
+        headers2["Content-Type"] = contentType2;
+      }
+      return new Response(scoped.value, { headers: headers2 });
+    }
+  }
+  const { value, metadata } = await env.STATIC_ASSETS.getWithMetadata(legacyKey, {
+    type: "arrayBuffer",
+    cacheTtl: 86400
+  });
+  if (!value) {
+    return null;
+  }
+  const contentType = resolveAssetContentType(metadata?.ct, path);
+  const headers = {
+    "Content-Length": String(value.byteLength)
+  };
+  if (contentType) {
+    headers["Content-Type"] = contentType;
+  }
+  return new Response(value, { headers });
+}
+__name(fetchStaticAssetOnce, "fetchStaticAssetOnce");
+function getWorker(env, routing) {
+  if (routing.limits) {
+    return env.DISPATCH.get(routing.workerName, {}, { limits: routing.limits });
+  }
+  return env.DISPATCH.get(routing.workerName);
+}
+__name(getWorker, "getWorker");
+async function revalidateInBackground(env, routing, request, host, pathname, defaultTtl, cacheKey, jsonCacheKey, staleSinceMs, originalUrl, timeoutMs = 1e4) {
+  try {
+    const worker = getWorker(env, routing);
+    const revalidationStartedAt = Date.now();
+    const cleanRequest = rebuildRequest(
+      request,
+      request.url,
+      (headers) => headers.delete("X-VoidPages")
+    );
+    let response = await withTimeout(
+      worker.fetch(cleanRequest),
+      remainingTimeoutBudget(revalidationStartedAt, timeoutMs, "dispatch"),
+      "dispatch"
+    );
+    if (isEventStreamResponse(response)) {
+      return false;
+    }
+    const originalStatus = response.status;
+    const fallbackResult = await applyWorkerFallbackRules({
+      response,
+      worker,
+      dispatchReq: cleanRequest,
+      routing,
+      pathname,
+      url: new URL(cleanRequest.url),
+      originalRequestUrl: request.url,
+      originalUrlHeader: request.headers.get("X-Void-Original-URL") ?? void 0,
+      originalUrlVariant: originalUrl ?? void 0,
+      deadline: { startedAt: revalidationStartedAt, timeoutMs }
+    });
+    response = fallbackResult.response;
+    if (isEventStreamResponse(response)) {
+      return false;
+    }
+    const assetFallbackResult = await maybeServeWfpAssetFallback({
+      env,
+      routing,
+      pathname: fallbackResult.pathname,
+      response,
+      userAgent: request.headers.get("user-agent"),
+      deadline: { startedAt: revalidationStartedAt, timeoutMs }
+    });
+    response = assetFallbackResult.response;
+    if (isEventStreamResponse(response)) {
+      return false;
+    }
+    const ttl = resolveRevalidateTtl(response, defaultTtl);
+    const cache = applicationEdgeCache;
+    const evictSharedEntry = /* @__PURE__ */ __name(async () => {
+      await deleteIsrCache(
+        env,
+        routing.projectId,
+        routing.version ?? "legacy",
+        host,
+        pathname,
+        originalUrl
+      );
+      await cache.delete(cacheKey);
+      await cache.delete(jsonCacheKey);
+    }, "evictSharedEntry");
+    const effectiveBgPathname = fallbackResult.applied ? fallbackResult.pathname : pathname;
+    if (ttl > 0 && response.status === 200 && !isApiPath(effectiveBgPathname) && !hasSharedCacheOptOut(response) && (!fallbackResult.applied || isFallbackTargetCacheable(
+      routing.pages,
+      effectiveBgPathname,
+      response,
+      routing.pathRevalidate
+    ))) {
+      await writeIsrCache(
+        env,
+        routing.projectId,
+        routing.version ?? "legacy",
+        host,
+        pathname,
+        response,
+        ttl,
+        originalUrl
+      );
+      const headers = new Headers(response.headers);
+      headers.set("x-isr-cache", "HIT");
+      headers.set("Cache-Control", `public, s-maxage=${ttl}, max-age=0, must-revalidate`);
+      markSharedCachePolicy(headers);
+      headers.delete("set-cookie");
+      headers.delete("x-void-page-data");
+      await cache.put(
+        cacheKey,
+        new Response(response.clone().body, {
+          status: response.status,
+          headers
+        })
+      );
+      await populateJsonEdgeCache(cache, jsonCacheKey, response, ttl, "HIT");
+      return true;
+    } else if (response.status === 200 && !isApiPath(effectiveBgPathname) && !fallbackResult.applied && (ttl === 0 || hasSharedCacheOptOut(response))) {
+      try {
+        await evictSharedEntry();
+      } catch (error) {
+        console.error("ISR privacy eviction failed:", error);
+      }
+      return true;
+    } else if ((originalStatus === 404 || originalStatus === 410) && Date.now() - staleSinceMs > ISR_STALE_EVICT_GRACE_SECONDS * 1e3) {
+      try {
+        await evictSharedEntry();
+      } catch (error) {
+        console.error("ISR stale-entry eviction failed:", error);
+      }
+      return true;
+    }
+    return false;
+  } catch (err) {
+    console.error("ISR revalidation failed:", err);
+    return false;
+  }
+}
+__name(revalidateInBackground, "revalidateInBackground");
+function isApiPath(pathname) {
+  return pathname === "/api" || pathname.startsWith("/api/");
+}
+__name(isApiPath, "isApiPath");
+function isIsrEligiblePath(pathname, pages, revalidate, pathRevalidate) {
+  if (isApiPath(pathname)) {
+    return false;
+  }
+  if (!hasExtension(pathname)) {
+    return true;
+  }
+  return isDottedPathIsrEligible(pages, revalidate, pathRevalidate, pathname);
+}
+__name(isIsrEligiblePath, "isIsrEligiblePath");
+function isFallbackTargetCacheable(pages, targetPathname, response, pathRevalidate) {
+  return isHtmlResponse(response) && matchesLiteralPage(pages, targetPathname, pathRevalidate);
+}
+__name(isFallbackTargetCacheable, "isFallbackTargetCacheable");
+function isSharedStaticCacheRequestEligible(request) {
+  return Boolean(
+    request.method === "GET" && !request.headers.has("Range") && !request.headers.has("X-VoidPages") && !shouldBypassIsr(request)
+  );
+}
+__name(isSharedStaticCacheRequestEligible, "isSharedStaticCacheRequestEligible");
+function isStaticCacheRequestEligible(request, pathname, routing) {
+  return Boolean(
+    isSharedStaticCacheRequestEligible(request) && routing.version && !isApiPath(pathname) && (hasExtension(pathname) || !routing.ssr)
+  );
+}
+__name(isStaticCacheRequestEligible, "isStaticCacheRequestEligible");
+async function isKnownStaticAssetPath(env, pathname, routing, timeoutMs) {
+  if (routing.staticDeploymentId) {
+    return true;
+  }
+  if (!routing.ssr) {
+    return true;
+  }
+  if (!routing.assetManifestId) {
+    return false;
+  }
+  try {
+    const manifest = await fetchAssetManifest(
+      env,
+      routing.assetManifestId,
+      routing.projectId,
+      Math.min(timeoutMs, STATIC_ASSET_HEDGE_DELAY_MS)
+    );
+    if (!manifest) {
+      return false;
+    }
+    if (Object.hasOwn(manifest, pathname)) {
+      return true;
+    }
+    const decoded = safeDecodePathname(pathname);
+    return decoded !== pathname && Object.hasOwn(manifest, decoded);
+  } catch {
+    return false;
+  }
+}
+__name(isKnownStaticAssetPath, "isKnownStaticAssetPath");
+function isStaticCacheResponseEligible(response) {
+  return response.status === 200 && !isEventStreamResponse(response) && !hasSharedCacheOptOut(response);
+}
+__name(isStaticCacheResponseEligible, "isStaticCacheResponseEligible");
+function isCurrentStaticCacheResponse(response) {
+  return hasCurrentSharedCachePolicy(response) && isStaticCacheResponseEligible(response);
+}
+__name(isCurrentStaticCacheResponse, "isCurrentStaticCacheResponse");
+export {
+  index_default as default,
+  isEventStreamResponse,
+  isHtmlResponse,
+  rebuildRequest
+};
+//# sourceMappingURL=index.js.map