waku 0.21.2 → 0.21.4

package/README.md

@@ -574,7 +574,7 @@ export default async function HomePage() {
   return (
     <>
       <title>Waku</title>
-      <meta property="description" content="The minimal React framework" />
+      <meta name="description" content="The minimal React framework" />
       <h1>Waku</h1>
       <div>Hello world!</div>
     </>
@@ -607,7 +607,7 @@ const Head = async () => {
   return (
     <>
       <title>{metadata.title}</title>
-      <meta property="description" content={metadata.description} />
+      <meta name="description" content={metadata.description} />
     </>
   );
 };
@@ -1021,7 +1021,7 @@ npx partykit dev # or deploy
 
 ```
 npm run build -- --with-deno
-DENO_DEPLOY_TOKEN=... deployctl deploy --project=... --prod dist/serve.js --exclude node_modules
+deployctl deploy --prod dist/serve-deno.js --exclude node_modules
 ```
 
 ### AWS Lambda (experimental)
@@ -1030,7 +1030,8 @@ DENO_DEPLOY_TOKEN=... deployctl deploy --project=... --prod dist/serve.js --excl
 npm run build -- --with-aws-lambda
 ```
 
-The handler entrypoint is `dist/serve.js`: see [Hono AWS Lambda Deploy Docs](https://hono.dev/getting-started/aws-lambda#_3-deploy).
+The handler entrypoint is `dist/serve-asw-lambda.js`: see [Hono AWS Lambda Deploy Docs](https://hono.dev/getting-started/aws-lambda#_3-deploy).
+Streaming can be activated by setting environment variable `DEPLOY_AWS_LAMBDA_STREAMING=true npm run build -- --with-aws-lambda`
 
 ## Community
 

package/dist/cli.js

@@ -4,10 +4,11 @@ import { pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
 import { createRequire } from 'node:module';
 import { Hono } from 'hono';
+import { compress } from 'hono/compress';
 import { serve } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import * as dotenv from 'dotenv';
-import { runner } from './lib/hono/runner.js';
+import { serverEngine } from './lib/hono/engine.js';
 import { build } from './lib/builder/build.js';
 import { DIST_ENTRIES_JS, DIST_PUBLIC } from './lib/builder/constants.js';
 const require = createRequire(new URL('.', import.meta.url));
@@ -49,6 +50,9 @@ const { values, positionals } = parseArgs({
         'experimental-partial': {
             type: 'boolean'
         },
+        'experimental-compress': {
+            type: 'boolean'
+        },
         port: {
             type: 'string',
             short: 'p'
@@ -90,22 +94,28 @@ if (values.version) {
 }
 async function runDev() {
     const config = await loadConfig();
-    const app = new Hono();
-    app.use('*', runner({
-        cmd: 'dev',
-        config,
-        env: process.env
-    }));
-    app.notFound((c)=>{
-        // FIXME can we avoid hardcoding the public path?
-        const file = path.join('public', '404.html');
-        if (existsSync(file)) {
-            return c.html(readFileSync(file, 'utf8'), 404);
+    const honoEnhancer = config.unstable_honoEnhancer || ((createApp)=>createApp);
+    const createApp = (app)=>{
+        if (values['experimental-compress']) {
+            app.use(compress());
         }
-        return c.text('404 Not Found', 404);
-    });
+        app.use(serverEngine({
+            cmd: 'dev',
+            config,
+            env: process.env
+        }));
+        app.notFound((c)=>{
+            // FIXME can we avoid hardcoding the public path?
+            const file = path.join('public', '404.html');
+            if (existsSync(file)) {
+                return c.html(readFileSync(file, 'utf8'), 404);
+            }
+            return c.text('404 Not Found', 404);
+        });
+        return app;
+    };
     const port = parseInt(values.port || '3000', 10);
-    await startServer(app, port);
+    await startServer(honoEnhancer(createApp)(new Hono()), port);
 }
 async function runBuild() {
     const config = await loadConfig();
@@ -118,27 +128,34 @@ async function runBuild() {
     });
 }
 async function runStart() {
-    const { distDir = 'dist' } = await loadConfig();
+    const config = await loadConfig();
+    const { distDir = 'dist' } = config;
+    const honoEnhancer = config.unstable_honoEnhancer || ((createApp)=>createApp);
     const loadEntries = ()=>import(pathToFileURL(path.resolve(distDir, DIST_ENTRIES_JS)).toString());
-    const app = new Hono();
-    app.use('*', serveStatic({
-        root: path.join(distDir, DIST_PUBLIC)
-    }));
-    app.use('*', runner({
-        cmd: 'start',
-        loadEntries,
-        env: process.env
-    }));
-    app.notFound((c)=>{
-        // FIXME better implementation using node stream?
-        const file = path.join(distDir, DIST_PUBLIC, '404.html');
-        if (existsSync(file)) {
-            return c.html(readFileSync(file, 'utf8'), 404);
+    const createApp = (app)=>{
+        if (values['experimental-compress']) {
+            app.use(compress());
         }
-        return c.text('404 Not Found', 404);
-    });
+        app.use(serveStatic({
+            root: path.join(distDir, DIST_PUBLIC)
+        }));
+        app.use(serverEngine({
+            cmd: 'start',
+            loadEntries,
+            env: process.env
+        }));
+        app.notFound((c)=>{
+            // FIXME better implementation using node stream?
+            const file = path.join(distDir, DIST_PUBLIC, '404.html');
+            if (existsSync(file)) {
+                return c.html(readFileSync(file, 'utf8'), 404);
+            }
+            return c.text('404 Not Found', 404);
+        });
+        return app;
+    };
     const port = parseInt(values.port || '8080', 10);
-    await startServer(app, port);
+    await startServer(honoEnhancer(createApp)(new Hono()), port);
 }
 function startServer(app, port) {
     return new Promise((resolve, reject)=>{

package/dist/client.d.ts

@@ -1,66 +1,150 @@
-import { Component } from 'react';
-import type { ReactNode } from 'react';
-declare global {
-    interface ImportMeta {
-        readonly env: Record<string, string>;
-    }
-}
-type Elements = Promise<Record<string, ReactNode>> & {
-    prev?: Record<string, ReactNode> | undefined;
-};
-type SetElements = (updater: (prev: Elements) => Elements) => void;
-type OnFetchData = (data: unknown) => void;
-declare const ENTRY = "e";
-declare const SET_ELEMENTS = "s";
-declare const ON_FETCH_DATA = "o";
-type FetchCache = {
-    [ENTRY]?: [input: string, params: unknown, elements: Elements];
-    [SET_ELEMENTS]?: SetElements;
-    [ON_FETCH_DATA]?: OnFetchData | undefined;
-};
-/**
- * callServer callback
- * This is not a public API.
- */
-export declare const callServerRSC: (actionId: string, args?: unknown[], fetchCache?: FetchCache) => Promise<bigint | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | import("react").AwaitedReactNode>;
-export declare const fetchRSC: (input: string, params?: unknown, fetchCache?: FetchCache) => Elements;
-export declare const prefetchRSC: (input: string, params?: unknown) => void;
-export declare const Root: ({ initialInput, initialParams, fetchCache, unstable_onFetchData, children, }: {
-    initialInput?: string;
-    initialParams?: unknown;
-    fetchCache?: FetchCache;
-    unstable_onFetchData?: (data: unknown) => void;
-    children: ReactNode;
-}) => import("react").FunctionComponentElement<import("react").ProviderProps<(input: string, params?: unknown) => void>>;
-export declare const useRefetch: () => (input: string, params?: unknown) => void;
-type OuterSlotProps = {
-    elementsPromise: Elements;
-    shouldRenderPrev: ((err: unknown) => boolean) | undefined;
-    renderSlot: (elements: Record<string, ReactNode>) => ReactNode;
-    children?: ReactNode;
-};
-declare class OuterSlot extends Component<OuterSlotProps, {
-    error?: unknown;
-}> {
-    constructor(props: OuterSlotProps);
-    static getDerivedStateFromError(error: unknown): {
-        error: unknown;
-    };
-    render(): ReactNode;
-}
+/** @deprecated */
+export declare const Children: () => import("react").ReactNode;
+/** @deprecated */
 export declare const Slot: ({ id, children, fallback, unstable_shouldRenderPrev, }: {
     id: string;
-    children?: ReactNode;
-    fallback?: ReactNode;
+    children?: import("react").ReactNode;
+    fallback?: import("react").ReactNode;
     unstable_shouldRenderPrev?: (err: unknown) => boolean;
-}) => import("react").CElement<OuterSlotProps, OuterSlot>;
-export declare const Children: () => ReactNode;
-/**
- * ServerRoot for SSR
- * This is not a public API.
- */
+}) => import("react").CElement<{
+    elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+        prev?: Record<string, import("react").ReactNode> | undefined;
+    };
+    shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+    renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+    children?: import("react").ReactNode;
+}, {
+    render(): import("react").ReactNode;
+    context: unknown;
+    setState<K extends "error">(state: {
+        error?: unknown;
+    } | ((prevState: Readonly<{
+        error?: unknown;
+    }>, props: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>) => {
+        error?: unknown;
+    } | Pick<{
+        error?: unknown;
+    }, K> | null) | Pick<{
+        error?: unknown;
+    }, K> | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>;
+    state: Readonly<{
+        error?: unknown;
+    }>;
+    refs: {
+        [key: string]: import("react").ReactInstance;
+    };
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextState: Readonly<{
+        error?: unknown;
+    }>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, prevState: Readonly<{
+        error?: unknown;
+    }>): any;
+    componentDidUpdate?(prevProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, prevState: Readonly<{
+        error?: unknown;
+    }>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextState: Readonly<{
+        error?: unknown;
+    }>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+        elementsPromise: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        };
+        shouldRenderPrev: ((err: unknown) => boolean) | undefined;
+        renderSlot: (elements: Record<string, import("react").ReactNode>) => import("react").ReactNode;
+        children?: import("react").ReactNode;
+    }>, nextState: Readonly<{
+        error?: unknown;
+    }>, nextContext: any): void;
+}>;
+/** @deprecated */
+export declare const Root: ({ initialRscPath, initialRscParams, fetchCache, unstable_enhanceCreateData, children, }: {
+    initialRscPath?: string;
+    initialRscParams?: unknown;
+    fetchCache?: {
+        e?: [rscPath: string, rscParams: unknown, elements: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        }];
+        s?: (updater: (prev: Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        }) => Promise<Record<string, import("react").ReactNode>> & {
+            prev?: Record<string, import("react").ReactNode> | undefined;
+        }) => void;
+        d?: ((createData: (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>) => (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>) | undefined;
+    };
+    unstable_enhanceCreateData?: (createData: (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>) => (responsePromise: Promise<Response>) => Promise<Record<string, import("react").ReactNode>>;
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<(rscPath: string, rscParams?: unknown) => void>>;
+/** @deprecated */
 export declare const ServerRoot: ({ elements, children, }: {
-    elements: Elements;
-    children: ReactNode;
-}) => import("react").FunctionComponentElement<import("react").ProviderProps<Elements | null>>;
-export {};
+    elements: Promise<Record<string, import("react").ReactNode>> & {
+        prev?: Record<string, import("react").ReactNode> | undefined;
+    };
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<(Promise<Record<string, import("react").ReactNode>> & {
+    prev?: Record<string, import("react").ReactNode> | undefined;
+}) | null>>;

package/dist/client.js

@@ -1,203 +1,5 @@
-/// <reference types="react/canary" />
-'use client';
-import { Component, createContext, createElement, memo, use, useCallback, useEffect, useState } from 'react';
-import RSDWClient from 'react-server-dom-webpack/client';
-import { encodeInput, encodeActionId } from './lib/renderers/utils.js';
-const { createFromFetch, encodeReply } = RSDWClient;
-const BASE_PATH = `${import.meta.env?.WAKU_CONFIG_BASE_PATH}${import.meta.env?.WAKU_CONFIG_RSC_PATH}/`;
-const checkStatus = async (responsePromise)=>{
-    const response = await responsePromise;
-    if (!response.ok) {
-        const err = new Error(response.statusText);
-        err.statusCode = response.status;
-        throw err;
-    }
-    return response;
-};
-const getCached = (c, m, k)=>(m.has(k) ? m : m.set(k, c())).get(k);
-const cache1 = new WeakMap();
-const mergeElements = (a, b)=>{
-    const getResult = ()=>{
-        const promise = new Promise((resolve, reject)=>{
-            Promise.all([
-                a,
-                b
-            ]).then(([a, b])=>{
-                const nextElements = {
-                    ...a,
-                    ...b
-                };
-                delete nextElements._value;
-                promise.prev = a;
-                resolve(nextElements);
-            }).catch((e)=>{
-                a.then((a)=>{
-                    promise.prev = a;
-                    reject(e);
-                }, ()=>{
-                    promise.prev = a.prev;
-                    reject(e);
-                });
-            });
-        });
-        return promise;
-    };
-    const cache2 = getCached(()=>new WeakMap(), cache1, a);
-    return getCached(getResult, cache2, b);
-};
-const ENTRY = 'e';
-const SET_ELEMENTS = 's';
-const ON_FETCH_DATA = 'o';
-const defaultFetchCache = {};
-/**
- * callServer callback
- * This is not a public API.
- */ export const callServerRSC = async (actionId, args, fetchCache = defaultFetchCache)=>{
-    const url = BASE_PATH + encodeInput(encodeActionId(actionId));
-    const response = args === undefined ? fetch(url) : encodeReply(args).then((body)=>fetch(url, {
-            method: 'POST',
-            body
-        }));
-    const data = createFromFetch(checkStatus(response), {
-        callServer: (actionId, args)=>callServerRSC(actionId, args, fetchCache)
-    });
-    fetchCache[ON_FETCH_DATA]?.(data);
-    // FIXME this causes rerenders even if data is empty
-    fetchCache[SET_ELEMENTS]?.((prev)=>mergeElements(prev, data));
-    return (await data)._value;
-};
-const prefetchedParams = new WeakMap();
-const fetchRSCInternal = (url, params)=>params === undefined ? fetch(url) : typeof params === 'string' ? fetch(url, {
-        headers: {
-            'X-Waku-Params': params
-        }
-    }) : encodeReply(params).then((body)=>fetch(url, {
-            method: 'POST',
-            body
-        }));
-export const fetchRSC = (input, params, fetchCache = defaultFetchCache)=>{
-    const entry = fetchCache[ENTRY];
-    if (entry && entry[0] === input && entry[1] === params) {
-        return entry[2];
-    }
-    const prefetched = globalThis.__WAKU_PREFETCHED__ ||= {};
-    const url = BASE_PATH + encodeInput(input);
-    const hasValidPrefetchedResponse = !!prefetched[url] && // HACK .has() is for the initial hydration
-    // It's limited and may result in a wrong result. FIXME
-    (!prefetchedParams.has(prefetched[url]) || prefetchedParams.get(prefetched[url]) === params);
-    const response = hasValidPrefetchedResponse ? prefetched[url] : fetchRSCInternal(url, params);
-    delete prefetched[url];
-    const data = createFromFetch(checkStatus(response), {
-        callServer: (actionId, args)=>callServerRSC(actionId, args, fetchCache)
-    });
-    fetchCache[ON_FETCH_DATA]?.(data);
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    fetchCache[ENTRY] = [
-        input,
-        params,
-        data
-    ];
-    return data;
-};
-export const prefetchRSC = (input, params)=>{
-    const prefetched = globalThis.__WAKU_PREFETCHED__ ||= {};
-    const url = BASE_PATH + encodeInput(input);
-    if (!(url in prefetched)) {
-        prefetched[url] = fetchRSCInternal(url, params);
-        prefetchedParams.set(prefetched[url], params);
-    }
-};
-const RefetchContext = createContext(()=>{
-    throw new Error('Missing Root component');
-});
-const ElementsContext = createContext(null);
-export const Root = ({ initialInput, initialParams, fetchCache = defaultFetchCache, unstable_onFetchData, children })=>{
-    fetchCache[ON_FETCH_DATA] = unstable_onFetchData;
-    const [elements, setElements] = useState(()=>fetchRSC(initialInput || '', initialParams, fetchCache));
-    useEffect(()=>{
-        fetchCache[SET_ELEMENTS] = setElements;
-    }, [
-        fetchCache,
-        setElements
-    ]);
-    const refetch = useCallback((input, params)=>{
-        // clear cache entry before fetching
-        delete fetchCache[ENTRY];
-        const data = fetchRSC(input, params, fetchCache);
-        setElements((prev)=>mergeElements(prev, data));
-    }, [
-        fetchCache
-    ]);
-    return createElement(RefetchContext.Provider, {
-        value: refetch
-    }, createElement(ElementsContext.Provider, {
-        value: elements
-    }, children));
-};
-export const useRefetch = ()=>use(RefetchContext);
-const ChildrenContext = createContext(undefined);
-const ChildrenContextProvider = memo(ChildrenContext.Provider);
-class OuterSlot extends Component {
-    constructor(props){
-        super(props);
-        this.state = {};
-    }
-    static getDerivedStateFromError(error) {
-        return {
-            error
-        };
-    }
-    render() {
-        if ('error' in this.state) {
-            const e = this.state.error;
-            if (e instanceof Error && !('statusCode' in e)) {
-                // HACK we assume any error as Not Found,
-                // probably caused by history api fallback
-                e.statusCode = 404;
-            }
-            if (this.props.shouldRenderPrev?.(e) && this.props.elementsPromise.prev) {
-                const elements = this.props.elementsPromise.prev;
-                return this.props.renderSlot(elements);
-            } else {
-                throw e;
-            }
-        }
-        return this.props.children;
-    }
-}
-const InnerSlot = ({ elementsPromise, renderSlot })=>{
-    const elements = use(elementsPromise);
-    return renderSlot(elements);
-};
-export const Slot = ({ id, children, fallback, unstable_shouldRenderPrev })=>{
-    const elementsPromise = use(ElementsContext);
-    if (!elementsPromise) {
-        throw new Error('Missing Root component');
-    }
-    const renderSlot = (elements)=>{
-        if (!(id in elements)) {
-            if (fallback) {
-                return fallback;
-            }
-            throw new Error('Not found: ' + id);
-        }
-        return createElement(ChildrenContextProvider, {
-            value: children
-        }, elements[id]);
-    };
-    return createElement(OuterSlot, {
-        elementsPromise,
-        shouldRenderPrev: unstable_shouldRenderPrev,
-        renderSlot
-    }, createElement(InnerSlot, {
-        elementsPromise,
-        renderSlot
-    }));
-};
-export const Children = ()=>use(ChildrenContext);
-/**
- * ServerRoot for SSR
- * This is not a public API.
- */ export const ServerRoot = ({ elements, children })=>createElement(ElementsContext.Provider, {
-        value: elements
-    }, children);
+import { Children as ChildrenOrig, Slot as SlotOrig, Root as RootOrig, ServerRootInternal as ServerRootOrig } from './minimal/client.js';
+/** @deprecated */ export const Children = ChildrenOrig;
+/** @deprecated */ export const Slot = SlotOrig;
+/** @deprecated */ export const Root = RootOrig;
+/** @deprecated */ export const ServerRoot = ServerRootOrig;

package/dist/config.d.ts

@@ -31,16 +31,16 @@ export interface Config {
      */
     privateDir?: string;
     /**
-     * Prefix for HTTP requests to indicate RSC requests.
+     * Bse path for HTTP requests to indicate RSC requests.
      * Defaults to "RSC".
      */
-    rscPath?: string;
+    rscBase?: string;
     /**
      * Middleware to use
      * Defaults to:
      * () => [
+     *   import('waku/middleware/context'),
      *   import('waku/middleware/dev-server'),
-     *   import('waku/middleware/headers'),
      *   import('waku/middleware/rsc'),
      *   import('waku/middleware/ssr'),
      * ]
@@ -48,5 +48,10 @@ export interface Config {
     middleware?: () => Promise<{
         default: Middleware;
     }>[];
+    /**
+     * Enhancer for Hono
+     * Defaults to `undefined`
+     */
+    unstable_honoEnhancer?: (<Hono>(createApp: (app: Hono) => Hono) => (app: Hono) => Hono) | undefined;
 }
 export declare function defineConfig(config: Config): Config;