@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/base.js

@@ -69,6 +69,18 @@ var booleanAttributes = [
   "reversed",
   "selected"
 ];
+var resolveFunctionComponentResult = (result, suspendedContext) => result.then((resolved) => {
+  if (typeof resolved !== "string" && !Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
+    return resolved;
+  }
+  const children = Array.isArray(resolved) ? resolved : [resolved];
+  const render = () => {
+    const buffer = [""];
+    childrenToStringToBuffer(children, buffer);
+    return buffer.length === 1 ? raw(buffer[0], buffer.callbacks) : stringBufferToString(buffer, buffer.callbacks);
+  };
+  return suspendedContext ? suspendedContext(render) : runWithRenderContext(render);
+});
 var childrenToStringToBuffer = (children, buffer) => {
   for (let i = 0, len = children.length; i < len; i++) {
     const child = children[i];
@@ -78,9 +90,17 @@ var childrenToStringToBuffer = (children, buffer) => {
       continue;
     } else if (child instanceof JSXNode) {
       child.toStringToBuffer(buffer);
-    } else if (typeof child === "number" || child.isEscaped) {
+    } else if (typeof child === "number") {
+      ;
+      buffer[0] += child;
+    } else if (child.isEscaped) {
       ;
       buffer[0] += child;
+      const callbacks = child.callbacks;
+      if (callbacks) {
+        buffer.callbacks ||= [];
+        buffer.callbacks.push(...callbacks);
+      }
     } else if (child instanceof Promise) {
       buffer.unshift("", child);
     } else {
@@ -88,13 +108,23 @@ var childrenToStringToBuffer = (children, buffer) => {
     }
   }
 };
+var renderChildren = (children) => runWithRenderContext(() => {
+  const buffer = [""];
+  childrenToStringToBuffer(children, buffer);
+  return buffer.length === 1 ? raw(buffer[0], buffer.callbacks) : stringBufferToString(buffer, buffer.callbacks);
+});
+var isUntrustedObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof JSXNode) && !(value instanceof Promise) && !value.isEscaped && typeof value.toString === "function";
+var renderUntrustedObject = (value) => {
+  const stringified = value.toString();
+  const escape = (result) => renderChildren([String(result)]);
+  return stringified instanceof Promise ? stringified.then(escape) : escape(stringified);
+};
 var JSXNode = class {
   tag;
   props;
   key;
   children;
   isEscaped = true;
-  suspendedContext;
   constructor(tag, props, children) {
     if (typeof tag !== "function" && !isValidTagName(tag)) {
       throw new Error(`Invalid JSX tag name: ${tag}`);
@@ -117,7 +147,7 @@ var JSXNode = class {
       this.toStringToBuffer(buffer);
       return buffer.length === 1 ? "callbacks" in buffer ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString() : buffer[0] : stringBufferToString(buffer, buffer.callbacks);
     };
-    return this.suspendedContext ? this.suspendedContext(render) : runWithRenderContext(render);
+    return runWithRenderContext(render);
   }
   toStringToBuffer(buffer) {
     const tag = this.tag;
@@ -191,21 +221,14 @@ var JSXFunctionNode = class extends JSXNode {
       return;
     } else if (res instanceof Promise) {
       if (globalContexts.length === 0) {
-        buffer.unshift("", res);
+        buffer.unshift("", resolveFunctionComponentResult(res));
       } else {
-        const suspendedContext = captureRenderContext();
-        buffer.unshift(
-          "",
-          res.then((childRes) => {
-            if (childRes instanceof JSXNode) {
-              childRes.suspendedContext = suspendedContext;
-            }
-            return childRes;
-          })
-        );
+        buffer.unshift("", resolveFunctionComponentResult(res, captureRenderContext()));
       }
     } else if (res instanceof JSXNode) {
       res.toStringToBuffer(buffer);
+    } else if (Array.isArray(res)) {
+      childrenToStringToBuffer(res, buffer);
     } else if (typeof res === "number" || res.isEscaped) {
       buffer[0] += res;
       if (res.callbacks) {
@@ -284,15 +307,7 @@ var shallowEqual = (a, b) => {
   return true;
 };
 var memo = (component, propsAreEqual = shallowEqual) => {
-  let computed = null;
-  let prevProps = void 0;
-  const wrapper = ((props) => {
-    if (prevProps && !propsAreEqual(prevProps, props)) {
-      computed = null;
-    }
-    prevProps = props;
-    return computed ||= component(props);
-  });
+  const wrapper = ((props) => component(props));
   wrapper[DOM_MEMO] = propsAreEqual;
   wrapper[DOM_RENDERER] = component;
   return wrapper;
@@ -333,10 +348,13 @@ export {
   booleanAttributes,
   cloneElement,
   getNameSpaceContext,
+  isUntrustedObject,
   isValidElement,
   jsx,
   jsxFn,
   memo,
   reactAPICompatVersion,
+  renderChildren,
+  renderUntrustedObject,
   shallowEqual
 };

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/components.js

@@ -1,7 +1,7 @@
 // src/jsx/components.ts
 import { raw } from "../helper/html/index.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
-import { jsx, Fragment } from "./base.js";
+import { jsx, Fragment, isUntrustedObject, renderChildren, renderUntrustedObject } from "./base.js";
 import { DOM_RENDERER } from "./constants.js";
 import { captureRenderContext, useContext } from "./context.js";
 import { ErrorBoundary as ErrorBoundaryDomRenderer } from "./dom/components.js";
@@ -9,7 +9,7 @@ import { StreamingContext } from "./streaming.js";
 var errorBoundaryCounter = 0;
 var childrenToString = async (children) => {
   try {
-    return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
+    return children.flat().map(resolveChildEarly);
   } catch (e) {
     if (e instanceof Promise) {
       const resume = captureRenderContext();
@@ -20,18 +20,16 @@ var childrenToString = async (children) => {
     }
   }
 };
-var resolveChildEarly = (c) => {
-  if (c == null || typeof c === "boolean") {
+var resolveChildEarly = (child) => {
+  if (child == null || typeof child === "boolean") {
     return "";
-  } else if (typeof c === "string") {
-    return c;
+  } else if (typeof child === "string" || Array.isArray(child)) {
+    return renderChildren([child]);
+  } else if (isUntrustedObject(child)) {
+    return renderUntrustedObject(child);
   } else {
-    const str = c.toString();
-    if (!(str instanceof Promise)) {
-      return raw(str);
-    } else {
-      return str;
-    }
+    const str = child.toString();
+    return str instanceof Promise ? str : raw(str);
   }
 };
 var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
@@ -47,26 +45,27 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
   let fallbackStrPromise;
   const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
     const awaitedFallback = await fallback;
-    if (typeof awaitedFallback === "string") {
-      return awaitedFallback;
-    } else {
-      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
-      if (typeof fallbackResult === "string") {
-        return raw(
-          fallbackResult,
-          fallbackResult.callbacks || awaitedFallback?.callbacks
-        );
-      }
+    if (awaitedFallback === null || awaitedFallback === void 0) {
+      return;
+    }
+    if (typeof awaitedFallback === "string" || Array.isArray(awaitedFallback)) {
+      return getResume()(() => renderChildren([awaitedFallback]));
+    }
+    if (isUntrustedObject(awaitedFallback)) {
+      return getResume()(() => renderUntrustedObject(awaitedFallback));
     }
+    const fallbackResult = await getResume()(() => awaitedFallback.toString());
+    return raw(
+      fallbackResult,
+      fallbackResult.callbacks || awaitedFallback.callbacks
+    );
   })();
   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();
+      const fallbackResString = await Fragment({ children: fallbackRes }).toString();
       return raw(
         fallbackResString,
         fallbackResString.callbacks || fallbackRes.callbacks
@@ -99,7 +98,7 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
       const fallbackResString = await renderFallback(error2);
       const fallbackCallbacks = fallbackResString.callbacks;
       if (buffer) {
-        buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+        buffer[0] = buffer[0].replace(replaceRe, () => fallbackResString);
         return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
       }
       return raw(
@@ -138,7 +137,7 @@ d.parentElement.insertBefore(c.content,d.nextSibling)
 </script>`;
           if (htmlArray.every((html2) => !html2.callbacks?.length)) {
             if (buffer) {
-              buffer[0] = buffer[0].replace(replaceRe, content);
+              buffer[0] = buffer[0].replace(replaceRe, () => content);
             }
             return html;
           }

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/context.js

@@ -1,6 +1,6 @@
 // src/jsx/context.ts
 import { raw } from "../helper/html/index.js";
-import { JSXFragmentNode } from "./base.js";
+import { isUntrustedObject, JSXFragmentNode, renderChildren, renderUntrustedObject } from "./base.js";
 import { DOM_RENDERER } from "./constants.js";
 import { createContextProviderFunction } from "./dom/context.js";
 var globalContexts = [];
@@ -130,18 +130,18 @@ var createContext = (defaultValue) => {
   const context = ((props) => {
     const contextValues = getContextValuesIn(getCurrentStore(), context);
     contextValues.push(props.value);
-    let string;
+    let rendered;
     try {
-      string = props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
+      rendered = typeof props.children === "string" ? renderChildren([props.children]) : isUntrustedObject(props.children) ? renderUntrustedObject(props.children) : props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : raw("");
     } catch (e) {
       contextValues.pop();
       throw e;
     }
-    if (string instanceof Promise) {
-      return string.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
+    if (rendered instanceof Promise) {
+      return rendered.finally(() => contextValues.pop()).then((resString) => raw(resString, resString.callbacks));
     } else {
       contextValues.pop();
-      return raw(string);
+      return raw(rendered);
     }
   });
   context.values = values;

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/dom/render.js

@@ -78,6 +78,7 @@ var applyProps = (container, attributes, oldAttributes) => {
       } else if (key === "dangerouslySetInnerHTML" && value) {
         container.innerHTML = value.__html;
       } else if (key === "ref") {
+        refCleanupMap.get(container)?.();
         let cleanup;
         if (typeof value === "function") {
           cleanup = value(container) || (() => value(null));
@@ -142,6 +143,7 @@ var applyProps = (container, attributes, oldAttributes) => {
           container.removeEventListener(eventSpec[0], value, eventSpec[1]);
         } else if (key === "ref") {
           refCleanupMap.get(container)?.();
+          refCleanupMap.delete(container);
         } else {
           try {
             container.removeAttribute(toAttributeName(container, key));

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/dom/server.js

@@ -1,11 +1,14 @@
 // src/jsx/dom/server.ts
+import { renderChildren } from "../base.js";
 import { renderToReadableStream as renderToReadableStreamHono } from "../streaming.js";
 import version from "./index.js";
+var prepareRoot = (element) => typeof element === "string" || Array.isArray(element) ? renderChildren([element]) : element;
 var renderToString = (element, options = {}) => {
   if (Object.keys(options).length > 0) {
     console.warn("options are not supported yet");
   }
-  const res = element?.toString() ?? "";
+  element = prepareRoot(element);
+  const res = element instanceof Promise ? element : element?.toString() ?? "";
   if (typeof res !== "string") {
     throw new Error("Async component is not supported in renderToString");
   }
@@ -15,6 +18,7 @@ var renderToReadableStream = async (element, options = {}) => {
   if (Object.keys(options).some((key) => key !== "onError")) {
     console.warn("options are not supported yet, except onError");
   }
+  element = prepareRoot(element);
   if (!element || typeof element !== "object") {
     element = element?.toString() ?? "";
   }

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/hooks/index.js

@@ -222,7 +222,7 @@ var useCallback = (callback, deps) => {
   }
   return callback;
 };
-var useRef = (initialValue) => {
+function useRef(initialValue) {
   const buildData = buildDataStack.at(-1);
   if (!buildData) {
     return { current: initialValue };
@@ -231,7 +231,7 @@ var useRef = (initialValue) => {
   const refArray = node[DOM_STASH][1][STASH_REF] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
   return refArray[hookIndex] ||= { current: initialValue };
-};
+}
 var use = (promise) => {
   const cachedRes = resolvedPromiseValueMap.get(promise);
   if (cachedRes) {
@@ -289,19 +289,22 @@ var useSyncExternalStore = (subscribe, getSnapshot, getServerSnapshot) => {
     }
     return getServerSnapshot();
   }
-  const [serverSnapshotIsUsed] = useState(!!(buildData[0][4] && getServerSnapshot));
-  const [state, setState] = useState(
-    () => serverSnapshotIsUsed ? getServerSnapshot() : getSnapshot()
-  );
+  const snapshot = buildData[0][4] && getServerSnapshot ? getServerSnapshot() : getSnapshot();
+  const [, setVersion] = useState(0);
+  const latestSnapshot = useRef([snapshot, getSnapshot]);
+  latestSnapshot.current = [snapshot, getSnapshot];
+  const unsubscribeRef = useRef(null);
   useEffect(() => {
-    if (serverSnapshotIsUsed) {
-      setState(getSnapshot());
+    const update2 = () => setVersion((version) => version + 1);
+    unsubscribeRef.current?.();
+    unsubscribeRef.current = subscribe(update2);
+    const [snapshot2, getSnapshot2] = latestSnapshot.current;
+    if (!Object.is(snapshot2, getSnapshot2())) {
+      update2();
     }
-    return subscribe(() => {
-      setState(getSnapshot());
-    });
-  }, []);
-  return state;
+  }, [subscribe]);
+  useEffect(() => () => unsubscribeRef.current?.(), []);
+  return snapshot;
 };
 export {
   STASH_EFFECT,

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/intrinsic-element/components.js

@@ -1,6 +1,6 @@
 // src/jsx/intrinsic-element/components.ts
 import { raw } from "../../helper/html/index.js";
-import { JSXNode, getNameSpaceContext } from "../base.js";
+import { JSXNode, getNameSpaceContext, renderChildren } from "../base.js";
 import { toArray } from "../children.js";
 import { PERMALINK } from "../constants.js";
 import { useContext } from "../context.js";
@@ -62,10 +62,10 @@ var insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context })
     insertTags.forEach((tag2) => {
       buffer[0] = buffer[0].replaceAll(tag2, "");
     });
-    buffer[0] = buffer[0].replace(/(?=<\/head>)/, insertTags.join(""));
+    buffer[0] = buffer[0].replace(/(?=<\/head>)/, () => insertTags.join(""));
   }
 };
-var returnWithoutSpecialBehavior = (tag, children, props) => raw(new JSXNode(tag, props, toArray(children ?? [])).toString());
+var returnWithoutSpecialBehavior = (tag, children, props) => renderChildren([new JSXNode(tag, props, toArray(children ?? []))]);
 var documentMetadataTag = (tag, children, props, sort) => {
   if ("itemProp" in props) {
     return returnWithoutSpecialBehavior(tag, children, props);
@@ -78,7 +78,7 @@ var documentMetadataTag = (tag, children, props, sort) => {
   const string = new JSXNode(tag, restProps, toArray(children || [])).toString();
   if (string instanceof Promise) {
     return string.then(
-      (resString) => raw(string, [
+      (resString) => raw(resString, [
         ...resString.callbacks || [],
         insertIntoHead(tag, resString, restProps, precedence)
       ])

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/jsx/streaming.js

@@ -1,7 +1,7 @@
 // src/jsx/streaming.ts
 import { raw } from "../helper/html/index.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
-import { JSXNode } from "./base.js";
+import { isUntrustedObject, JSXNode, renderChildren, renderUntrustedObject } from "./base.js";
 import { childrenToString } from "./components.js";
 import { DOM_RENDERER, DOM_STASH } from "./constants.js";
 import { captureRenderContext, createContext, useContext } from "./context.js";
@@ -9,6 +9,7 @@ import { Suspense as SuspenseDomRenderer } from "./dom/components.js";
 import { buildDataStack } from "./dom/render.js";
 var StreamingContext = createContext(null);
 var suspenseCounter = 0;
+var serializeBoundaryChild = (child) => typeof child === "string" || Array.isArray(child) ? renderChildren([child]) : child == null || typeof child === "boolean" ? "" : isUntrustedObject(child) ? renderUntrustedObject(child) : child.toString();
 var Suspense = async ({
   children,
   fallback
@@ -25,9 +26,7 @@ var Suspense = async ({
   try {
     stackNode[DOM_STASH][0] = 0;
     buildDataStack.push([[], stackNode]);
-    resArray = children.map(
-      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
-    );
+    resArray = children.map(serializeBoundaryChild);
   } catch (e) {
     if (e instanceof Promise) {
       const resume = captureRenderContext();
@@ -48,7 +47,7 @@ var Suspense = async ({
   }
   if (resArray.some((res) => res instanceof Promise)) {
     const index = suspenseCounter++;
-    const fallbackStr = await fallback.toString();
+    const fallbackStr = await (typeof fallback === "string" || Array.isArray(fallback) ? renderChildren([fallback]) : isUntrustedObject(fallback) ? renderUntrustedObject(fallback) : fallback.toString());
     return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [
       ...fallbackStr.callbacks || [],
       ({ phase, buffer, context }) => {
@@ -61,7 +60,7 @@ var Suspense = async ({
           if (buffer) {
             buffer[0] = buffer[0].replace(
               new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`),
-              content
+              () => content
             );
           }
           let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/middleware/cache/index.js

@@ -1,5 +1,19 @@
 // src/middleware/cache/index.ts
+import { cloneRawRequest } from "../../request.js";
+import { sha256 } from "../../utils/crypto.js";
 var defaultCacheableStatusCodes = [200];
+var defaultMaxQueryBodySize = 64 * 1024;
+var cacheKeyPath = "/.hono/cache";
+var cacheKeyParameter = "__hono_cache_key";
+var cacheMethodKeyParameter = "__hono_cache_method";
+var queryDigestKeyParameter = "__hono_query_digest";
+var cacheVaryKeyParameter = "__hono_cache_vary";
+var queryRepresentationMetadataHeaders = [
+  "content-type",
+  "content-encoding",
+  "content-language",
+  "content-location"
+];
 var shouldSkipCacheControl = (cacheControl) => !!cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl);
 var parseVaryDirectives = (vary) => {
   if (vary == null) {
@@ -7,17 +21,86 @@ var parseVaryDirectives = (vary) => {
   }
   return (Array.isArray(vary) ? vary : vary.split(",")).map((directive) => directive.trim().toLowerCase()).filter(Boolean);
 };
+var createCacheKey = (key, requestUrl, request, varyHeaders) => {
+  const url = new URL(cacheKeyPath, requestUrl);
+  url.searchParams.append(cacheKeyParameter, key);
+  url.searchParams.append(cacheMethodKeyParameter, request.method);
+  if (request.method === "QUERY") {
+    url.searchParams.append(queryDigestKeyParameter, request.digest);
+  }
+  for (const header of varyHeaders) {
+    url.searchParams.append(cacheVaryKeyParameter, JSON.stringify(header));
+  }
+  return url.href;
+};
 var shouldSkipCache = (res, optionsVaryDirectives, responseVary) => responseVary.length && (!optionsVaryDirectives || responseVary.some((name) => !optionsVaryDirectives.has(name))) || shouldSkipCacheControl(res.headers.get("Cache-Control")) || res.headers.has("Set-Cookie");
+var reportCacheNotAvailable = (onCacheNotAvailable, reason) => {
+  if (onCacheNotAvailable === false) {
+  } else if (onCacheNotAvailable) {
+    onCacheNotAvailable(reason);
+  } else {
+    console.log(reason);
+  }
+};
+var createQueryDigest = async (c, maxQueryBodySize) => {
+  if (!globalThis.crypto?.subtle) {
+    return void 0;
+  }
+  if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") {
+    return void 0;
+  }
+  try {
+    const requestHeaders = c.req.raw.headers;
+    const metadata = new TextEncoder().encode(
+      JSON.stringify(
+        queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])
+      )
+    );
+    const body = (await cloneRawRequest(c.req)).body;
+    const chunks = [];
+    let bodySize = 0;
+    if (body) {
+      const reader = body.getReader();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        bodySize += value.byteLength;
+        if (bodySize > maxQueryBodySize) {
+          void reader.cancel().catch(() => {
+          });
+          return void 0;
+        }
+        chunks.push(value);
+      }
+    }
+    const data = new Uint8Array(metadata.byteLength + bodySize);
+    data.set(metadata);
+    let offset = metadata.byteLength;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return await sha256(data) ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
 var cache = (options) => {
   if (!globalThis.caches) {
-    if (options.onCacheNotAvailable === false) {
-    } else if (options.onCacheNotAvailable) {
-      options.onCacheNotAvailable();
-    } else {
-      console.log("Cache Middleware is not enabled because caches is not defined.");
-    }
+    reportCacheNotAvailable(
+      options.onCacheNotAvailable,
+      "Cache Middleware is not enabled because caches is not defined."
+    );
     return async (_c, next) => await next();
   }
+  if (!globalThis.crypto?.subtle) {
+    reportCacheNotAvailable(
+      options.onCacheNotAvailable,
+      "Cache Middleware cannot cache QUERY requests because Web Crypto is not available."
+    );
+  }
   if (options.wait === void 0) {
     options.wait = false;
   }
@@ -32,6 +115,7 @@ var cache = (options) => {
   const cacheableStatusCodes = new Set(
     options.cacheableStatusCodes ?? defaultCacheableStatusCodes
   );
+  const maxQueryBodySize = options.maxQueryBodySize ?? defaultMaxQueryBodySize;
   const addHeader = (c, responseVary) => {
     if (cacheControlDirectives) {
       const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0].toLowerCase()) ?? [];
@@ -60,20 +144,31 @@ var cache = (options) => {
     }
   };
   return async function cache2(c, next) {
-    if (c.req.method !== "GET" || c.req.raw.headers.has("Authorization")) {
+    if (c.req.method !== "GET" && c.req.method !== "QUERY" || c.req.raw.headers.has("Authorization")) {
       await next();
       return;
     }
+    let cacheKeyRequest = { method: "GET" };
+    if (c.req.method === "QUERY") {
+      const digest = await createQueryDigest(c, maxQueryBodySize);
+      if (digest === void 0) {
+        await next();
+        return;
+      }
+      cacheKeyRequest = { method: "QUERY", digest };
+    }
     let key = c.req.url;
     if (options.keyGenerator) {
       key = await options.keyGenerator(c);
     }
+    const varyHeaders = [];
     if (varyDirectives) {
       for (const directive of varyDirectives) {
         const value = c.req.raw.headers.get(directive) ?? "";
-        key += `::${directive}=${encodeURIComponent(value)}`;
+        varyHeaders.push([directive, value]);
       }
     }
+    key = createCacheKey(key, c.req.url, cacheKeyRequest, varyHeaders);
     const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
     const cache3 = await caches.open(cacheName);
     const response = await cache3.match(key);

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/hono/dist/middleware/compress/index.js

@@ -21,6 +21,7 @@ var selectEncoding = (header, candidates) => {
   }
   return best?.encoding;
 };
+var varyAcceptEncodingRegExp = /(?:^|,)\s*accept-encoding\s*(?:,|$)/i;
 var compress = (options) => {
   const threshold = options?.threshold ?? 1024;
   const candidates = options?.encoding ? [options.encoding] : ENCODING_TYPES;
@@ -44,6 +45,10 @@ var compress = (options) => {
     !shouldTransform(ctx.res)) {
       return;
     }
+    const current = ctx.res.headers.get("Vary");
+    if (current !== "*" && !(current && varyAcceptEncodingRegExp.test(current))) {
+      ctx.header("Vary", current ? `${current}, Accept-Encoding` : "Accept-Encoding");
+    }
     const accepted = ctx.req.header("Accept-Encoding");
     const encoding = selectEncoding(accepted, candidates);
     if (!encoding || !ctx.res.body) {