@wular/coder 0.3.18 → 0.4.1

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-B4THCTQP.js

@@ -0,0 +1,22 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  loadNextConfig
+} from "./chunk-2ICEVELW.js";
+import {
+  registerConfigSource
+} from "./chunk-JESFYECC.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/register/config.ts
+function registerConfigSource2() {
+  registerConfigSource(async (root, options) => {
+    const { overrides } = await loadNextConfig(root, options);
+    return overrides;
+  });
+}
+
+export {
+  registerConfigSource2 as registerConfigSource
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-C2LIV2MM.js

@@ -0,0 +1,172 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  isNotFoundError,
+  isRedirectError
+} from "./chunk-VC5O2SDP.js";
+import {
+  nextResponseMeta,
+  toNextRequest
+} from "./chunk-7DCNCW6O.js";
+import {
+  getWorkUnit,
+  runWithRequest
+} from "./chunk-JESFYECC.js";
+import {
+  safeDecode
+} from "./chunk-JRPJM2XY.js";
+import {
+  getRenderExtensions,
+  reportRequestError
+} from "./chunk-4P5CMIYT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/handler.ts
+var routeMethods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var httpMethods = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+]);
+async function handleRouteModule(module, request, params, options = {}) {
+  const responseHeaders = new Headers();
+  const method = request.method.toUpperCase();
+  try {
+    if (!httpMethods.has(method)) return new Response(null, { status: 400 });
+    const handler = routeMethods.includes(method) ? module[method] : void 0;
+    if (!handler) {
+      if (method === "HEAD" && module.GET) {
+        const response = finalizeResponse(
+          await callHandler(module.GET, request, params, responseHeaders),
+          request,
+          responseHeaders,
+          options
+        );
+        return new Response(null, { status: response.status, headers: response.headers });
+      }
+      return missingMethodResponse(module, method);
+    }
+    return finalizeResponse(
+      await callHandler(handler, request, params, responseHeaders),
+      request,
+      responseHeaders,
+      options
+    );
+  } catch (error) {
+    if (isRedirectError(error)) {
+      const status = method === "POST" ? 303 : error.status;
+      return withResponseHeaders(
+        new Response(null, { status, headers: { location: error.location } }),
+        responseHeaders
+      );
+    }
+    if (isNotFoundError(error)) {
+      return withResponseHeaders(new Response(null, { status: 404 }), responseHeaders);
+    }
+    await reportRequestError(
+      error,
+      { method, url: request.url, headers: request.headers },
+      { phase: "handler", routeKind: "route-handler", ...getWorkUnit()?.responseHints ?? {} }
+    );
+    console.error(error);
+    return new Response(null, { status: 500 });
+  }
+}
+function finalizeResponse(response, request, responseHeaders, options) {
+  const method = request.method.toUpperCase();
+  if (!response) {
+    const file = options.routeFile ?? "<route>";
+    console.error(
+      `No response is returned from route handler '${file}'. Expected a Response object but received '${typeof response}' (method: ${method}, url: ${request.url}). Ensure you return a \`Response\` or a \`NextResponse\` in all branches of your handler.`
+    );
+    return new Response(null, { status: 500 });
+  }
+  if (nextResponseMeta(response)?.kind === "next") {
+    console.error("https://nextjs.org/docs/messages/next-response-next-in-app-route-handler");
+    return new Response(null, { status: 500 });
+  }
+  return withResponseHeaders(response, responseHeaders);
+}
+function callHandler(handler, request, params, responseHeaders) {
+  const nextRequest = toNextRequest(request);
+  const context = Object.keys(params).length > 0 ? {
+    params: getRenderExtensions().legacySyncProps(Promise.resolve(params), "params", params)
+  } : {};
+  return runWithRequest(nextRequest, () => handler(nextRequest, context), params, {
+    responseHeaders
+  });
+}
+function withResponseHeaders(response, extra) {
+  const withSetCookie = extra;
+  const scopeCookies = withSetCookie.getSetCookie?.() ?? [];
+  let hasOthers = false;
+  extra.forEach((_, key) => {
+    if (key !== "set-cookie") hasOthers = true;
+  });
+  if (scopeCookies.length === 0 && !hasOthers) return response;
+  const apply = (headers) => {
+    extra.forEach((value, key) => {
+      if (key !== "set-cookie") headers.set(key, value);
+    });
+    const responseCookies = headers.getSetCookie?.() ?? [];
+    const jar = /* @__PURE__ */ new Map();
+    for (const cookie of [...scopeCookies, ...responseCookies]) {
+      jar.set(cookieName(cookie), normalizeSetCookie(cookie));
+    }
+    headers.delete("set-cookie");
+    for (const cookie of jar.values()) headers.append("set-cookie", cookie);
+  };
+  try {
+    apply(response.headers);
+    return response;
+  } catch {
+    const headers = new Headers(response.headers);
+    apply(headers);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+function cookieName(setCookie) {
+  return (setCookie.split("=")[0] ?? "").trim();
+}
+function normalizeSetCookie(setCookie) {
+  return /;\s*path=/i.test(setCookie) ? setCookie : `${setCookie}; Path=/`;
+}
+function routeParamsFromPath(route, pathname) {
+  const match = new RegExp(`^${route.pattern}$`).exec(pathname);
+  const params = {};
+  if (!match) return params;
+  for (let index = 0; index < route.params.length; index += 1) {
+    params[route.params[index]] = safeDecode(match[index + 1] ?? "");
+  }
+  if (route.catchAll) {
+    params[route.catchAll] = (match[route.params.length + 1] ?? "").split("/").filter(Boolean).map(safeDecode);
+  }
+  return params;
+}
+function missingMethodResponse(module, method) {
+  const headers = { Allow: allowedMethods(module).join(", ") };
+  if (method === "OPTIONS") return new Response(null, { status: 204, headers });
+  return new Response(null, { status: 405, headers });
+}
+function allowedMethods(module) {
+  const allowed = new Set(routeMethods.filter((method) => typeof module[method] === "function"));
+  if (allowed.has("GET")) allowed.add("HEAD");
+  allowed.add("OPTIONS");
+  return [...allowed].sort();
+}
+
+export {
+  handleRouteModule,
+  routeParamsFromPath
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-CCATPVTW.js

@@ -0,0 +1,378 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  dynamicCallFacts,
+  rewriteFacts
+} from "./chunk-NQE46AZN.js";
+import {
+  restoreWithExtensionHost
+} from "./chunk-4P5CMIYT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/dynamic.ts
+function sourceHasDynamicImport(source) {
+  return source.includes("@wular/pnext") || source.includes("next/dynamic");
+}
+function pnextDynamicImportNames(source, file = "module.tsx") {
+  const names = /* @__PURE__ */ new Set();
+  if (!sourceHasDynamicImport(source)) return names;
+  for (const statement of rewriteFacts(file, source).imports) {
+    const { specifier } = statement;
+    const pnext = specifier === "@wular/pnext" || specifier === "@wular/pnext/dynamic";
+    const nextDynamic = specifier === "next/dynamic" || /compat\/next\/dynamic(?:\.tsx)?$/.test(specifier);
+    if (!pnext && !nextDynamic) continue;
+    for (const binding of statement.bindings) {
+      if (binding.type) continue;
+      if (pnext ? binding.imported === "dynamic" : binding.imported === "default") {
+        names.add(binding.local);
+      }
+    }
+  }
+  return names;
+}
+function dynamicCallsFromSource(source, dynamicNames) {
+  const calls = [];
+  if (dynamicNames.size === 0) return calls;
+  let index = 0;
+  while ((index = nextDynamicCallIndex(source, dynamicNames, index)) !== -1) {
+    const name = dynamicNameAt(source, dynamicNames, index);
+    if (!name) {
+      index += 1;
+      continue;
+    }
+    const before = source[index - 1];
+    const after = source[index + name.length];
+    if (before && /[\w$]/.test(before) || after && /[\w$]/.test(after)) {
+      index += name.length;
+      continue;
+    }
+    const open = source.indexOf("(", index + name.length);
+    if (open === -1 || source.slice(index + name.length, open).trim()) {
+      index += name.length;
+      continue;
+    }
+    const close = matchingParen(source, open);
+    if (close === -1) {
+      index = open + 1;
+      continue;
+    }
+    calls.push({
+      index,
+      name,
+      open,
+      close,
+      source: source.slice(index, close + 1)
+    });
+    index = close + 1;
+  }
+  return calls;
+}
+function rewriteLiteralDynamicCalls(source, file) {
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0) return source;
+  const facts = dynamicCallFacts(source, file);
+  const edits = [];
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const fact = factForCall(facts, call);
+    if (!fact?.literal) continue;
+    edits.push({
+      start: fact.specifierStart,
+      end: fact.specifierEnd,
+      value: `() => import(${source.slice(fact.specifierStart, fact.specifierEnd)})`
+    });
+  }
+  if (edits.length === 0) return source;
+  let next = source;
+  for (const edit of edits.reverse()) {
+    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`;
+  }
+  return next;
+}
+function rewriteDynamicCallTargets(source, resolve, file) {
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0) return source;
+  const facts = dynamicCallFacts(source, file);
+  const edits = [];
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target) continue;
+    const file2 = resolve(target.specifier);
+    if (!file2) continue;
+    const args = source.slice(call.open + 1, call.close);
+    const argCount = topLevelArgCount(args);
+    if (argCount < 1 || argCount > 2) continue;
+    const literal = JSON.stringify({ file: file2, exportName: target.exportName });
+    const separator = /,\s*$/.test(args) ? "" : ", ";
+    edits.push({
+      at: call.close,
+      value: `${separator}${argCount === 1 ? "undefined, " : ""}${literal}`
+    });
+  }
+  if (edits.length === 0) return source;
+  let next = source;
+  for (const edit of edits.reverse()) {
+    next = `${next.slice(0, edit.at)}${edit.value}${next.slice(edit.at)}`;
+  }
+  return next;
+}
+function factForCall(facts, call) {
+  return facts.find((fact) => fact.start === call.index);
+}
+function loaderImportTargetForCall(call, facts) {
+  const fact = factForCall(facts, call);
+  return fact && !fact.literal ? fact : void 0;
+}
+function devDynamicSplitEnabled() {
+  return process.env.PNEXT_DYNAMIC_SPLIT !== "0";
+}
+function deferredDynamicImportSpecifiers(source, file) {
+  const deferred = /* @__PURE__ */ new Set();
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0) return deferred;
+  const optionConsts = /* @__PURE__ */ new Map();
+  const constPattern = /const\s+([A-Za-z_$][\w$]*)\s*=\s*({[\s\S]*?})\s*(?:as\s+const\s*)?;/g;
+  let constMatch;
+  while (constMatch = constPattern.exec(source)) {
+    if (constMatch[1] && constMatch[2]) optionConsts.set(constMatch[1], constMatch[2]);
+  }
+  const facts = dynamicCallFacts(source, file);
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target) continue;
+    const tail = source.slice(target.loaderEnd, call.close);
+    let options = tail;
+    for (const identifier of tail.match(/[A-Za-z_$][\w$]*/g) ?? []) {
+      const named = optionConsts.get(identifier);
+      if (named) options += `
+${named}`;
+    }
+    const ssrFalse = /\bssr\s*:\s*false\b/.test(options);
+    const visible = /\bload\s*:\s*['"]visible['"]/.test(options) && !/\bssr\s*:\s*true\b/.test(options);
+    if (ssrFalse || visible) deferred.add(target.specifier);
+  }
+  return deferred;
+}
+function topLevelArgCount(args) {
+  let count = 0;
+  let depth = 0;
+  let quote = null;
+  let sawArg = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const char = args[index];
+    if (quote) {
+      if (char === quote && args[index - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      sawArg = true;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
+    if (char === "," && depth === 0) {
+      if (sawArg) count += 1;
+      sawArg = false;
+      continue;
+    }
+    if (!/\s/.test(char ?? "")) sawArg = true;
+  }
+  return sawArg ? count + 1 : count;
+}
+function matchingParen(source, open) {
+  let depth = 0;
+  let quote = null;
+  for (let index = open; index < source.length; index += 1) {
+    const char = source[index];
+    const previous = source[index - 1];
+    if (quote) {
+      if (char === quote && previous !== "\\") quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(") depth += 1;
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function nextDynamicCallIndex(source, dynamicNames, fromIndex) {
+  let next = -1;
+  for (const name of dynamicNames) {
+    const index = source.indexOf(name, fromIndex);
+    if (index !== -1 && (next === -1 || index < next)) next = index;
+  }
+  return next;
+}
+function dynamicNameAt(source, dynamicNames, index) {
+  for (const name of dynamicNames) {
+    if (source.startsWith(name, index)) return name;
+  }
+  return void 0;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/render/hooks.ts
+function nextCompatEnabled(config) {
+  return Boolean(config.compat?.next);
+}
+function reactCompatEnabled(config) {
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+}
+var fontExtensions = {
+  runWithFontScope: (callback) => callback(),
+  collectFontAssets: () => Promise.resolve({ css: "", preloads: [] }),
+  prewarmFontAssets: () => Promise.resolve()
+};
+function getFontExtensions() {
+  return fontExtensions;
+}
+function setFontExtensions(overrides) {
+  Object.assign(fontExtensions, overrides);
+}
+var suspenseExtensions = {
+  ensureCompatSuspense: () => Promise.resolve(),
+  compatSuspenseType: () => void 0
+};
+function getSuspenseExtensions() {
+  return suspenseExtensions;
+}
+function setSuspenseExtensions(overrides) {
+  Object.assign(suspenseExtensions, overrides);
+}
+var streamRouteExtensions = {
+  canStreamRoute: () => true,
+  inlineSuspenseStream: () => false
+};
+function getStreamRouteExtensions() {
+  return streamRouteExtensions;
+}
+function setStreamRouteExtensions(overrides) {
+  Object.assign(streamRouteExtensions, overrides);
+}
+var streamBoundaryExtensions = {
+  onStreamBoundaryError: () => void 0
+};
+function setStreamBoundaryExtensions(overrides) {
+  Object.assign(streamBoundaryExtensions, overrides);
+}
+function reportStreamBoundaryError(error) {
+  try {
+    const result = streamBoundaryExtensions.onStreamBoundaryError(error);
+    if (isThenable(result)) {
+      void Promise.resolve(result).catch((reportError) => {
+        console.error("stream boundary error hook failed:", reportError);
+      });
+    }
+  } catch (reportError) {
+    console.error("stream boundary error hook failed:", reportError);
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var metadataExtensions = {};
+function getActiveMetadataExtensions(config) {
+  return metadataExtensions.enabled?.(config) ? metadataExtensions : {};
+}
+function setMetadataExtensions(overrides) {
+  Object.assign(metadataExtensions, overrides);
+}
+var documentScriptExtensions = {
+  stylesheetPrecedence: () => void 0,
+  documentBodyScripts: () => ""
+};
+function getDocumentScriptExtensions() {
+  return documentScriptExtensions;
+}
+function setDocumentScriptExtensions(overrides) {
+  Object.assign(documentScriptExtensions, overrides);
+}
+var staticParamsExtensions = {
+  normalizeModule: (module) => typeof module.params === "function" || typeof module.generateStaticParams !== "function" ? module : { ...module, params: module.generateStaticParams }
+};
+function getStaticParamsExtensions() {
+  return staticParamsExtensions;
+}
+function setStaticParamsExtensions(overrides) {
+  Object.assign(staticParamsExtensions, overrides);
+}
+var actionModuleExtensions = {
+  tagActionModulesForRender: () => Promise.resolve(),
+  tagActionModuleExports: () => void 0
+};
+function getActionModuleExtensions() {
+  return actionModuleExtensions;
+}
+function setActionModuleExtensions(overrides) {
+  Object.assign(actionModuleExtensions, overrides);
+}
+var renderSpanExtensions = {
+  withRenderBodySpan: (_route, fn) => fn(),
+  withFindPageComponentsSpan: (_route, fn) => fn(),
+  emitResolveSegmentSpan: () => void 0,
+  withRouteHandlerSpan: (_route, fn) => fn()
+};
+function getRenderSpanExtensions() {
+  return renderSpanExtensions;
+}
+function setRenderSpanExtensions(overrides) {
+  Object.assign(renderSpanExtensions, overrides);
+}
+for (const registry of [
+  fontExtensions,
+  suspenseExtensions,
+  streamRouteExtensions,
+  streamBoundaryExtensions,
+  metadataExtensions,
+  documentScriptExtensions,
+  staticParamsExtensions,
+  actionModuleExtensions,
+  renderSpanExtensions
+]) {
+  restoreWithExtensionHost(registry);
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/verbose.ts
+function formatDuration(durationMs) {
+  const ms = Math.max(0, durationMs);
+  if (ms < 10) return `${ms.toFixed(1)}ms`;
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(ms < 1e4 ? 2 : 1)}s`;
+}
+
+export {
+  sourceHasDynamicImport,
+  pnextDynamicImportNames,
+  dynamicCallsFromSource,
+  rewriteLiteralDynamicCalls,
+  rewriteDynamicCallTargets,
+  devDynamicSplitEnabled,
+  deferredDynamicImportSpecifiers,
+  nextCompatEnabled,
+  reactCompatEnabled,
+  getFontExtensions,
+  setFontExtensions,
+  getSuspenseExtensions,
+  setSuspenseExtensions,
+  getStreamRouteExtensions,
+  setStreamRouteExtensions,
+  setStreamBoundaryExtensions,
+  reportStreamBoundaryError,
+  getActiveMetadataExtensions,
+  setMetadataExtensions,
+  getDocumentScriptExtensions,
+  setDocumentScriptExtensions,
+  getStaticParamsExtensions,
+  setStaticParamsExtensions,
+  getActionModuleExtensions,
+  setActionModuleExtensions,
+  getRenderSpanExtensions,
+  setRenderSpanExtensions,
+  formatDuration
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-COXJAPTU.js

@@ -0,0 +1,89 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  onExtensionHostReset
+} from "./chunk-4P5CMIYT.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/runtime/fetch-host.ts
+var installed = false;
+var upstreamAborts = /* @__PURE__ */ new WeakMap();
+function isHostKey(key) {
+  return typeof key === "string" && key.length === 4 && key.toLowerCase() === "host";
+}
+function hasHost(headers) {
+  if (headers instanceof Headers) return headers.has("host");
+  if (Array.isArray(headers)) {
+    for (const entry of headers) if (isHostKey(entry?.[0])) return true;
+    return false;
+  }
+  for (const key in headers) if (isHostKey(key)) return true;
+  return false;
+}
+function withoutHost(headers) {
+  const next = new Headers(headers);
+  next.delete("host");
+  return next;
+}
+function installFetchHostNormalization() {
+  if (installed) return;
+  installed = true;
+  const original = globalThis.fetch.bind(globalThis);
+  globalThis.fetch = function fetch(input, init) {
+    const source = init?.headers ?? (input instanceof Request ? input.headers : void 0);
+    const normalized = source !== void 0 && hasHost(source) ? { ...init, headers: withoutHost(source) } : init;
+    return trackUpstream(original, input, normalized);
+  };
+}
+function trackUpstream(original, input, init) {
+  const controller = new AbortController();
+  const caller = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+  const signal = caller ? AbortSignal.any([caller, controller.signal]) : controller.signal;
+  return original(input, { ...init, signal }).then((response) => {
+    if (response.body) upstreamAborts.set(response.body, controller);
+    return response;
+  });
+}
+function abortUpstreamFetchOnDisconnect(body, signal) {
+  if (!body || !signal || !upstreamAborts.has(body)) return;
+  const abort = () => {
+    const controller = upstreamAborts.get(body);
+    if (!controller) return;
+    upstreamAborts.delete(body);
+    controller.abort();
+  };
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat-bootstrap.ts
+function compatEnabled(config) {
+  const compat = config.compat;
+  return Boolean(compat?.next || compat?.react || compat?.reactCompiler);
+}
+var bootRegistration;
+var registration;
+onExtensionHostReset(() => {
+  bootRegistration = void 0;
+  registration = void 0;
+});
+function bootstrapCompatBoot(config) {
+  installFetchHostNormalization();
+  if (!compatEnabled(config)) return Promise.resolve();
+  bootRegistration ??= import("./boot-B2MFTRO2.js").then(
+    (module) => module.registerCompatBootExtensions(config)
+  );
+  return bootRegistration;
+}
+function bootstrapCompat(config, options = {}) {
+  installFetchHostNormalization();
+  if (!compatEnabled(config)) return Promise.resolve();
+  registration ??= bootstrapCompatBoot(config).then(() => import("./register-4SA55SWT.js")).then((module) => module.registerCompatExtensions(config, options));
+  return registration;
+}
+
+export {
+  abortUpstreamFetchOnDisconnect,
+  bootstrapCompat
+};