@suveren/gateway 0.2.11 → 0.3.0

package/node_modules/hono/dist/jsx/components.js

@@ -3,7 +3,7 @@ import { raw } from "../helper/html/index.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
 import { jsx, Fragment } from "./base.js";
 import { DOM_RENDERER } from "./constants.js";
-import { useContext } from "./context.js";
+import { captureRenderContext, useContext } from "./context.js";
 import { ErrorBoundary as ErrorBoundaryDomRenderer } from "./dom/components.js";
 import { StreamingContext } from "./streaming.js";
 var errorBoundaryCounter = 0;
@@ -12,8 +12,9 @@ var childrenToString = async (children) => {
     return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = captureRenderContext();
       await e;
-      return childrenToString(children);
+      return resume(() => childrenToString(children));
     } else {
       throw e;
     }
@@ -41,51 +42,68 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
     children = [children];
   }
   const nonce = useContext(StreamingContext)?.scriptNonce;
-  let fallbackStr;
-  const resolveFallbackStr = async () => {
+  let resume;
+  const getResume = () => resume ||= captureRenderContext();
+  let fallbackStrPromise;
+  const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
     const awaitedFallback = await fallback;
     if (typeof awaitedFallback === "string") {
-      fallbackStr = awaitedFallback;
+      return awaitedFallback;
     } else {
-      fallbackStr = await awaitedFallback?.toString();
-      if (typeof fallbackStr === "string") {
-        fallbackStr = raw(fallbackStr);
+      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
+      if (typeof fallbackResult === "string") {
+        return raw(
+          fallbackResult,
+          fallbackResult.callbacks || awaitedFallback?.callbacks
+        );
       }
     }
-  };
-  const fallbackRes = (error) => {
-    onError?.(error);
-    return fallbackStr || fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+  })();
+  const renderFallback = async (error) => {
+    const fallbackStr = await resolveFallbackStr();
+    return getResume()(async () => {
+      onError?.(error);
+      const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+      const fallbackResString = await Fragment({
+        children: fallbackRes
+      }).toString();
+      return raw(
+        fallbackResString,
+        fallbackResString.callbacks || fallbackRes.callbacks
+      );
+    });
   };
   let resArray = [];
   try {
     resArray = children.map(resolveChildEarly);
   } catch (e) {
-    await resolveFallbackStr();
+    const resume2 = getResume();
     if (e instanceof Promise) {
       resArray = [
-        e.then(() => childrenToString(children)).catch((e2) => fallbackRes(e2))
+        e.then(() => resume2(() => childrenToString(children))).catch((e2) => renderFallback(e2))
       ];
     } else {
-      resArray = [fallbackRes(e)];
+      resArray = [await renderFallback(e)];
     }
   }
   if (resArray.some((res) => res instanceof Promise)) {
-    await resolveFallbackStr();
+    getResume();
     const index = errorBoundaryCounter++;
     const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
-    const caught = false;
+    let caught = false;
     const catchCallback = async ({ error: error2, buffer }) => {
       if (caught) {
         return "";
       }
-      const fallbackResString = await Fragment({
-        children: fallbackRes(error2)
-      }).toString();
+      caught = true;
+      const fallbackResString = await renderFallback(error2);
+      const fallbackCallbacks = fallbackResString.callbacks;
       if (buffer) {
         buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+        return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
       }
-      return buffer ? "" : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
+      return raw(
+        `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
 ((d,c,n) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')
@@ -93,7 +111,9 @@ if(!d)return
 do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
 d.replaceWith(c.content)
 })(document)
-</script>`;
+</script>`,
+        fallbackCallbacks
+      );
     };
     let error;
     const promiseAll = Promise.all(resArray).catch((e) => error = e);

package/node_modules/hono/dist/jsx/context.js

@@ -4,21 +4,143 @@ import { JSXFragmentNode } from "./base.js";
 import { DOM_RENDERER } from "./constants.js";
 import { createContextProviderFunction } from "./dom/context.js";
 var globalContexts = [];
+var alsProbed = false;
+var asyncLocalStorage;
+var fallbackStore;
+var fallbackRendersInFlight = 0;
+var warnedFallbackDefault = false;
+var loadAsyncLocalStorage = () => {
+  if (alsProbed) {
+    return asyncLocalStorage;
+  }
+  alsProbed = true;
+  const global = globalThis;
+  let AsyncLocalStorage;
+  for (const probe of [
+    // Node.js >= 20.16, Deno, Bun, Cloudflare Workers (nodejs_compat). Property
+    // access only, so bundlers don't statically resolve `node:async_hooks`.
+    () => global.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage,
+    // Node.js < 20.16 has no `process.getBuiltinModule`, but a CJS entrypoint
+    // exposes the main module's `require` here.
+    () => global.process?.mainModule?.require?.("node:async_hooks")?.AsyncLocalStorage
+  ]) {
+    try {
+      AsyncLocalStorage = probe();
+    } catch {
+    }
+    if (AsyncLocalStorage) {
+      break;
+    }
+  }
+  if (AsyncLocalStorage) {
+    asyncLocalStorage = new AsyncLocalStorage();
+  }
+  return asyncLocalStorage;
+};
+var getCurrentStore = () => {
+  return loadAsyncLocalStorage()?.getStore() || fallbackStore;
+};
+var warnIfStorelessAccess = () => {
+  if (fallbackRendersInFlight > 0 && !warnedFallbackDefault) {
+    warnedFallbackDefault = true;
+    console.warn(
+      "hono/jsx: AsyncLocalStorage is unavailable in this runtime, so useContext() after an await in an async component falls back to the context default value during server-side rendering. To get provided values across await boundaries, use a runtime with AsyncLocalStorage (Node.js >= 20.16, Deno, Bun, or Cloudflare Workers with the nodejs_compat flag)."
+    );
+  }
+};
+var getContextValuesIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values;
+  }
+  let values = store.get(context);
+  if (!values) {
+    values = [context.values[0]];
+    store.set(context, values);
+  }
+  return values;
+};
+var readContextValueIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values.at(-1);
+  }
+  const values = store.get(context);
+  return values?.length ? values.at(-1) : context.values[0];
+};
+var captureContextValues = (store) => (store ? globalContexts.filter((c) => store.has(c)) : globalContexts).map((c) => [
+  c,
+  readContextValueIn(store, c)
+]);
+var resumeWithContextValues = (callback, store, contexts) => runWithRenderContext(() => {
+  const currentStore = getCurrentStore();
+  const valuesPerContext = contexts.map(([context, value]) => {
+    const values = getContextValuesIn(currentStore, context);
+    values.push(value);
+    return values;
+  });
+  const popContextValues = () => {
+    valuesPerContext.forEach((values) => {
+      values.pop();
+    });
+  };
+  try {
+    const result = callback();
+    if (result instanceof Promise) {
+      return result.finally(popContextValues);
+    }
+    popContextValues();
+    return result;
+  } catch (e) {
+    popContextValues();
+    throw e;
+  }
+}, store);
+var runWithRenderContext = (callback, resumeStore) => {
+  if (getCurrentStore()) {
+    return callback();
+  }
+  const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
+  const storage = loadAsyncLocalStorage();
+  if (storage) {
+    return storage.run(store, callback);
+  }
+  fallbackStore = store;
+  let result;
+  try {
+    result = callback();
+  } finally {
+    fallbackStore = void 0;
+  }
+  if (!warnedFallbackDefault && result instanceof Promise) {
+    fallbackRendersInFlight++;
+    result = result.finally(() => {
+      fallbackRendersInFlight--;
+    });
+  }
+  return result;
+};
+var captureRenderContext = () => {
+  const store = getCurrentStore();
+  const contexts = captureContextValues(store);
+  return (callback) => resumeWithContextValues(callback, store, contexts);
+};
 var createContext = (defaultValue) => {
   const values = [defaultValue];
   const context = ((props) => {
-    values.push(props.value);
+    const contextValues = getContextValuesIn(getCurrentStore(), context);
+    contextValues.push(props.value);
     let string;
     try {
       string = props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
     } catch (e) {
-      values.pop();
+      contextValues.pop();
       throw e;
     }
     if (string instanceof Promise) {
-      return string.finally(() => values.pop()).then((resString) => raw(resString, resString.callbacks));
+      return string.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
     } else {
-      values.pop();
+      contextValues.pop();
       return raw(string);
     }
   });
@@ -29,10 +151,12 @@ var createContext = (defaultValue) => {
   return context;
 };
 var useContext = (context) => {
-  return context.values.at(-1);
+  return readContextValueIn(getCurrentStore(), context);
 };
 export {
+  captureRenderContext,
   createContext,
   globalContexts,
+  runWithRenderContext,
   useContext
 };

package/node_modules/hono/dist/jsx/streaming.js

@@ -4,7 +4,7 @@ import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
 import { JSXNode } from "./base.js";
 import { childrenToString } from "./components.js";
 import { DOM_RENDERER, DOM_STASH } from "./constants.js";
-import { createContext, useContext } from "./context.js";
+import { captureRenderContext, createContext, useContext } from "./context.js";
 import { Suspense as SuspenseDomRenderer } from "./dom/components.js";
 import { buildDataStack } from "./dom/render.js";
 var StreamingContext = createContext(null);
@@ -19,9 +19,8 @@ var Suspense = async ({
   const nonce = useContext(StreamingContext)?.scriptNonce;
   let resArray = [];
   const stackNode = { [DOM_STASH]: [0, []] };
-  const popNodeStack = (value) => {
+  const popNodeStack = () => {
     buildDataStack.pop();
-    return value;
   };
   try {
     stackNode[DOM_STASH][0] = 0;
@@ -31,12 +30,15 @@ var Suspense = async ({
     );
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = captureRenderContext();
       resArray = [
-        e.then(() => {
-          stackNode[DOM_STASH][0] = 0;
-          buildDataStack.push([[], stackNode]);
-          return childrenToString(children).then(popNodeStack);
-        })
+        e.then(
+          () => resume(() => {
+            stackNode[DOM_STASH][0] = 0;
+            buildDataStack.push([[], stackNode]);
+            return childrenToString(children).finally(popNodeStack);
+          })
+        )
       ];
     } else {
       throw e;

package/node_modules/hono/dist/middleware/bearer-auth/index.js

@@ -6,7 +6,7 @@ var PREFIX = "Bearer";
 var HEADER = "Authorization";
 var bearerAuth = (options) => {
   if (!("token" in options || "verifyToken" in options)) {
-    throw new Error('bearer auth middleware requires options for "token"');
+    throw new Error('bearer auth middleware requires options for "token" or "verifyToken"');
   }
   if (!options.realm) {
     options.realm = "";

package/node_modules/hono/dist/middleware/cors/index.js

@@ -10,9 +10,6 @@ var cors = (options) => {
   const findAllowOrigin = ((optsOrigin) => {
     if (typeof optsOrigin === "string") {
       if (optsOrigin === "*") {
-        if (opts.credentials) {
-          return (origin) => origin || null;
-        }
         return () => optsOrigin;
       } else {
         return (origin) => optsOrigin === origin ? origin : null;
@@ -47,7 +44,7 @@ var cors = (options) => {
       set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
     }
     if (c.req.method === "OPTIONS") {
-      if (opts.origin !== "*" || opts.credentials) {
+      if (opts.origin !== "*") {
         set("Vary", "Origin");
       }
       if (opts.maxAge != null) {
@@ -77,7 +74,7 @@ var cors = (options) => {
       });
     }
     await next();
-    if (opts.origin !== "*" || opts.credentials) {
+    if (opts.origin !== "*") {
       c.header("Vary", "Origin", { append: true });
     }
   };

package/node_modules/hono/dist/middleware/language/language.js

@@ -53,20 +53,12 @@ var normalizeLanguage = (lang, options) => {
   }
 };
 var detectFromQuery = (c, options) => {
-  try {
-    const query = c.req.query(options.lookupQueryString);
-    return normalizeLanguage(query, options);
-  } catch {
-    return void 0;
-  }
+  const query = c.req.query(options.lookupQueryString);
+  return normalizeLanguage(query, options);
 };
 var detectFromCookie = (c, options) => {
-  try {
-    const cookie = getCookie(c, options.lookupCookie);
-    return normalizeLanguage(cookie, options);
-  } catch {
-    return void 0;
-  }
+  const cookie = getCookie(c, options.lookupCookie);
+  return normalizeLanguage(cookie, options);
 };
 function detectFromHeader(c, options) {
   try {
@@ -87,14 +79,10 @@ function detectFromHeader(c, options) {
   }
 }
 function detectFromPath(c, options) {
-  try {
-    const url = new URL(c.req.url);
-    const pathSegments = url.pathname.split("/").filter(Boolean);
-    const langSegment = pathSegments[options.lookupFromPathIndex];
-    return normalizeLanguage(langSegment, options);
-  } catch {
-    return void 0;
-  }
+  const url = new URL(c.req.url);
+  const pathSegments = url.pathname.split("/").filter(Boolean);
+  const langSegment = pathSegments[options.lookupFromPathIndex];
+  return normalizeLanguage(langSegment, options);
 }
 var detectors = {
   querystring: detectFromQuery,
@@ -129,9 +117,6 @@ var detectLanguage = (c, options) => {
   let detectedLang;
   for (const detectorName of options.order) {
     const detector = detectors[detectorName];
-    if (!detector) {
-      continue;
-    }
     try {
       detectedLang = detector(c, options);
       if (detectedLang) {
@@ -164,15 +149,8 @@ var languageDetector = (userOptions) => {
   };
   validateOptions(options);
   return async function languageDetector2(ctx, next) {
-    try {
-      const lang = detectLanguage(ctx, options);
-      ctx.set("language", lang);
-    } catch (error) {
-      if (options.debug) {
-        console.error("Language detection failed:", error);
-      }
-      ctx.set("language", options.fallbackLanguage);
-    }
+    const lang = detectLanguage(ctx, options);
+    ctx.set("language", lang);
     await next();
   };
 };

package/node_modules/hono/dist/middleware/serve-static/index.js

@@ -24,7 +24,7 @@ var serveStatic = (options) => {
     } else {
       try {
         filename = tryDecodeURI(c.req.path);
-        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}/.test(filename)) {
+        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) {
           throw new Error();
         }
       } catch {

package/node_modules/hono/dist/middleware/timing/timing.js

@@ -31,7 +31,9 @@ var timing = (config) => {
       endTime(c, "total");
     }
     if (options.autoEnd) {
-      timers.forEach((_, key) => endTime(c, key));
+      timers.forEach((_, key) => {
+        endTime(c, key);
+      });
     }
     const enabled = typeof options.enabled === "function" ? options.enabled(c) : options.enabled;
     if (enabled) {