@nocobase/plugin-mcp-server 2.3.0-beta.12 → 2.3.0-beta.14

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

@@ -1,58 +1,63 @@
-import type { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from '../utils/html';
-import { DOM_MEMO } from './constants';
-import type { Context } from './context';
-import type { JSX as HonoJSX, IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
+import { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from "../utils/html.js";
+import { DOM_MEMO } from "./constants.js";
+import { JSX as JSX$1 } from "./intrinsic-elements.js";
+import { Context } from "./context.js";
+//#region src/jsx/base.d.ts
 export type Props = Record<string, any>;
+type FunctionComponentResult = HtmlEscapedString | JSXNode | Child[] | Promise<HtmlEscapedString | JSXNode | Child[]> | null;
 export type FC<P = Props> = {
-    (props: P): HtmlEscapedString | Promise<HtmlEscapedString> | null;
-    defaultProps?: Partial<P> | undefined;
-    displayName?: string | undefined;
+  (props: P): FunctionComponentResult;
+  defaultProps?: Partial<P> | undefined;
+  displayName?: string | undefined;
 };
-export type DOMAttributes = HonoJSX.HTMLAttributes;
+export type DOMAttributes = JSX$1.HTMLAttributes;
 export declare namespace JSX {
-    type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
-    interface ElementChildrenAttribute {
-        children: Child;
-    }
-    interface IntrinsicElements extends IntrinsicElementsDefined {
-        [tagName: string]: Props;
-    }
-    interface IntrinsicAttributes {
-        key?: string | number | bigint | null | undefined;
-    }
+  type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
+  type ElementType = string | ((props: never) => FunctionComponentResult);
+  interface ElementChildrenAttribute {
+    children: Child;
+  }
+  interface IntrinsicElements extends JSX$1.IntrinsicElements {
+    [tagName: string]: Props;
+  }
+  interface IntrinsicAttributes {
+    key?: string | number | bigint | null | undefined;
+  }
 }
 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;
-    toString(): string | Promise<string>;
-    toStringToBuffer(buffer: StringBufferWithCallbacks): void;
+  tag: string | Function;
+  props: Props;
+  key?: string;
+  children: Child[];
+  isEscaped: true;
+  constructor(tag: string | Function, props: Props, children: Child[]);
+  get type(): string | Function;
+  get ref(): any;
+  toString(): string | Promise<string>;
+  toStringToBuffer(buffer: StringBufferWithCallbacks): void;
 }
 export declare class JSXFragmentNode extends JSXNode {
-    toStringToBuffer(buffer: StringBufferWithCallbacks): void;
+  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;
+  [DOM_MEMO]: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean;
 };
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
-export declare const Fragment: ({ children, }: {
-    key?: string;
-    children?: Child | HtmlEscapedString;
+export declare const Fragment: ({ children }: {
+  key?: string;
+  children?: Child | HtmlEscapedString;
 }) => HtmlEscapedString;
 export declare const isValidElement: (element: unknown) => element is JSXNode;
 export declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Partial<Props>, ...children: Child[]) => T;
 export declare const reactAPICompatVersion = "19.0.0-hono-jsx";
+//#endregion
 export {};

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

@@ -1,9 +1,11 @@
-import type { Child } from './base';
+import { Child } from "./base.js";
+//#region src/jsx/children.d.ts
 export declare const toArray: (children: Child) => Child[];
 export declare const Children: {
-    map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
-    forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
-    count: (children: Child[]) => number;
-    only: (_children: Child[]) => Child;
-    toArray: (children: Child) => Child[];
+  map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+  forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+  count: (children: Child[]) => number;
+  only: (_children: Child[]) => Child;
+  toArray: (children: Child) => Child[];
 };
+//#endregion

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

@@ -1,5 +1,7 @@
-import type { HtmlEscapedString } from '../utils/html';
-import type { Child, FC, PropsWithChildren } from './';
+import { HtmlEscapedString } from "../utils/html.js";
+import { PropsWithChildren } from "./types.js";
+import { Child, FC } from "./base.js";
+//#region src/jsx/components.d.ts
 export declare const childrenToString: (children: Child[]) => Promise<HtmlEscapedString[]>;
 export type ErrorHandler = (error: Error) => void;
 export type FallbackRender = (error: Error) => Child;
@@ -9,7 +11,8 @@ export type FallbackRender = (error: Error) => Child;
  * The API might be changed.
  */
 export declare const ErrorBoundary: FC<PropsWithChildren<{
-    fallback?: Child;
-    fallbackRender?: FallbackRender;
-    onError?: ErrorHandler;
+  fallback?: Child;
+  fallbackRender?: FallbackRender;
+  onError?: ErrorHandler;
 }>>;
+//#endregion

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

@@ -1,6 +1,8 @@
+//#region src/jsx/constants.d.ts
 export declare const DOM_RENDERER: unique symbol;
 export declare const DOM_ERROR_HANDLER: unique symbol;
 export declare const DOM_STASH: unique symbol;
 export declare const DOM_INTERNAL_TAG: unique symbol;
 export declare const DOM_MEMO: unique symbol;
 export declare const PERMALINK: unique symbol;
+//#endregion

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

@@ -1,12 +1,54 @@
-import type { FC, PropsWithChildren } from './';
+import { PropsWithChildren } from "./types.js";
+import { FC } from "./base.js";
+//#region src/jsx/context.d.ts
 export interface Context<T> extends FC<PropsWithChildren<{
-    value: T;
+  value: T;
 }>> {
-    values: T[];
-    Provider: FC<PropsWithChildren<{
-        value: T;
-    }>>;
+  values: T[];
+  Provider: FC<PropsWithChildren<{
+    value: T;
+  }>>;
 }
 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;
+//#endregion
+export {};

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

@@ -1,11 +1,8 @@
-/**
- * @module
- * This module provides APIs for `hono/jsx/dom/client`, which is compatible with `react-dom/client`.
- */
-import type { Child } from '../base';
+import { Child } from "../base.js";
+//#region src/jsx/dom/client.d.ts
 export interface Root {
-    render(children: Child): void;
-    unmount(): void;
+  render(children: Child): void;
+  unmount(): void;
 }
 export type RootOptions = Record<string, unknown>;
 /**
@@ -25,7 +22,9 @@ export declare const createRoot: (element: HTMLElement | DocumentFragment, optio
  */
 export declare const hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
 declare const _default: {
-    createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
-    hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
+  createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
+  hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;
 };
-export default _default;
+//#endregion
+export { _default as default };
+export {};

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

@@ -1,10 +1,13 @@
-import type { Child, FC, PropsWithChildren } from '../';
-import type { ErrorHandler, FallbackRender } from '../components';
+import { ErrorHandler, FallbackRender } from "../components.js";
+import { PropsWithChildren } from "../types.js";
+import { Child, FC } from "../base.js";
+//#region src/jsx/dom/components.d.ts
 export declare const ErrorBoundary: FC<PropsWithChildren<{
-    fallback?: Child;
-    fallbackRender?: FallbackRender;
-    onError?: ErrorHandler;
+  fallback?: Child;
+  fallbackRender?: FallbackRender;
+  onError?: ErrorHandler;
 }>>;
 export declare const Suspense: FC<PropsWithChildren<{
-    fallback: any;
+  fallback: any;
 }>>;
+//#endregion

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

@@ -1,3 +1,5 @@
-import type { Context } from '../context';
+import { Context } from "../context.js";
+//#region src/jsx/dom/context.d.ts
 export declare const createContextProviderFunction: <T>(values: T[]) => Function;
 export declare const createContext: <T>(defaultValue: T) => Context<T>;
+//#endregion

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

@@ -1,41 +1,35 @@
-/**
- * @module
- * This module provides APIs that enable `hono/jsx/dom` to support.
- */
-import type { FC, PropsWithChildren } from '../';
-import type { ClassNameSlug, CssClassName, CssVariableType, OnInvalidSlug } from '../../helper/css/common';
-export { rawCssString } from '../../helper/css/common';
+import { ClassNameSlug, CssClassName, CssVariableType, OnInvalidSlug, rawCssString } from "../../helper/css/common.js";
+import { PropsWithChildren } from "../types.js";
+import { FC } from "../base.js";
+//#region src/jsx/dom/css.d.ts
 interface CreateCssJsxDomObjectsType {
-    (args: {
-        id: Readonly<string>;
-    }): readonly [
-        {
-            toString(this: CssClassName): string;
-        },
-        FC<PropsWithChildren<void>>
-    ];
+  (args: {
+    id: Readonly<string>;
+  }): readonly [{
+    toString(this: CssClassName): string;
+  }, FC<PropsWithChildren<void>>];
 }
 export declare const createCssJsxDomObjects: CreateCssJsxDomObjectsType;
 interface CssType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
 }
 interface CxType {
-    (...args: (string | boolean | null | undefined)[]): string;
+  (...args: (string | boolean | null | undefined)[]): string;
 }
 interface KeyframesType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
 }
 interface ViewTransitionType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
-    (content: string): string;
-    (): string;
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+  (content: string): string;
+  (): string;
 }
 interface DefaultContextType {
-    css: CssType;
-    cx: CxType;
-    keyframes: KeyframesType;
-    viewTransition: ViewTransitionType;
-    Style: FC<PropsWithChildren<void>>;
+  css: CssType;
+  cx: CxType;
+  keyframes: KeyframesType;
+  viewTransition: ViewTransitionType;
+  Style: FC<PropsWithChildren<void>>;
 }
 /**
  * @experimental
@@ -46,10 +40,10 @@ interface DefaultContextType {
  * @param options.classNameSlug - Optional function to customize generated CSS class names
  * @param options.onInvalidSlug - Optional callback function called when an invalid slug is returned from ClassNameSlug
  */
-export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug, }: {
-    id: Readonly<string>;
-    classNameSlug?: ClassNameSlug;
-    onInvalidSlug?: OnInvalidSlug;
+export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug }: {
+  id: Readonly<string>;
+  classNameSlug?: ClassNameSlug;
+  onInvalidSlug?: OnInvalidSlug;
 }) => DefaultContextType;
 /**
  * @experimental
@@ -81,3 +75,6 @@ export declare const viewTransition: ViewTransitionType;
  * The API might be changed.
  */
 export declare const Style: FC<PropsWithChildren<void>>;
+//#endregion
+export { rawCssString };
+export {};

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

@@ -1,17 +1,15 @@
-/**
- * Provide hooks used only in jsx/dom
- */
-import type { Context } from '../../context';
+import { Context } from "../../context.js";
+//#region src/jsx/dom/hooks/index.d.ts
 type FormStatus = {
-    pending: false;
-    data: null;
-    method: null;
-    action: null;
+  pending: false;
+  data: null;
+  method: null;
+  action: null;
 } | {
-    pending: true;
-    data: FormData;
-    method: 'get' | 'post';
-    action: string | ((formData: FormData) => void | Promise<void>);
+  pending: true;
+  data: FormData;
+  method: 'get' | 'post';
+  action: string | ((formData: FormData) => void | Promise<void>);
 };
 export declare const FormContext: Context<FormStatus>;
 export declare const registerAction: (action: Promise<unknown>) => void;
@@ -36,4 +34,5 @@ export declare const useOptimistic: <T, N>(state: T, updateState: (currentState:
  * @returns [T, (data: FormData) => void]
  */
 export declare const useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
+//#endregion
 export {};

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

@@ -1,88 +1,84 @@
-/**
- * @module
- * This module provides APIs for `hono/jsx/dom`.
- */
-import { isValidElement, reactAPICompatVersion } from '../base';
-import type { Child, DOMAttributes, JSX, JSXNode, Props, FC } from '../base';
-import { Children } from '../children';
-import { useContext } from '../context';
-import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from '../hooks';
-import { ErrorBoundary, Suspense } from './components';
-import { createContext } from './context';
-import { useActionState, useFormStatus, useOptimistic } from './hooks';
-import { Fragment } from './jsx-runtime';
-import { createPortal, flushSync } from './render';
-export { render } from './render';
+import { ErrorHandler, FallbackRender } from "../components.js";
+import { RefObject, createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from "../hooks/index.js";
+import { AnimationEvent, CSSProperties, ClipboardEvent, ComponentClass, DragEvent, Event, FocusEvent, InputEvent, KeyboardEvent, MouseEvent, PointerEvent, PropsWithChildren, ReactElement, ReactNode, TouchEvent, TransitionEvent, WheelEvent } from "../types.js";
+import { Children } from "../children.js";
+import { useActionState, useFormStatus, useOptimistic } from "./hooks/index.js";
+import { Context, useContext } from "../context.js";
+import { Child, DOMAttributes, FC, JSX, JSXNode, Props, isValidElement, reactAPICompatVersion } from "../base.js";
+import { ErrorBoundary, Suspense } from "./components.js";
+import { createContext } from "./context.js";
+import { Fragment } from "./jsx-dev-runtime.js";
+import { createPortal, flushSync, render } from "./render.js";
+//#region src/jsx/dom/index.d.ts
 declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
 declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
 declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
-export { reactAPICompatVersion as version, createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, useFormStatus, useActionState, useOptimistic, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, Children, Fragment, Fragment as StrictMode, DOMAttributes, flushSync, createPortal, };
 declare const _default: {
-    version: string;
-    useState: {
-        <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
-        <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>;
-    useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
-    use: <T>(promise: Promise<T>) => T;
-    startTransition: (callback: () => void) => void;
-    useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
-    useDeferredValue: <T>(value: T, initialValue?: T) => T;
-    startViewTransition: (callback: () => void) => void;
-    useViewTransition: () => [boolean, (callback: () => void) => void];
-    useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
-    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    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>;
-    }) => JSX.Element);
-    useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
-    useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
-    useFormStatus: () => {
-        pending: false;
-        data: null;
-        method: null;
-        action: null;
-    } | {
-        pending: true;
-        data: FormData;
-        method: "get" | "post";
-        action: string | ((formData: FormData) => void | Promise<void>);
-    };
-    useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
-    useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
-    Suspense: FC<import("..").PropsWithChildren<{
-        fallback: any;
-    }>>;
-    ErrorBoundary: FC<import("..").PropsWithChildren<{
-        fallback?: Child;
-        fallbackRender?: import("../components").FallbackRender;
-        onError?: import("../components").ErrorHandler;
-    }>>;
-    createContext: <T>(defaultValue: T) => import("..").Context<T>;
-    useContext: <T>(context: import("..").Context<T>) => T;
-    memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
-    isValidElement: (element: unknown) => element is JSXNode;
-    createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
-    cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
-    Children: {
-        map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
-        forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
-        count: (children: Child[]) => number;
-        only: (_children: Child[]) => Child;
-        toArray: (children: Child) => Child[];
-    };
-    Fragment: (props: Record<string, unknown>) => JSXNode;
-    StrictMode: (props: Record<string, unknown>) => JSXNode;
-    flushSync: (callback: () => void) => void;
-    createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
+  version: string;
+  useState: {
+    <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
+    <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
+  };
+  useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+  useRef: typeof useRef;
+  useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
+  use: <T>(promise: Promise<T>) => T;
+  startTransition: (callback: () => void) => void;
+  useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+  useDeferredValue: <T>(value: T, initialValue?: T) => T;
+  startViewTransition: (callback: () => void) => void;
+  useViewTransition: () => [boolean, (callback: () => void) => void];
+  useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
+  useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+  useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+  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>() => RefObject<T | null>;
+  forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T | null>) => JSX.Element) => ((props: P & {
+    ref?: RefObject<T | null>;
+  }) => JSX.Element);
+  useImperativeHandle: <T>(ref: RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
+  useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+  useFormStatus: () => {
+    pending: false;
+    data: null;
+    method: null;
+    action: null;
+  } | {
+    pending: true;
+    data: FormData;
+    method: "get" | "post";
+    action: string | ((formData: FormData) => void | Promise<void>);
+  };
+  useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
+  useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
+  Suspense: FC<PropsWithChildren<{
+    fallback: any;
+  }>>;
+  ErrorBoundary: FC<PropsWithChildren<{
+    fallback?: Child;
+    fallbackRender?: FallbackRender;
+    onError?: ErrorHandler;
+  }>>;
+  createContext: <T>(defaultValue: T) => Context<T>;
+  useContext: <T>(context: Context<T>) => T;
+  memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
+  isValidElement: (element: unknown) => element is JSXNode;
+  createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
+  cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
+  Children: {
+    map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+    forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+    count: (children: Child[]) => number;
+    only: (_children: Child[]) => Child;
+    toArray: (children: Child) => Child[];
+  };
+  Fragment: (props: Record<string, unknown>) => JSXNode;
+  StrictMode: (props: Record<string, unknown>) => JSXNode;
+  flushSync: (callback: () => void) => void;
+  createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
 };
-export default _default;
-export type { Context } from '../context';
-export type * from '../types';
+//#endregion
+export { type AnimationEvent, type CSSProperties, type Child, Children, type ClipboardEvent, type ComponentClass, type Context, type DOMAttributes, type DragEvent, ErrorBoundary, type Event, type FC, type FocusEvent, Fragment, Fragment as StrictMode, type InputEvent, type JSXNode, type KeyboardEvent, type MouseEvent, type PointerEvent, type PropsWithChildren, type ReactElement, type ReactNode, type RefObject, Suspense, type TouchEvent, type TransitionEvent, type WheelEvent, cloneElement, createContext, createElement, createElement as jsx, createPortal, createRef, _default as default, flushSync, forwardRef, isValidElement, memo, render, startTransition, startViewTransition, use, useActionState, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useFormStatus, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition, reactAPICompatVersion as version };
+export {};

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

@@ -1,16 +1,20 @@
-import type { IntrinsicElements } from '../../intrinsic-elements';
-import type { FC, PropsWithChildren, RefObject } from '../../types';
+import { IntrinsicElements } from "../../intrinsic-elements.js";
+import { RefObject } from "../../hooks/index.js";
+import { PropsWithChildren } from "../../types.js";
+import { FC } from "../../base.js";
+//#region src/jsx/dom/intrinsic-element/components.d.ts
 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']>>;
 export declare const link: FC<PropsWithChildren<IntrinsicElements['link']>>;
 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));
+  action?: Function | string;
+  method?: 'get' | 'post';
+  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']>>;
+//#endregion

package/dist/node_modules/hono/dist/types/jsx/dom/jsx-dev-runtime.d.ts

@@ -1,8 +1,6 @@
-/**
- * @module
- * This module provides the `hono/jsx/dom` dev runtime.
- */
-import type { JSXNode, Props } from '../base';
-export type { JSX } from '../base';
+import { JSX, JSXNode, Props } from "../base.js";
+//#region src/jsx/dom/jsx-dev-runtime.d.ts
 export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;
 export declare const Fragment: (props: Record<string, unknown>) => JSXNode;
+//#endregion
+export type { JSX };

package/dist/node_modules/hono/dist/types/jsx/dom/jsx-runtime.d.ts

@@ -1,7 +1,3 @@
-/**
- * @module
- * This module provides the `hono/jsx/dom` runtime.
- */
-export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime';
-export { jsxDEV as jsxs } from './jsx-dev-runtime';
-export type { JSX } from './jsx-dev-runtime';
+import { JSX } from "../base.js";
+import { Fragment, jsxDEV } from "./jsx-dev-runtime.js";
+export { Fragment, type JSX, jsxDEV as jsx, jsxDEV as jsxs };