@nocobase/plugin-mcp-server 2.4.0-alpha.8 → 2.4.0-alpha.9

package/dist/node_modules/hono/dist/router/trie-router/node.js

@@ -1,77 +1,53 @@
 // src/router/trie-router/node.ts
 import { METHOD_NAME_ALL } from "../../router.js";
 import { getPattern, splitPath, splitRoutingPath } from "../../utils/url.js";
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var hasChildren = (children) => {
-  for (const _ in children) {
-    return true;
-  }
-  return false;
-};
+import { createNullObject } from "../utils.js";
+var emptyParams = createNullObject();
+var order = 0;
 var Node = class _Node {
-  #methods;
-  #children;
-  #patterns;
-  #order = 0;
+  #methods = [];
+  #children = createNullObject();
+  #patterns = [];
+  #pattern;
   #params = emptyParams;
-  constructor(method, handler, children) {
-    this.#children = children || /* @__PURE__ */ Object.create(null);
-    this.#methods = [];
-    if (method && handler) {
-      const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0 };
-      this.#methods = [m];
-    }
-    this.#patterns = [];
-  }
   insert(method, path, handler) {
-    this.#order = ++this.#order;
     let curNode = this;
     const parts = splitRoutingPath(path);
-    const possibleKeys = [];
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const p = parts[i];
-      const nextP = parts[i + 1];
-      const pattern = getPattern(p, nextP);
-      const key = Array.isArray(pattern) ? pattern[0] : p;
-      if (key in curNode.#children) {
-        curNode = curNode.#children[key];
-        if (pattern) {
-          possibleKeys.push(pattern[1]);
-        }
-        continue;
+    const possibleKeys = /* @__PURE__ */ new Set();
+    let i = 0;
+    for (const p of parts) {
+      const nextP = parts[++i];
+      const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+      const isParam = Array.isArray(pattern);
+      const key = isParam ? pattern[0] : pattern || p;
+      const child = curNode.#children[key] ||= new _Node();
+      if (pattern && !child.#pattern) {
+        child.#pattern = pattern;
+        curNode.#patterns.push(child);
       }
-      curNode.#children[key] = new _Node();
-      if (pattern) {
-        curNode.#patterns.push(pattern);
-        possibleKeys.push(pattern[1]);
+      curNode = child;
+      if (isParam) {
+        possibleKeys.add(pattern[1]);
       }
-      curNode = curNode.#children[key];
     }
     curNode.#methods.push({
       [method]: {
         handler,
-        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-        score: this.#order
+        possibleKeys: [...possibleKeys],
+        score: ++order
       }
     });
-    return curNode;
   }
   #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
     for (let i = 0, len = node.#methods.length; i < len; i++) {
       const m = node.#methods[i];
       const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = {};
-      if (handlerSet !== void 0) {
-        handlerSet.params = /* @__PURE__ */ Object.create(null);
+      if (handlerSet) {
+        handlerSet.params = createNullObject();
         handlerSets.push(handlerSet);
-        if (nodeParams !== emptyParams || params && params !== emptyParams) {
-          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
-            const key = handlerSet.possibleKeys[i2];
-            const processed = processedSet[handlerSet.score];
-            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
-            processedSet[handlerSet.score] = true;
-          }
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
         }
       }
     }
@@ -103,42 +79,52 @@ var Node = class _Node {
             tempNodes.push(nextNode);
           }
         }
-        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
-          const pattern = node.#patterns[k];
+        for (const child of node.#patterns) {
+          const pattern = child.#pattern;
           const params = node.#params === emptyParams ? {} : { ...node.#params };
-          if (pattern === "*") {
-            const astNode = node.#children["*"];
-            if (astNode) {
-              this.#pushHandlerSets(handlerSets, astNode, method, node.#params);
-              astNode.#params = params;
-              tempNodes.push(astNode);
+          if (typeof pattern === "string") {
+            if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+              this.#pushHandlerSets(handlerSets, child, method, node.#params);
+              if (pattern === "*") {
+                child.#params = params;
+                tempNodes.push(child);
+              }
             }
             continue;
           }
-          const [key, name, matcher] = pattern;
-          if (!part && !(matcher instanceof RegExp)) {
+          const [, name, matcher] = pattern;
+          if (!part && matcher === true) {
             continue;
           }
-          const child = node.#children[key];
-          if (matcher instanceof RegExp) {
-            if (partOffsets === null) {
-              partOffsets = new Array(len);
+          if (matcher !== true) {
+            if (!partOffsets) {
+              partOffsets = [];
               let offset = path[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path.substring(partOffsets[i]);
+            const restPathString = path.slice(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
               this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
-              if (hasChildren(child.#children)) {
+              if (m[0].length === restPathString.length && child.#children["*"]) {
+                this.#pushHandlerSets(
+                  handlerSets,
+                  child.#children["*"],
+                  method,
+                  node.#params,
+                  params
+                );
+              }
+              for (const _ in child.#children) {
                 child.#params = params;
-                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const componentCount = m[0].match(/\//g)?.length ?? 0;
                 const targetCurNodes = curNodesQueue[componentCount] ||= [];
                 targetCurNodes.push(child);
+                break;
               }
               continue;
             }
@@ -166,7 +152,7 @@ var Node = class _Node {
       const shifted = curNodesQueue.shift();
       curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
     }
-    if (handlerSets.length > 1) {
+    if (handlerSets[1]) {
       handlerSets.sort((a, b) => {
         return a.score - b.score;
       });

package/dist/node_modules/hono/dist/router/trie-router/router.js

@@ -3,19 +3,11 @@ import { checkOptionalParameter } from "../../utils/url.js";
 import { Node } from "./node.js";
 var TrieRouter = class {
   name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new Node();
-  }
+  #node = new Node();
   add(method, path, handler) {
-    const results = checkOptionalParameter(path);
-    if (results) {
-      for (let i = 0, len = results.length; i < len; i++) {
-        this.#node.insert(method, results[i], handler);
-      }
-      return;
+    for (const result of checkOptionalParameter(path) || [path]) {
+      this.#node.insert(method, result, handler);
     }
-    this.#node.insert(method, path, handler);
   }
   match(method, path) {
     return this.#node.search(method, path);

package/dist/node_modules/hono/dist/router/utils.js

@@ -0,0 +1,5 @@
+// src/router/utils.ts
+var createNullObject = () => /* @__PURE__ */ Object.create(null);
+export {
+  createNullObject
+};

package/dist/node_modules/hono/dist/router.js

@@ -1,7 +1,7 @@
 // src/router.ts
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
 var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
 var UnsupportedPathError = class extends Error {
 };

package/dist/node_modules/hono/dist/types/adapter/aws-lambda/handler.d.ts

@@ -66,7 +66,7 @@ export interface ALBProxyEvent {
     requestContext: ALBRequestContext;
 }
 type WithHeaders = {
-    headers: Record<string, string>;
+    headers: Record<string, string | string[]>;
     multiValueHeaders?: undefined;
 };
 type WithMultiValueHeaders = {

package/dist/node_modules/hono/dist/types/adapter/aws-lambda/types.d.ts

@@ -96,6 +96,15 @@ interface Authorizer {
         userArn: string;
         userId: string;
     };
+    jwt?: {
+        claims: Record<string, string | number | boolean | string[]>;
+        scopes: string[] | null;
+    };
+    /**
+     * The `context` object returned by a Lambda (REQUEST) authorizer.
+     * It is `null` when the authorizer returns no context.
+     */
+    lambda?: Record<string, unknown> | null;
 }
 export interface ApiGatewayRequestContextV2 {
     accountId: string;

package/dist/node_modules/hono/dist/types/adapter/bun/serve-static.d.ts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from '../../middleware/serve-static';
 import type { Env, MiddlewareHandler } from '../../types';
-export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/adapter/cloudflare-workers/serve-static.d.ts

@@ -2,7 +2,7 @@ import type { ServeStaticOptions as BaseServeStaticOptions } from '../../middlew
 import type { Env, MiddlewareHandler } from '../../types';
 export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E> & {
     namespace?: unknown;
-    manifest: object | string;
+    manifest?: object | string;
 };
 /**
  * @deprecated
@@ -13,4 +13,4 @@ export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E>
  * please consider using Cloudflare Pages. You can start to create the Cloudflare Pages
  * application with the `npm create hono@latest` command.
  */
-export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/adapter/deno/serve-static.d.ts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from '../../middleware/serve-static';
 import type { Env, MiddlewareHandler } from '../../types';
-export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;
+export declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/node_modules/hono/dist/types/adapter/lambda-edge/handler.d.ts

@@ -81,7 +81,7 @@ interface CloudFrontResult {
     body?: string;
     bodyEncoding?: 'text' | 'base64';
 }
-export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult>);
+export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult | CloudFrontRequest>);
 export declare const createBody: (method: string, requestBody: CloudFrontRequest["body"]) => string | Uint8Array<ArrayBuffer> | undefined;
 export declare const isContentTypeBinary: (contentType: string) => boolean;
 export {};

package/dist/node_modules/hono/dist/types/client/types.d.ts

@@ -10,7 +10,7 @@ import type { HasRequiredKeys } from '../utils/types';
 type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
 /**
  * Type representing all standard HTTP methods prefixed with '$'
- * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch'
+ * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch' | '$query'
  */
 type StandardMethods = `$${(typeof METHODS)[number]}`;
 /**

package/dist/node_modules/hono/dist/types/context.d.ts

@@ -323,6 +323,10 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   c.header('X-Message', 'Hello!')
      *   c.header('Content-Type', 'text/plain')
      *
+     *   // Append multiple headers using the append option (e.g. Vary)
+     *   c.header('Vary', 'Accept-Encoding', { append: true })
+     *   c.header('Vary', 'User-Agent', { append: true })
+     *
      *   return c.body('Thank you for coming')
      * })
      * ```
@@ -343,7 +347,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * ```
      */
     set: Set<IsAny<E> extends true ? {
-        Variables: ContextVariableMap & Record<string, any>;
+        Variables: ContextVariableMap & Record<PropertyKey, any>;
     } : E>;
     /**
      * `.get()` can use the value specified by the key.
@@ -359,7 +363,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * ```
      */
     get: Get<IsAny<E> extends true ? {
-        Variables: ContextVariableMap & Record<string, any>;
+        Variables: ContextVariableMap & Record<PropertyKey, any>;
     } : E>;
     /**
      * `.var` can access the value of a variable.

package/dist/node_modules/hono/dist/types/helper/proxy/index.d.ts

@@ -27,7 +27,7 @@ interface ProxyFetch {
  * Fetch API wrapper for proxy.
  * The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
  *
- * The “Accept-Encoding” header is replaced with an encoding that the current runtime can handle.
+ * The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
  * Unnecessary response headers are deleted and a Response object is returned that can be returned
  * as is as a response from the handler.
  *

package/dist/node_modules/hono/dist/types/helper/route/index.d.ts

@@ -31,7 +31,7 @@ export declare const matchedRoutes: (c: Context) => RouterRoute[];
  * Get the route path registered within the handler
  *
  * @param {Context} c - The context object
- * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
  * @returns The route path registered within the handler
  *
  * @example
@@ -54,7 +54,7 @@ export declare const routePath: (c: Context, index?: number) => string;
  * Get the basePath of the as-is route specified by routing.
  *
  * @param {Context} c - The context object
- * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
  * @returns The basePath of the as-is route specified by routing.
  *
  * @example

package/dist/node_modules/hono/dist/types/helper/websocket/index.d.ts

@@ -31,7 +31,7 @@ export type WSReadyState = 0 | 1 | 2 | 3;
  * An argument for WSContext class
  */
 export interface WSContextInit<T = unknown> {
-    send(data: string | ArrayBuffer | Uint8Array, options: SendOptions): void;
+    send(data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options: SendOptions): void;
     close(code?: number, reason?: string): void;
     raw?: T;
     readyState: WSReadyState;

package/dist/node_modules/hono/dist/types/hono-base.d.ts

@@ -65,6 +65,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
     options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
     patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
+    query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
     all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
     on: OnHandlerInterface<E, S, BasePath>;
     use: MiddlewareHandlerInterface<E, S, BasePath>;
@@ -179,12 +180,12 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
      * @see {@link https://hono.dev/docs/api/hono#fetch}
      *
      * @param {Request} request - request Object of request
-     * @param {Env} Env - env Object
-     * @param {ExecutionContext} - context of execution
+     * @param {Env} env - env Object
+     * @param {ExecutionContext} executionCtx - context of execution
      * @returns {Response | Promise<Response>} response of request
      *
      */
-    fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
     /**
      * `.request()` is a useful method for testing.
      * You can pass a URL or pathname to send a GET request.

package/dist/node_modules/hono/dist/types/index.d.ts

@@ -21,7 +21,8 @@ export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundRespo
 /**
  * Types for context, context variable map, context renderer, and execution context.
  */
-export type { Context, ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
+export { Context } from './context';
+export type { ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
 /**
  * Type for HonoRequest.
  */

package/dist/node_modules/hono/dist/types/jsx/base.d.ts

@@ -3,14 +3,16 @@ import { DOM_MEMO } from './constants';
 import type { Context } from './context';
 import type { JSX as HonoJSX, IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
 export type Props = Record<string, any>;
+type FunctionComponentResult = HtmlEscapedString | Child[] | Promise<HtmlEscapedString | Child[]> | null;
 export type FC<P = Props> = {
-    (props: P): HtmlEscapedString | Promise<HtmlEscapedString> | null;
+    (props: P): FunctionComponentResult;
     defaultProps?: Partial<P> | undefined;
     displayName?: string | undefined;
 };
 export type DOMAttributes = HonoJSX.HTMLAttributes;
 export declare namespace JSX {
     type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
+    type ElementType = string | ((props: never) => FunctionComponentResult);
     interface ElementChildrenAttribute {
         children: Child;
     }
@@ -23,15 +25,16 @@ export declare namespace JSX {
 }
 export declare const getNameSpaceContext: () => Context<string> | undefined;
 export declare const booleanAttributes: string[];
-type LocalContexts = [Context<unknown>, unknown][];
 export type Child = string | Promise<string> | number | JSXNode | null | undefined | boolean | Child[];
+export declare const renderChildren: (children: Child[]) => HtmlEscapedString | Promise<HtmlEscapedString>;
+export declare const isUntrustedObject: (value: unknown) => boolean;
+export declare const renderUntrustedObject: (value: unknown) => HtmlEscapedString | Promise<HtmlEscapedString>;
 export declare class JSXNode implements HtmlEscaped {
     tag: string | Function;
     props: Props;
     key?: string;
     children: Child[];
     isEscaped: true;
-    localContexts?: LocalContexts;
     constructor(tag: string | Function, props: Props, children: Child[]);
     get type(): string | Function;
     get ref(): any;
@@ -41,8 +44,8 @@ export declare class JSXNode implements HtmlEscaped {
 export declare class JSXFragmentNode extends JSXNode {
     toStringToBuffer(buffer: StringBufferWithCallbacks): void;
 }
-export declare const jsx: (tag: string | Function, props: Props | null, ...children: (string | number | HtmlEscapedString)[]) => JSXNode;
-export declare const jsxFn: (tag: string | Function, props: Props, children: (string | number | HtmlEscapedString)[]) => JSXNode;
+export declare const jsx: (tag: string | Function, props: Props | null, ...children: Child[]) => JSXNode;
+export declare const jsxFn: (tag: string | Function, props: Props, children: Child[]) => JSXNode;
 export declare const shallowEqual: (a: Props, b: Props) => boolean;
 export type MemorableFC<T> = FC<T> & {
     [DOM_MEMO]: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean;

package/dist/node_modules/hono/dist/types/jsx/context.d.ts

@@ -8,5 +8,44 @@ export interface Context<T> extends FC<PropsWithChildren<{
     }>>;
 }
 export declare const globalContexts: Context<unknown>[];
+/** Per-render context store, isolated per request so values never leak across renders. */
+type RenderStore = WeakMap<Context<unknown>, unknown[]>;
+/**
+ * Establish the request-scoped context store for a render.
+ *
+ * `resumeStore` continues a suspended subtree in the same store on the fallback
+ * path (ignored when `AsyncLocalStorage` is available, where isolation is
+ * automatic).
+ *
+ * Without `AsyncLocalStorage` a render can't be followed across `await`, so the
+ * store lives in `fallbackStore` only during synchronous work (mirroring
+ * React's request storage). Reading context after `await` then finds no store
+ * and falls back to the default value — never another request's value.
+ */
+export declare const runWithRenderContext: <T>(callback: () => T, resumeStore?: RenderStore) => T;
+/**
+ * Capture the current render store and return a resumer that re-establishes it
+ * around a deferred continuation (e.g. a re-render after a suspended promise
+ * settles). Shared by every suspension point so none reimplements it.
+ */
+export declare const captureRenderContext: () => (<T>(callback: () => T) => T);
+/**
+ * Create a context whose value can be provided with `<Context.Provider>` and
+ * read with {@link useContext}.
+ *
+ * Server-side renders are isolated per request, so a provided value never leaks
+ * into a concurrent request — even across `await` in an async component, when
+ * `AsyncLocalStorage` is available (Node.js >= 20.16, Deno, Bun, Cloudflare
+ * Workers with `nodejs_compat`). Without it, reading context after `await`
+ * returns the default value; synchronous components and `use()`-based
+ * suspension are unaffected.
+ */
 export declare const createContext: <T>(defaultValue: T) => Context<T>;
+/**
+ * Read the current value of a context created with {@link createContext}.
+ *
+ * Safe to call from async components after `await`. See {@link createContext}
+ * for the per-runtime isolation guarantees.
+ */
 export declare const useContext: <T>(context: Context<T>) => T;
+export {};

package/dist/node_modules/hono/dist/types/jsx/dom/index.d.ts

@@ -24,7 +24,7 @@ declare const _default: {
         <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
     };
     useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    useRef: <T>(initialValue: T | null) => import("..").RefObject<T>;
+    useRef: typeof useRef;
     useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
     use: <T>(promise: Promise<T>) => T;
     startTransition: (callback: () => void) => void;
@@ -38,11 +38,11 @@ declare const _default: {
     useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
     useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-    createRef: <T>() => import("..").RefObject<T>;
-    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T>) => JSX.Element) => ((props: P & {
-        ref?: import("..").RefObject<T>;
+    createRef: <T>() => import("..").RefObject<T | null>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T | null>) => JSX.Element) => ((props: P & {
+        ref?: import("..").RefObject<T | null>;
     }) => JSX.Element);
-    useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useImperativeHandle: <T>(ref: import("..").RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
     useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
     useFormStatus: () => {
         pending: false;

package/dist/node_modules/hono/dist/types/jsx/dom/intrinsic-element/components.d.ts

@@ -1,7 +1,7 @@
 import type { IntrinsicElements } from '../../intrinsic-elements';
 import type { FC, PropsWithChildren, RefObject } from '../../types';
 export declare const clearCache: () => void;
-export declare const composeRef: <T>(ref: RefObject<T> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
+export declare const composeRef: <T>(ref: RefObject<T | null> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
 export declare const title: FC<PropsWithChildren>;
 export declare const script: FC<PropsWithChildren<IntrinsicElements['script']>>;
 export declare const style: FC<PropsWithChildren<IntrinsicElements['style']>>;
@@ -10,7 +10,7 @@ export declare const meta: FC<PropsWithChildren>;
 export declare const form: FC<PropsWithChildren<{
     action?: Function | string;
     method?: 'get' | 'post';
-    ref?: RefObject<HTMLFormElement> | ((e: HTMLFormElement | null) => void | (() => void));
+    ref?: RefObject<HTMLFormElement | null> | ((e: HTMLFormElement | null) => void | (() => void));
 }>>;
 export declare const input: FC<PropsWithChildren<IntrinsicElements['input']>>;
 export declare const button: FC<PropsWithChildren<IntrinsicElements['button']>>;

package/dist/node_modules/hono/dist/types/jsx/dom/server.d.ts

@@ -43,7 +43,7 @@ declare const _default: {
             <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
         };
         useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-        useRef: <T>(initialValue: T | null) => import("..").RefObject<T>;
+        useRef: typeof import("..").useRef;
         useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
         use: <T>(promise: Promise<T>) => T;
         startTransition: (callback: () => void) => void;
@@ -57,11 +57,11 @@ declare const _default: {
         useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
         useId: () => string;
         useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-        createRef: <T>() => import("..").RefObject<T>;
-        forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T>) => import("./jsx-dev-runtime").JSX.Element) => ((props: P & {
-            ref?: import("..").RefObject<T>;
+        createRef: <T>() => import("..").RefObject<T | null>;
+        forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T | null>) => import("./jsx-dev-runtime").JSX.Element) => ((props: P & {
+            ref?: import("..").RefObject<T | null>;
         }) => import("./jsx-dev-runtime").JSX.Element);
-        useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+        useImperativeHandle: <T>(ref: import("..").RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
         useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
         useFormStatus: () => {
             pending: false;

package/dist/node_modules/hono/dist/types/jsx/hooks/index.d.ts

@@ -29,17 +29,19 @@ export declare const useLayoutEffect: (effect: () => void | (() => void), deps?:
 export declare const useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
 export type RefObject<T> = {
-    current: T | null;
+    current: T;
 };
-export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
+export declare function useRef<T>(initialValue: T): RefObject<T>;
+export declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+export declare function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
 export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
 export declare const useId: () => string;
 export declare const useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
-export declare const createRef: <T>() => RefObject<T>;
-export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T>) => JSX.Element) => ((props: P & {
-    ref?: RefObject<T>;
+export declare const createRef: <T>() => RefObject<T | null>;
+export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T | null>) => JSX.Element) => ((props: P & {
+    ref?: RefObject<T | null>;
 }) => JSX.Element);
-export declare const useImperativeHandle: <T>(ref: RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+export declare const useImperativeHandle: <T>(ref: RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
 export declare const useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
 export {};