bosbun 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosbun",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "description": "A minimalist fullstack framework — SSR + Svelte 5 Runes + Bun + ElysiaJS",
   "keywords": [

package/src/core/client/App.svelte

@@ -9,12 +9,14 @@
     ssrLayoutComponents = [],
     ssrPageData = {},
     ssrLayoutData = [],
+    ssrFormData = null,
   }: {
     ssrMode?: boolean;
     ssrPageComponent?: any;
     ssrLayoutComponents?: any[];
     ssrPageData?: Record<string, any>;
     ssrLayoutData?: Record<string, any>[];
+    ssrFormData?: any;
   } = $props();
 
   let PageComponent = $state<any>(ssrPageComponent);
@@ -23,6 +25,7 @@
   let layoutData = $state<Record<string, any>[]>(ssrLayoutData ?? []);
   // Kept separate to avoid a read→write cycle inside the $effect below
   let routeParams = $state<Record<string, string>>(ssrPageData?.params ?? {});
+  let formData = $state<any>(ssrFormData);
   let navigating = $state(false);
   let navDone = $state(false);
   // Skip bar on the very first effect run (initial hydration — data already present)
@@ -41,6 +44,7 @@
     const isFirst = firstNav;
     firstNav = false;
     if (!isFirst) {
+      formData = null;
       if (navDoneTimer) { clearTimeout(navDoneTimer); navDoneTimer = null; }
       navDone = false;
       navigating = true;
@@ -94,7 +98,7 @@
 {#if layoutComponents.length > 0}
   {@render renderLayout(0)}
 {:else if PageComponent}
-  <PageComponent data={{ ...pageData, params: routeParams }} />
+  <PageComponent data={{ ...pageData, params: routeParams }} form={formData} />
 {:else}
   <p>Loading...</p>
 {/if}
@@ -110,7 +114,7 @@
   {:else}
     <Layout {data}>
       {#if PageComponent}
-        <PageComponent data={{ ...pageData, params: routeParams }} />
+        <PageComponent data={{ ...pageData, params: routeParams }} form={formData} />
       {:else}
         <p>Loading...</p>
       {/if}

package/src/core/client/hydrate.ts

@@ -37,6 +37,7 @@ async function main() {
             ssrLayoutComponents,
             ssrPageData: (window as any).__BUNIA_PAGE_DATA__ ?? {},
             ssrLayoutData: (window as any).__BUNIA_LAYOUT_DATA__ ?? [],
+            ssrFormData: (window as any).__BUNIA_FORM_DATA__ ?? null,
         },
     });
 }

package/src/core/errors.ts

@@ -21,3 +21,15 @@ export function error(status: number, message: string): never {
 export function redirect(status: number, location: string): never {
     throw new Redirect(status, location);
 }
+
+// ─── Form Action Helpers ─────────────────────────────────
+// Return from form actions — not thrown, just returned.
+
+export class ActionFailure<T extends Record<string, any> = Record<string, any>> {
+    constructor(public status: number, public data: T) {}
+}
+
+/** Return a failure from a form action with a status code and data. */
+export function fail<T extends Record<string, any>>(status: number, data: T): ActionFailure<T> {
+    return new ActionFailure(status, data);
+}

package/src/core/hooks.ts

@@ -46,6 +46,7 @@ export type LoadEvent = {
     cookies: Cookies;
     fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     parent: () => Promise<Record<string, any>>;
+    metadata: Record<string, any> | null;
 };
 
 export type ResolveFunction = (event: RequestEvent) => MaybePromise<Response>;
@@ -55,6 +56,23 @@ export type Handle = (input: {
     resolve: ResolveFunction;
 }) => MaybePromise<Response>;
 
+// ─── Metadata Types ──────────────────────────────────────
+
+export type MetadataEvent = {
+    params: Record<string, string>;
+    url: URL;
+    locals: Record<string, any>;
+    cookies: Cookies;
+    fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+};
+
+export type Metadata = {
+    title?: string;
+    description?: string;
+    meta?: Array<{ name?: string; property?: string; content: string }>;
+    data?: Record<string, any>;
+};
+
 type MaybePromise<T> = T | Promise<T>;
 
 // ─── Middleware Composition ────────────────────────────────

package/src/core/html.ts

@@ -56,6 +56,7 @@ export function buildHtml(
     pageData: any,
     layoutData: any[],
     csr = true,
+    formData: any = null,
 ): string {
     const cacheBust = isDev ? `?v=${Date.now()}` : "";
 
@@ -70,8 +71,12 @@ export function buildHtml(
         ? `\n  <script>window.__BUNIA_ENV__=${safeJsonStringify(publicEnv)};</script>`
         : "";
 
+    const formScript = formData != null
+        ? `window.__BUNIA_FORM_DATA__=${safeJsonStringify(formData)};`
+        : "";
+
     const scripts = csr
-        ? `${envScript}\n  <script>window.__BUNIA_PAGE_DATA__=${safeJsonStringify(pageData)};window.__BUNIA_LAYOUT_DATA__=${safeJsonStringify(layoutData)};</script>\n  <script type="module" src="/dist/client/${distManifest.entry}${cacheBust}"></script>`
+        ? `${envScript}\n  <script>window.__BUNIA_PAGE_DATA__=${safeJsonStringify(pageData)};window.__BUNIA_LAYOUT_DATA__=${safeJsonStringify(layoutData)};${formScript}</script>\n  <script type="module" src="/dist/client/${distManifest.entry}${cacheBust}"></script>`
         : isDev
             ? `\n  <script>!function r(){var e=new EventSource("/__bunia/sse");e.addEventListener("reload",()=>location.reload());e.onopen=()=>r._ok||(r._ok=1);e.onerror=()=>{e.close();setTimeout(r,2000)}}()</script>`
             : "";
@@ -95,29 +100,69 @@ export function buildHtml(
 
 // ─── Streaming HTML Helpers ──────────────────────────────
 
+import type { Metadata } from "./hooks.ts";
+
 let _shell: string | null = null;
 
 export function buildHtmlShell(): string {
     if (_shell) return _shell;
+    _shell = buildHtmlShellOpen() + buildMetadataChunk(null);
+    return _shell;
+}
+
+let _shellOpen: string | null = null;
+
+/** Chunk 1: everything from <!DOCTYPE> through CSS/modulepreload links (head still open) */
+export function buildHtmlShellOpen(): string {
+    if (_shellOpen) return _shellOpen;
     const cacheBust = isDev ? `?v=${Date.now()}` : "";
     const cssLinks = (distManifest.css ?? [])
         .map((f: string) => `<link rel="stylesheet" href="/dist/client/${f}">`)
         .join("\n  ");
-    _shell = `<!DOCTYPE html>\n<html lang="en">\n<head>\n` +
+    _shellOpen = `<!DOCTYPE html>\n<html lang="en">\n<head>\n` +
         `  <meta charset="UTF-8">\n` +
         `  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n` +
         `  <link rel="icon" href="data:,">\n` +
         `  ${cssLinks}\n` +
         `  <link rel="stylesheet" href="/bunia-tw.css${cacheBust}">\n` +
-        `  <link rel="modulepreload" href="/dist/client/${distManifest.entry}${cacheBust}">\n` +
-        `</head>\n<body>\n` +
-        `<div id="__bs__"><style>` +
-        `:root{--bunia-loading-color:#f73b27}` +
-        `#__bs__{position:fixed;inset:0;display:flex;align-items:center;justify-content:center}` +
-        `#__bs__ i{width:32px;height:32px;border:3px solid #e5e7eb;border-top-color:var(--bunia-loading-color);` +
-        `border-radius:50%;animation:__bs__ .8s linear infinite}` +
-        `@keyframes __bs__{to{transform:rotate(360deg)}}</style><i></i></div>`;
-    return _shell;
+        `  <link rel="modulepreload" href="/dist/client/${distManifest.entry}${cacheBust}">`;
+    return _shellOpen;
+}
+
+const SPINNER = `<div id="__bs__"><style>` +
+    `:root{--bunia-loading-color:#f73b27}` +
+    `#__bs__{position:fixed;inset:0;display:flex;align-items:center;justify-content:center}` +
+    `#__bs__ i{width:32px;height:32px;border:3px solid #e5e7eb;border-top-color:var(--bunia-loading-color);` +
+    `border-radius:50%;animation:__bs__ .8s linear infinite}` +
+    `@keyframes __bs__{to{transform:rotate(360deg)}}</style><i></i></div>`;
+
+/** Chunk 2: metadata tags + close </head> + open <body> + spinner */
+export function buildMetadataChunk(metadata: Metadata | null): string {
+    let out = "\n";
+    if (metadata) {
+        if (metadata.title) out += `  <title>${escapeHtml(metadata.title)}</title>\n`;
+        if (metadata.description) {
+            out += `  <meta name="description" content="${escapeAttr(metadata.description)}">\n`;
+        }
+        if (metadata.meta) {
+            for (const m of metadata.meta) {
+                const attrs = m.name ? `name="${escapeAttr(m.name)}"` : `property="${escapeAttr(m.property ?? "")}"`;
+                out += `  <meta ${attrs} content="${escapeAttr(m.content)}">\n`;
+            }
+        }
+    } else {
+        out += `  <title>Bunia App</title>\n`;
+    }
+    out += `</head>\n<body>\n${SPINNER}`;
+    return out;
+}
+
+function escapeHtml(s: string): string {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function escapeAttr(s: string): string {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
 export function buildHtmlTail(
@@ -126,6 +171,7 @@ export function buildHtmlTail(
     pageData: any,
     layoutData: any[],
     csr: boolean,
+    formData: any = null,
 ): string {
     const cacheBust = isDev ? `?v=${Date.now()}` : "";
     let out = `<script>document.getElementById('__bs__').remove()</script>`;
@@ -136,8 +182,9 @@ export function buildHtmlTail(
         if (Object.keys(publicEnv).length > 0) {
             out += `\n<script>window.__BUNIA_ENV__=${safeJsonStringify(publicEnv)};</script>`;
         }
+        const formInject = formData != null ? `window.__BUNIA_FORM_DATA__=${safeJsonStringify(formData)};` : "";
         out += `\n<script>window.__BUNIA_PAGE_DATA__=${safeJsonStringify(pageData)};` +
-               `window.__BUNIA_LAYOUT_DATA__=${safeJsonStringify(layoutData)};</script>`;
+               `window.__BUNIA_LAYOUT_DATA__=${safeJsonStringify(layoutData)};${formInject}</script>`;
         out += `\n<script type="module" src="/dist/client/${distManifest.entry}${cacheBust}"></script>`;
     } else if (isDev) {
         out += `\n<script>!function r(){var e=new EventSource("/__bunia/sse");e.addEventListener("reload",()=>location.reload());e.onopen=()=>r._ok||(r._ok=1);e.onerror=()=>{e.close();setTimeout(r,2000)}}()</script>`;

package/src/core/matcher.ts

@@ -17,6 +17,11 @@ export function matchPattern(
     pattern: string,
     pathname: string,
 ): Record<string, string> | null {
+    // Strip trailing slash (but keep "/" as-is)
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+    }
+
     // Exact match
     if (pattern === pathname) return {};
 
@@ -54,29 +59,19 @@ export function matchPattern(
 
 /**
  * Find the first matching route from a list.
- * Uses 3-pass priority: exact → dynamic → catch-all.
+ * Routes must be pre-sorted by priority (exact → dynamic → catch-all).
+ * Single pass — first match wins.
  */
 export function findMatch<T extends { pattern: string }>(
     routes: T[],
     pathname: string,
 ): RouteMatch<T> | null {
-    // Pass 1 — exact
-    for (const route of routes) {
-        if (route.pattern === pathname) {
-            return { route, params: {} };
-        }
-    }
-
-    // Pass 2 — dynamic segments (no catch-all)
-    for (const route of routes) {
-        if (!route.pattern.includes("[") || route.pattern.includes("[...")) continue;
-        const params = matchPattern(route.pattern, pathname);
-        if (params !== null) return { route, params };
+    // Strip trailing slash (but keep "/" as-is)
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
     }
 
-    // Pass 3 — catch-all
     for (const route of routes) {
-        if (!route.pattern.includes("[...")) continue;
         const params = matchPattern(route.pattern, pathname);
         if (params !== null) return { route, params };
     }

package/src/core/renderer.ts

@@ -5,7 +5,8 @@ import { serverRoutes, errorPage } from "bunia:routes";
 import type { Cookies } from "./hooks.ts";
 import { HttpError, Redirect } from "./errors.ts";
 import App from "./client/App.svelte";
-import { buildHtml, buildHtmlShell, buildHtmlTail, compress, safeJsonStringify, isDev } from "./html.ts";
+import { buildHtml, buildHtmlShell, buildHtmlShellOpen, buildMetadataChunk, buildHtmlTail, compress, safeJsonStringify, isDev } from "./html.ts";
+import type { Metadata } from "./hooks.ts";
 
 // ─── Session-Aware Fetch ─────────────────────────────────
 // Passed to load() functions so they can call internal APIs
@@ -37,6 +38,7 @@ export async function loadRouteData(
     locals: Record<string, any>,
     req: Request,
     cookies: Cookies,
+    metadataData: Record<string, any> | null = null,
 ) {
     const match = findMatch(serverRoutes, url.pathname);
     if (!match) return null;
@@ -55,7 +57,7 @@ export async function loadRouteData(
                     for (let d = 0; d < ls.depth; d++) Object.assign(merged, layoutData[d] ?? {});
                     return merged;
                 };
-                layoutData[ls.depth] = (await mod.load({ params, url, locals, cookies, parent, fetch })) ?? {};
+                layoutData[ls.depth] = (await mod.load({ params, url, locals, cookies, parent, fetch, metadata: null })) ?? {};
             }
         } catch (err) {
             if (err instanceof HttpError || err instanceof Redirect) throw err;
@@ -77,7 +79,7 @@ export async function loadRouteData(
                     for (const d of layoutData) if (d) Object.assign(merged, d);
                     return merged;
                 };
-                pageData = (await mod.load({ params, url, locals, cookies, parent, fetch })) ?? {};
+                pageData = (await mod.load({ params, url, locals, cookies, parent, fetch, metadata: metadataData })) ?? {};
             }
         } catch (err) {
             if (err instanceof HttpError || err instanceof Redirect) throw err;
@@ -119,6 +121,30 @@ export async function renderSSR(url: URL, locals: Record<string, any>, req: Requ
     return { body, head, pageData: data.pageData, layoutData: data.layoutData, csr: data.csr };
 }
 
+// ─── Metadata Loader ─────────────────────────────────────
+
+async function loadMetadata(
+    route: any,
+    params: Record<string, string>,
+    url: URL,
+    locals: Record<string, any>,
+    cookies: Cookies,
+    req: Request,
+): Promise<Metadata | null> {
+    if (!route.pageServer) return null;
+    try {
+        const mod = await route.pageServer();
+        if (typeof mod.metadata === "function") {
+            const fetch = makeFetch(req, url);
+            return (await mod.metadata({ params, url, locals, cookies, fetch })) ?? null;
+        }
+    } catch (err) {
+        if (isDev) console.error("Metadata load error:", err);
+        else console.error("Metadata load error:", (err as Error).message ?? err);
+    }
+    return null;
+}
+
 // ─── Streaming SSR Renderer ──────────────────────────────
 
 export function renderSSRStream(
@@ -130,7 +156,7 @@ export function renderSSRStream(
     const match = findMatch(serverRoutes, url.pathname);
     if (!match) return null;
 
-    const { route } = match;
+    const { route, params } = match;
     const enc = new TextEncoder();
 
     // Kick off imports immediately (parallel with data loading)
@@ -139,12 +165,20 @@ export function renderSSRStream(
 
     const stream = new ReadableStream<Uint8Array>({
         async start(controller) {
-            // Chunk 1: shell (cached at startup)
-            controller.enqueue(enc.encode(buildHtmlShell()));
+            // Chunk 1: head opening (CSS, modulepreload — cached)
+            controller.enqueue(enc.encode(buildHtmlShellOpen()));
 
             try {
+                // Chunk 2: metadata() resolves → send title/meta, close head, open body + spinner
+                const metadata = await loadMetadata(route, params, url, locals, cookies, req);
+                controller.enqueue(enc.encode(buildMetadataChunk(metadata)));
+
+                // Pass metadata.data to load() so it can reuse fetched data
+                const metadataData = metadata?.data ?? null;
+
+                // Wait for data + component imports
                 const [data, pageMod, layoutMods] = await Promise.all([
-                    loadRouteData(url, locals, req, cookies),
+                    loadRouteData(url, locals, req, cookies, metadataData),
                     pageModPromise,
                     layoutModsPromise,
                 ]);
@@ -165,7 +199,7 @@ export function renderSSRStream(
                     },
                 });
 
-                // Chunk 2: content
+                // Chunk 3: rendered content
                 controller.enqueue(enc.encode(buildHtmlTail(body, head, data.pageData, data.layoutData, data.csr)));
                 controller.close();
             } catch (err) {
@@ -196,6 +230,47 @@ export function renderSSRStream(
     });
 }
 
+// ─── Form Action Page Renderer ───────────────────────────
+// Re-runs load functions after a form action, renders with form data.
+// Uses non-streaming buildHtml so we can control the status code.
+
+export async function renderPageWithFormData(
+    url: URL,
+    locals: Record<string, any>,
+    req: Request,
+    cookies: Cookies,
+    formData: any,
+    status: number,
+): Promise<Response> {
+    const match = findMatch(serverRoutes, url.pathname);
+    if (!match) return renderErrorPage(404, "Not Found", url, req);
+
+    const { route } = match;
+
+    // Load components + data in parallel
+    const [data, pageMod, layoutMods] = await Promise.all([
+        loadRouteData(url, locals, req, cookies),
+        route.pageModule(),
+        Promise.all(route.layoutModules.map((l: () => Promise<any>) => l())),
+    ]);
+
+    if (!data) return renderErrorPage(404, "Not Found", url, req);
+
+    const { body, head } = render(App, {
+        props: {
+            ssrMode: true,
+            ssrPageComponent: pageMod.default,
+            ssrLayoutComponents: layoutMods.map((m: any) => m.default),
+            ssrPageData: data.pageData,
+            ssrLayoutData: data.layoutData,
+            ssrFormData: formData,
+        },
+    });
+
+    const html = buildHtml(body, head, data.pageData, data.layoutData, data.csr, formData);
+    return compress(html, "text/html; charset=utf-8", req, status);
+}
+
 // ─── Error Page Renderer ──────────────────────────────────
 
 export async function renderErrorPage(status: number, message: string, url: URL, req: Request): Promise<Response> {

package/src/core/routeFile.ts

@@ -7,11 +7,33 @@ import type { RouteManifest } from "./types.ts";
 //   serverRoutes  — used by SSR renderer (+ pageServer + layoutServers)
 //   apiRoutes     — used by API handler
 
+function routePriority(pattern: string): number {
+    if (!pattern.includes("[")) return 0;       // exact
+    if (!pattern.includes("[...")) return 1;    // dynamic
+    return 2;                                   // catch-all
+}
+
+function sortRoutes<T extends { pattern: string }>(routes: T[]): T[] {
+    return [...routes].sort((a, b) => {
+        const pa = routePriority(a.pattern);
+        const pb = routePriority(b.pattern);
+        if (pa !== pb) return pa - pb;
+        // same tier: more segments first, then alphabetical
+        const sa = a.pattern.split("/").length;
+        const sb = b.pattern.split("/").length;
+        if (sa !== sb) return sb - sa;
+        return a.pattern.localeCompare(b.pattern);
+    });
+}
+
 export function generateRoutesFile(manifest: RouteManifest): void {
     const lines: string[] = [
         "// AUTO-GENERATED by bunia build — do not edit\n",
     ];
 
+    const pages = sortRoutes(manifest.pages);
+    const apis = sortRoutes(manifest.apis);
+
     // clientRoutes
     lines.push("export const clientRoutes: Array<{");
     lines.push("  pattern: string;");
@@ -19,7 +41,7 @@ export function generateRoutesFile(manifest: RouteManifest): void {
     lines.push("  layouts: (() => Promise<any>)[];");
     lines.push("  hasServerData: boolean;");
     lines.push("}> = [");
-    for (const r of manifest.pages) {
+    for (const r of pages) {
         const layoutImports = r.layouts
             .map(l => `() => import(${JSON.stringify(toImportPath(l))})`)
             .join(", ");
@@ -41,7 +63,7 @@ export function generateRoutesFile(manifest: RouteManifest): void {
     lines.push("  pageServer: (() => Promise<any>) | null;");
     lines.push("  layoutServers: { loader: () => Promise<any>; depth: number }[];");
     lines.push("}> = [");
-    for (const r of manifest.pages) {
+    for (const r of pages) {
         const layoutImports = r.layouts
             .map(l => `() => import(${JSON.stringify(toImportPath(l))})`)
             .join(", ");
@@ -63,7 +85,7 @@ export function generateRoutesFile(manifest: RouteManifest): void {
     lines.push("  pattern: string;");
     lines.push("  module: () => Promise<any>;");
     lines.push("}> = [");
-    for (const r of manifest.apis) {
+    for (const r of apis) {
         lines.push("  {");
         lines.push(`    pattern: ${JSON.stringify(r.pattern)},`);
         lines.push(`    module: () => import(${JSON.stringify(toImportPath(r.server))}),`);

package/src/core/routeTypes.ts

@@ -51,6 +51,17 @@ export function generateRouteTypes(manifest: RouteManifest): void {
         }
         lines.push(`export type PageProps = { data: PageData };`);
 
+        // ActionData — union of all action return types, unwrapping ActionFailure
+        if (info.pageServer) {
+            lines.push(``);
+            lines.push(`import type { actions as _actions } from '${srcBase}+page.server.ts';`);
+            lines.push(`type _ActionReturn<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;`);
+            lines.push(`type _UnwrapFailure<T> = T extends { status: number; data: infer D } ? D : T;`);
+            lines.push(`export type ActionData = _actions extends Record<string, (...args: any[]) => any>`);
+            lines.push(`  ? _UnwrapFailure<_ActionReturn<_actions[keyof _actions]>> | null`);
+            lines.push(`  : null;`);
+        }
+
         if (info.layoutServer) {
             lines.push(`\nimport type { load as _layoutLoad } from '${srcBase}+layout.server.ts';`);
             lines.push(`export type LayoutData = Awaited<ReturnType<typeof _layoutLoad>> & { params: Record<string, string> };`);

package/src/core/server.ts

@@ -4,16 +4,16 @@ import { existsSync } from "fs";
 import { join } from "path";
 
 import { findMatch } from "./matcher.ts";
-import { apiRoutes } from "bunia:routes";
+import { apiRoutes, serverRoutes } from "bunia:routes";
 import type { Handle, RequestEvent } from "./hooks.ts";
-import { HttpError, Redirect } from "./errors.ts";
+import { HttpError, Redirect, ActionFailure } from "./errors.ts";
 import { CookieJar } from "./cookies.ts";
 import { checkCsrf } from "./csrf.ts";
 import type { CsrfConfig } from "./csrf.ts";
 import { getCorsHeaders, handlePreflight } from "./cors.ts";
 import type { CorsConfig } from "./cors.ts";
 import { isDev, compress, isStaticPath } from "./html.ts";
-import { loadRouteData, renderSSRStream, renderErrorPage } from "./renderer.ts";
+import { loadRouteData, renderSSRStream, renderErrorPage, renderPageWithFormData } from "./renderer.ts";
 import { getServerTime } from "../lib/utils.ts";
 
 // ─── User Hooks ──────────────────────────────────────────
@@ -94,6 +94,14 @@ function isValidRoutePath(path: string, origin: string): boolean {
     }
 }
 
+/** Extract action name from URL searchParams — `?/login` → "login", no slash key → "default". */
+function parseActionName(url: URL): string {
+    for (const key of url.searchParams.keys()) {
+        if (key.startsWith("/")) return key.slice(1) || "default";
+    }
+    return "default";
+}
+
 async function resolve(event: RequestEvent): Promise<Response> {
     const { request, url, locals, cookies } = event;
     const path = url.pathname;
@@ -190,6 +198,69 @@ async function resolve(event: RequestEvent): Promise<Response> {
         }
     }
 
+    // Form actions — POST to page routes with `actions` export
+    if (method === "POST") {
+        const pageMatch = findMatch(serverRoutes, path);
+        if (pageMatch?.route.pageServer) {
+            try {
+                const mod = await pageMatch.route.pageServer();
+                if (mod.actions && typeof mod.actions === "object") {
+                    const actionName = parseActionName(url);
+                    const action = mod.actions[actionName];
+                    if (!action) {
+                        return renderErrorPage(404, `Action "${actionName}" not found`, url, request);
+                    }
+
+                    event.params = pageMatch.params;
+                    let result: any;
+                    try {
+                        result = await action(event);
+                    } catch (err) {
+                        if (err instanceof Redirect) {
+                            return new Response(null, {
+                                status: 303,
+                                headers: { Location: err.location },
+                            });
+                        }
+                        if (err instanceof HttpError) {
+                            return renderErrorPage(err.status, err.message, url, request);
+                        }
+                        throw err;
+                    }
+
+                    // Redirect returned (not thrown)
+                    if (result instanceof Redirect) {
+                        return new Response(null, {
+                            status: 303,
+                            headers: { Location: result.location },
+                        });
+                    }
+
+                    // ActionFailure — re-render with failure status
+                    if (result instanceof ActionFailure) {
+                        return renderPageWithFormData(url, locals, request, cookies, result.data, result.status);
+                    }
+
+                    // Success — re-render page with action return data
+                    return renderPageWithFormData(url, locals, request, cookies, result ?? null, 200);
+                }
+            } catch (err) {
+                if (err instanceof Redirect) {
+                    return new Response(null, {
+                        status: 303,
+                        headers: { Location: err.location },
+                    });
+                }
+                if (err instanceof HttpError) {
+                    return renderErrorPage(err.status, err.message, url, request);
+                }
+                if (isDev) console.error("Form action error:", err);
+                else console.error("Form action error:", (err as Error).message ?? err);
+                return Response.json({ error: "Internal Server Error" }, { status: 500 });
+            }
+        }
+    }
+
     // SSR pages (+page.svelte) — streaming by default
     const streamResponse = renderSSRStream(url, locals, request, cookies);
     if (!streamResponse) return renderErrorPage(404, "Not Found", url, request);
@@ -293,7 +364,10 @@ const app = new Elysia({ serve: { maxRequestBodySize: BODY_SIZE_LIMIT } })
         return handleRequest(request, url);
     })
     // Non-GET catch-alls so onBeforeHandle fires for API routes on other methods
-    .post("*", () => new Response("Not Found", { status: 404 }))
+    .post("*", ({ request }) => {
+        const url = new URL(request.url);
+        return handleRequest(request, url);
+    })
     .put("*", () => new Response("Not Found", { status: 404 }))
     .patch("*", () => new Response("Not Found", { status: 404 }))
     .delete("*", () => new Response("Not Found", { status: 404 }))

package/src/lib/index.ts

@@ -5,11 +5,13 @@
 
 export { cn, getServerTime } from "./utils.ts";
 export { sequence } from "../core/hooks.ts";
-export { error, redirect } from "../core/errors.ts";
-export type { HttpError, Redirect } from "../core/errors.ts";
+export { error, redirect, fail } from "../core/errors.ts";
+export type { HttpError, Redirect, ActionFailure } from "../core/errors.ts";
 export type {
     RequestEvent,
     LoadEvent,
+    MetadataEvent,
+    Metadata,
     Handle,
     ResolveFunction,
     Cookies,