weifuwu 0.18.2 → 0.18.4

package/dist/dist/ssr/ssr.d.ts

@@ -0,0 +1,2 @@
+import { Router } from '../router.ts';
+export declare function ssr(path: string): Router;

package/dist/dist/tenant/client.d.ts

@@ -0,0 +1,2 @@
+import type { TenantOptions, TenantModule } from './types.ts';
+export declare function tenant(options: TenantOptions): TenantModule;

package/dist/dist/tenant/graphql.d.ts

@@ -0,0 +1,3 @@
+import type { Sql } from '../vendor.ts';
+import { Router } from '../router.ts';
+export declare function buildGraphQLHandler(sql: Sql<{}>): Router;

package/dist/dist/tenant/index.d.ts

@@ -0,0 +1,2 @@
+export { tenant } from './client.ts';
+export type { TenantOptions, TenantModule, TenantContext, FieldDef, FieldType, RelationDef, UserTableRow } from './types.ts';

package/dist/dist/tenant/migrate.d.ts

@@ -0,0 +1,6 @@
+import type { Sql } from '../vendor.ts';
+export interface MigrateOptions {
+    sql: Sql<{}>;
+    usersTable: string;
+}
+export declare function migrate(opts: MigrateOptions): Promise<void>;

package/dist/dist/tenant/rest.d.ts

@@ -0,0 +1,3 @@
+import type { Sql } from '../vendor.ts';
+import { Router } from '../router.ts';
+export declare function buildRouter(sql: Sql<{}>, usersTable: string): Router;

package/dist/dist/tenant/schema.d.ts

@@ -0,0 +1,5 @@
+import type { FieldDef } from './types.ts';
+export declare function createTableSQL(tenantId: string, slug: string, fields: FieldDef[]): string;
+export declare function addColumnSQL(tenantId: string, slug: string, field: FieldDef): string;
+export declare function dropTableSQL(tenantId: string, slug: string): string;
+export declare function createIndexesSQL(tenantId: string, slug: string, fields: FieldDef[]): string[];

package/dist/dist/tenant/types.d.ts

@@ -0,0 +1,48 @@
+import type { Context } from '../types.ts';
+import type { Router } from '../router.ts';
+import type { PostgresClient } from '../postgres/types.ts';
+declare module '../types.ts' {
+    interface Context {
+        tenant: TenantContext;
+    }
+}
+export interface TenantContext {
+    id: string;
+    name: string;
+    role: string;
+}
+export type FieldType = 'string' | 'integer' | 'float' | 'boolean' | 'text' | 'datetime' | 'date' | 'enum' | 'json' | 'vector';
+export interface RelationDef {
+    table: string;
+    field?: string;
+    onDelete?: 'cascade' | 'restrict' | 'setnull';
+}
+export interface FieldDef {
+    name: string;
+    type: FieldType;
+    required?: boolean;
+    unique?: boolean;
+    index?: boolean | 'desc' | 'gin' | 'hnsw';
+    default?: unknown;
+    options?: string[];
+    dimensions?: number;
+    relation?: RelationDef;
+}
+export interface UserTableRow {
+    id: number;
+    tenant_id: string;
+    slug: string;
+    label: string;
+    fields: FieldDef[];
+    created_at: string;
+}
+export interface TenantOptions {
+    pg: PostgresClient;
+    usersTable: string;
+}
+export interface TenantModule extends Router {
+    migrate: () => Promise<void>;
+    middleware: () => (req: Request, ctx: Context, next: any) => Promise<Response>;
+    graphql: () => any;
+    close: () => Promise<void>;
+}

package/dist/dist/tenant/utils.d.ts

@@ -0,0 +1,10 @@
+import type { FieldDef } from './types.ts';
+export declare function internalTableName(tenantId: string, slug: string): string;
+export declare function pascalCase(slug: string): string;
+export declare function sqlTypeForField(field: FieldDef): string;
+export declare function validateSlug(slug: string): string | null;
+export declare function validateFieldDefs(fields: FieldDef[]): string[];
+export declare function formatDefault(field: FieldDef): string;
+export declare function mapFieldToZod(field: FieldDef): string;
+export declare function getRelationFields(fields: FieldDef[]): FieldDef[];
+export declare function findRelation(fields: FieldDef[], targetSlug: string): FieldDef | undefined;

package/dist/dist/types.d.ts

@@ -0,0 +1,19 @@
+export interface Context {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    user?: unknown;
+    parsed?: Record<string, unknown>;
+    mountPath?: string;
+    t?: (key: string, params?: Record<string, string>, fallback?: string) => string;
+    setPref?: (name: string, value: string) => Response;
+    prefs?: Record<string, string>;
+    env?: Record<string, string>;
+    layoutStack?: {
+        path: string;
+        component: any;
+    }[];
+    [key: string]: unknown;
+}
+export type Handler = (req: Request, ctx: Context) => Response | Promise<Response>;
+export type Middleware = (req: Request, ctx: Context, next: Handler) => Response | Promise<Response>;
+export type ErrorHandler = (error: Error, req: Request, ctx: Context) => Response | Promise<Response>;

package/dist/dist/use-flash-message.d.ts

@@ -0,0 +1 @@
+export declare function useFlashMessage<T = any>(): T | null;

package/dist/error-boundary.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from './types.ts';
+export declare function errorBoundary(errorPath: string): Middleware;

package/dist/index.d.ts

@@ -67,3 +67,10 @@ export { logdb } from './logdb/index.ts';
 export type { LogdbOptions, LogdbModule, LogEntry, LogEntryInput, } from './logdb/types.ts';
 export { iii, createWorker, registerWorker } from './iii/index.ts';
 export type { IIIModule, IIIOptions, WorkerInfo, FunctionInfo, TriggerInfo, FunctionHandler, FunctionContext, TriggerInput, RemoteWorker, TriggerRequest, } from './iii/types.ts';
+export { ssr } from './ssr.ts';
+export { layout } from './layout.ts';
+export { liveReload } from './live.ts';
+export { tailwind } from './tailwind.ts';
+export { notFound } from './not-found.ts';
+export { errorBoundary } from './error-boundary.ts';
+export { clearCompileCache } from './compile.ts';

package/dist/index.js

@@ -306,6 +306,11 @@ var Router = class _Router {
     return this;
   }
   route(method, path2, ...args) {
+    const last = args[args.length - 1];
+    if (last instanceof _Router) {
+      this._mountRouter(path2, last);
+      return this;
+    }
     const handler = args.pop();
     const middlewares = args;
     const segments = this.splitPath(path2);
@@ -371,13 +376,13 @@ var Router = class _Router {
             const mw = match.middlewares[index++];
             return mw(innerReq, ctx2, dispatch);
           }
-          return await new Promise((resolve12) => {
+          return await new Promise((resolve13) => {
             try {
               upgradeSocket(router.wss, req, socket, head, match.handler, ctx2);
-              resolve12(new Response(null, { status: 101 }));
+              resolve13(new Response(null, { status: 101 }));
             } catch {
               socket.destroy();
-              resolve12(new Response("WebSocket upgrade failed", { status: 500 }));
+              resolve13(new Response("WebSocket upgrade failed", { status: 500 }));
             }
           });
         };
@@ -2631,7 +2636,7 @@ function user(options) {
   async function migrate() {
     await users.create();
     if (!oauth2Enabled) return;
-    const clients2 = pgTable("_oauth2_clients", {
+    const clients3 = pgTable("_oauth2_clients", {
       id: serial("id").primaryKey(),
       name: text("name").notNull(),
       client_id: text("client_id").unique().notNull(),
@@ -2640,7 +2645,7 @@ function user(options) {
       scopes: text("scopes").default(""),
       created_at: timestamptz("created_at").default(sql`NOW()`)
     });
-    await clients2.create(pg.sql);
+    await clients3.create(pg.sql);
     const codes = pgTable("_oauth2_codes", {
       id: serial("id").primaryKey(),
       code: text("code").unique().notNull(),
@@ -2837,7 +2842,7 @@ function createHub(opts) {
       }
     });
   }
-  function join6(key, ws) {
+  function join7(key, ws) {
     if (!channels.has(key)) {
       channels.set(key, /* @__PURE__ */ new Set());
       redisSub?.subscribe(`${prefix}${key}`);
@@ -2878,7 +2883,7 @@ function createHub(opts) {
       await redisSub.quit();
     }
   }
-  return { join: join6, leave, broadcast, close };
+  return { join: join7, leave, broadcast, close };
 }
 
 // queue/index.ts
@@ -4688,14 +4693,14 @@ function forkApp(opts) {
   return { child, port: opts.port };
 }
 function stopProcess(mp, timeout = 1e4) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const timer = setTimeout(() => {
       mp.child.kill("SIGKILL");
-      resolve12();
+      resolve13();
     }, timeout);
     mp.child.on("exit", () => {
       clearTimeout(timer);
-      resolve12();
+      resolve13();
     });
     mp.child.kill("SIGTERM");
   });
@@ -5127,13 +5132,13 @@ import { createOpenAI as createOpenAI3 } from "@ai-sdk/openai";
 // opencode/rest.ts
 import { join as join4 } from "node:path";
 
-// ssr/ssr.ts
+// ssr.ts
 import { createElement } from "react";
 import { createHash as createHash3 } from "node:crypto";
 import { dirname as dirname2, resolve as resolve4 } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 
-// ssr/compile.ts
+// compile.ts
 import * as esbuild from "esbuild";
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2, resolve as resolve3, dirname } from "node:path";
@@ -5181,6 +5186,10 @@ function resolveAliases() {
 function id(s) {
   return createHash2("md5").update(s).digest("hex").slice(0, 8);
 }
+function clearCompileCache() {
+  cache.clear();
+  _alias = null;
+}
 async function compileTsx(path2) {
   if (cache.has(path2)) return cache.get(path2);
   const absPath = resolve3(path2);
@@ -5205,7 +5214,7 @@ async function compileTsx(path2) {
   return mod;
 }
 
-// ssr/stream.ts
+// stream.ts
 import { TextDecoder, TextEncoder as TextEncoder2 } from "node:util";
 var _publicEnv = null;
 function getPublicEnv() {
@@ -5326,13 +5335,23 @@ function streamResponse(reactStream, opts) {
   });
 }
 
-// ssr/ssr.ts
+// ssr.ts
 var als = new AsyncLocalStorage();
 __registerAls(() => als.getStore());
 var isDev = process.env.NODE_ENV !== "production";
+var bundleCache = /* @__PURE__ */ new Map();
 function id2(s) {
   return createHash3("md5").update(s).digest("hex").slice(0, 8);
 }
+function serializeLoaderData(ctx) {
+  const data = {};
+  for (const key of Object.keys(ctx)) {
+    if (!["params", "query", "mountPath", "layoutStack"].includes(key)) {
+      data[key] = ctx[key];
+    }
+  }
+  return data;
+}
 async function buildClientBundle(entryPath, layoutPaths) {
   try {
     const absEntry = resolve4(entryPath);
@@ -5379,21 +5398,17 @@ async function buildClientBundle(entryPath, layoutPaths) {
     return null;
   }
 }
-var bundleRegistry = /* @__PURE__ */ new Map();
-function serializeLoaderData(ctx) {
-  const data = {};
-  for (const key of Object.keys(ctx)) {
-    if (!["params", "query", "mountPath", "layoutStack"].includes(key)) {
-      data[key] = ctx[key];
-    }
-  }
-  return data;
-}
 function ssr(path2) {
   const entryId = id2(resolve4(path2));
   const bundleKey = `/__ssr/${entryId}.js`;
-  let bundleBuilt = false;
-  return async (req, ctx) => {
+  const r = new Router();
+  r.get("/__ssr/:path", (req, ctx) => {
+    const buf = bundleCache.get("/__ssr/" + ctx.params.path);
+    return buf ? new Response(buf, {
+      headers: { "content-type": "application/javascript; charset=utf-8" }
+    }) : new Response("", { status: 404 });
+  });
+  r.get("/", async (req, ctx) => {
     const pageMod = await compileTsx(path2);
     const Component = pageMod.default;
     if (!Component) return new Response("", { status: 500 });
@@ -5441,14 +5456,11 @@ function ssr(path2) {
         }
       }
       let bundle = null;
-      if (!bundleBuilt) {
+      if (!bundleCache.has(bundleKey)) {
         const buf = await buildClientBundle(path2, layoutPaths);
-        if (buf) {
-          bundleRegistry.set(bundleKey, buf);
-          bundleBuilt = true;
-        }
+        if (buf) bundleCache.set(bundleKey, buf);
       }
-      if (bundleRegistry.has(bundleKey)) {
+      if (bundleCache.has(bundleKey)) {
         bundle = { url: bundleKey };
       }
       const { renderToReadableStream } = await import("react-dom/server");
@@ -5461,10 +5473,11 @@ function ssr(path2) {
         loaderData
       });
     });
-  };
+  });
+  return r;
 }
 
-// ssr/layout.ts
+// layout.ts
 function layout(path2) {
   return async (req, ctx, next) => {
     const mod = await compileTsx(path2);
@@ -5475,15 +5488,6 @@ function layout(path2) {
   };
 }
 
-// ssr/tailwind.ts
-var isDev2 = process.env.NODE_ENV !== "production";
-
-// ssr/error-boundary.ts
-import { createElement as createElement2 } from "react";
-
-// ssr/live.ts
-import chokidar from "chokidar";
-
 // opencode/session.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { join as join3 } from "node:path";
@@ -5720,10 +5724,10 @@ function createBashTool(ctx) {
         return { stdout: "", stderr: "Command denied: potentially dangerous command", exitCode: 1 };
       }
       const cwd = workdir ? `${ctx.workspace}/${workdir}` : ctx.workspace;
-      return new Promise((resolve12) => {
+      return new Promise((resolve13) => {
         const child = exec(command, { cwd, timeout: timeout * 1e3, maxBuffer: 1024 * 1024 }, (error, stdout, stderr) => {
           const truncated = stdout.length > 1e6 || stderr.length > 1e6;
-          resolve12({
+          resolve13({
             stdout: stdout.slice(0, 1e6),
             stderr: stderr.slice(0, 1e6),
             exitCode: error?.code ?? 0,
@@ -5964,7 +5968,7 @@ function createQuestionTool(ctx) {
       options: z12.array(z12.string()).optional().describe("Optional multiple choice options")
     }),
     execute: async ({ question, options }, { toolCallId }) => {
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const timeout = setTimeout(() => {
           ctx.pendingQuestions.delete(toolCallId);
           reject(new Error("Question timed out"));
@@ -5972,7 +5976,7 @@ function createQuestionTool(ctx) {
         ctx.pendingQuestions.set(toolCallId, {
           resolve: (answer) => {
             clearTimeout(timeout);
-            resolve12(answer);
+            resolve13(answer);
           },
           reject: (err) => {
             clearTimeout(timeout);
@@ -7717,12 +7721,12 @@ function iii(opts = {}) {
     const handler = async (payload) => {
       if (!worker.ws) throw new Error(`Worker "${worker.name}" disconnected`);
       const invocationId = crypto6.randomUUID();
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const timer = setTimeout(() => {
           pending.delete(invocationId);
           reject(new Error(`Invocation timed out for "${id3}"`));
         }, 3e4);
-        pending.set(invocationId, { resolve: resolve12, reject, timer });
+        pending.set(invocationId, { resolve: resolve13, reject, timer });
         worker.ws.send(JSON.stringify({
           type: "invoke",
           invocation_id: invocationId,
@@ -7963,8 +7967,8 @@ function registerWorker(url) {
   function connect() {
     if (intentionalClose) return;
     ws = new WebSocket(url);
-    ready = new Promise((resolve12) => {
-      resolveReady = resolve12;
+    ready = new Promise((resolve13) => {
+      resolveReady = resolve13;
     });
     ws.onopen = () => {
       reconnectAttempt = 0;
@@ -8084,13 +8088,13 @@ function registerWorker(url) {
         }
         return Promise.resolve(fn(request.payload, ctx));
       }
-      return new Promise((resolve12, reject) => {
+      return new Promise((resolve13, reject) => {
         const invocationId = genId();
         const timer = setTimeout(() => {
           pendingInvocations.delete(invocationId);
           reject(new Error(`Invocation timed out for "${request.function_id}"`));
         }, request.timeout_ms || 3e4);
-        pendingInvocations.set(invocationId, { resolve: resolve12, reject, timer });
+        pendingInvocations.set(invocationId, { resolve: resolve13, reject, timer });
         send({
           type: "invoke",
           invocation_id: invocationId,
@@ -8110,6 +8114,155 @@ function registerWorker(url) {
     }
   };
 }
+
+// live.ts
+import chokidar from "chokidar";
+var clients2 = /* @__PURE__ */ new Set();
+function broadcastReload() {
+  for (const ws of clients2) {
+    try {
+      ws.send("reload");
+    } catch {
+      clients2.delete(ws);
+    }
+  }
+}
+function liveReload(opts) {
+  const r = new Router();
+  r.ws("/__weifuwu/livereload", {
+    open(ws) {
+      clients2.add(ws);
+      ws.on("close", () => clients2.delete(ws));
+      ws.on("error", () => clients2.delete(ws));
+    }
+  });
+  const watcher = chokidar.watch(opts.dirs, {
+    ignored: /(^|[/\\])\.|node_modules|[/\\]\.weifuwu[/\\]/,
+    ignoreInitial: true
+  });
+  watcher.on("change", (path2) => {
+    if (!/\.tsx?$/.test(path2)) return;
+    clearCompileCache();
+    setTimeout(broadcastReload, 50);
+  });
+  r.close = () => {
+    watcher.close();
+    clients2.clear();
+  };
+  return r;
+}
+
+// tailwind.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { relative, resolve as resolve12 } from "node:path";
+var isDev2 = process.env.NODE_ENV !== "production";
+function tailwind(cssPath, scanDir2) {
+  let compiledCss = "";
+  let twWatcher = null;
+  return async (req, ctx, next) => {
+    const url = new URL(req.url);
+    if (url.pathname === "/__wfw/style.css") {
+      if (!compiledCss) compiledCss = await compile(cssPath, scanDir2);
+      return new Response(compiledCss || "", {
+        headers: { "content-type": "text/css; charset=utf-8" }
+      });
+    }
+    ctx.compiledTailwindCss = compiledCss;
+    if (isDev2 && !twWatcher) {
+      twWatcher = watchFile(cssPath, () => {
+        compiledCss = "";
+      });
+    }
+    return next(req, ctx);
+  };
+}
+async function compile(cssPath, scanDir2) {
+  try {
+    const inputFile = resolve12(cssPath);
+    if (!existsSync5(inputFile)) {
+      mkdirSync3(dirname4(inputFile), { recursive: true });
+      writeFileSync3(inputFile, '@import "tailwindcss"\n', "utf-8");
+    }
+    const { default: tailwindPlugin } = await import("@tailwindcss/postcss");
+    const { default: postcss } = await import("postcss");
+    let src = readFileSync5(inputFile, "utf-8");
+    const scanSource = scanDir2 ? relative(dirname4(inputFile), scanDir2) || "." : ".";
+    const sourcePath = scanSource === "." ? "./" : `./${scanSource}/`;
+    src = `@source "${sourcePath}";
+${src}`;
+    const result = await postcss([tailwindPlugin()]).process(src, { from: inputFile });
+    return result.css;
+  } catch (err) {
+    console.warn("Tailwind CSS processing failed:", err.message);
+    return "";
+  }
+}
+function dirname4(p) {
+  return p.substring(0, p.lastIndexOf("/")) || "/";
+}
+function watchFile(path2, onChange) {
+  let watcher = null;
+  import("chokidar").then((chokidar2) => {
+    watcher = chokidar2.default.watch(resolve12(path2), { persistent: false });
+    watcher.on("change", onChange);
+  });
+  return watcher;
+}
+
+// not-found.ts
+function notFound(path2) {
+  return async (req, ctx) => {
+    if (!path2) return new Response("Not Found", { status: 404 });
+    const mod = await compileTsx(path2);
+    const Component = mod?.default;
+    const body = Component ? "404 - Not Found" : "404 - Not Found";
+    return new Response(body, {
+      status: 404,
+      headers: { "content-type": "text/html; charset=utf-8" }
+    });
+  };
+}
+
+// error-boundary.ts
+import { createElement as createElement2 } from "react";
+import { TextEncoder as TextEncoder3 } from "node:util";
+function errorBoundary(errorPath) {
+  return async (req, ctx, next) => {
+    try {
+      return await next(req, ctx);
+    } catch (err) {
+      const mod = await compileTsx(errorPath);
+      const ErrorComponent = mod.default;
+      if (!ErrorComponent) throw err;
+      const layouts = (ctx.layoutStack || []).map((l) => l.component);
+      const stream = await import("react-dom/server").then((m) => m.renderToReadableStream(
+        createElement2(ErrorComponent, {
+          error: err instanceof Error ? err : new Error(String(err)),
+          reset: () => {
+          }
+        })
+      ));
+      const reader = stream.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const encoder2 = new TextEncoder3();
+      const body = chunks.reduce((acc, c) => {
+        const merged = new Uint8Array(acc.length + c.length);
+        merged.set(acc);
+        merged.set(c, acc.length);
+        return merged;
+      }, new Uint8Array(0));
+      return new Response(body, {
+        status: 500,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    }
+  };
+}
 export {
   Router,
   TsxContext,
@@ -8117,6 +8270,7 @@ export {
   aiStream,
   analytics,
   auth,
+  clearCompileCache,
   compress,
   cors,
   createHub,
@@ -8130,6 +8284,7 @@ export {
   deploy,
   embed,
   embedMany,
+  errorBoundary,
   formatSSE,
   formatSSEData,
   generateObject,
@@ -8139,11 +8294,14 @@ export {
   health,
   helmet,
   iii,
+  layout,
+  liveReload,
   loadEnv,
   logdb,
   logger,
   mailer,
   messager,
+  notFound,
   openai,
   opencode,
   postgres,
@@ -8161,8 +8319,10 @@ export {
   serveStatic,
   setCookie,
   smoothStream,
+  ssr,
   streamObject,
   streamText,
+  tailwind,
   tenant,
   tool2 as tool,
   upload,

package/dist/layout.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from './types.ts';
+export declare function layout(path: string): Middleware;

package/dist/live.d.ts

@@ -0,0 +1,6 @@
+import { Router } from './router.ts';
+export declare function liveReload(opts: {
+    dirs: string[];
+}): Router & {
+    close: () => void;
+};

package/dist/not-found.d.ts

@@ -0,0 +1,2 @@
+import type { Handler } from './types.ts';
+export declare function notFound(path?: string): Handler;

package/dist/router.d.ts

@@ -19,16 +19,16 @@ export declare class Router {
     use(router: Router): this;
     use(path: string, router: Router): this;
     use(path: string, mw: Middleware): this;
-    get(path: string, ...args: [...Middleware[], Handler]): this;
-    post(path: string, ...args: [...Middleware[], Handler]): this;
-    put(path: string, ...args: [...Middleware[], Handler]): this;
-    delete(path: string, ...args: [...Middleware[], Handler]): this;
-    patch(path: string, ...args: [...Middleware[], Handler]): this;
-    head(path: string, ...args: [...Middleware[], Handler]): this;
-    options(path: string, ...args: [...Middleware[], Handler]): this;
-    all(path: string, ...args: [...Middleware[], Handler]): this;
+    get(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    post(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    put(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    delete(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    patch(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    head(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    options(path: string, ...args: [...Middleware[], Handler | Router]): this;
+    all(path: string, ...args: [...Middleware[], Handler | Router]): this;
     onError(handler: ErrorHandler): this;
-    route(method: string, path: string, ...args: [...Middleware[], Handler]): this;
+    route(method: string, path: string, ...args: [...Middleware[], Handler | Router]): this;
     ws(path: string, ...args: [...Middleware[], WebSocketHandler]): this;
     handler(): Handler;
     websocketHandler(): WsUpgradeHandler;

package/dist/ssr.d.ts

@@ -0,0 +1,2 @@
+import { Router } from './router.ts';
+export declare function ssr(path: string): Router;