hono-preact 0.1.0 → 0.3.0

package/dist/iso/define-loader.d.ts

@@ -2,6 +2,9 @@ import type { ComponentChildren, ComponentType, FunctionComponent } from 'preact
 import type { Context } from 'hono';
 import type { RouteHook } from 'preact-iso';
 import { type LoaderCache } from './cache.js';
+import type { LoaderUse } from './internal/use-types.js';
+import type { Middleware } from './define-middleware.js';
+import type { StreamObserver } from './define-stream-observer.js';
 export type LoaderCtx = {
     c: Context;
     location: RouteHook;
@@ -15,6 +18,21 @@ export interface LoaderRef<T> {
     readonly fn: Loader<T>;
     readonly cache: LoaderCache<T>;
     readonly params: string[] | '*';
+    /**
+     * Raw value as authored on `defineLoader({ timeoutMs })`. `undefined`
+     * means "use the handler's configured default"; `false` means "no
+     * timeout, only the request signal aborts".
+     */
+    readonly timeoutMs?: number | false;
+    /**
+     * Per-loader middleware and (for streaming loaders) stream observers,
+     * exactly as authored on `defineLoader({ use })`. The handler-side
+     * dispatcher calls `partitionUse(ref.use)` to split middleware from
+     * observers; both partitions flow through the SSR/RPC streaming pump.
+     * Typed as the union the partitioner accepts so the contract is
+     * advertised at the consumer rather than hidden behind `unknown`.
+     */
+    readonly use: ReadonlyArray<Middleware | StreamObserver<unknown, never>>;
     useData(): T;
     useError(): Error | null;
     invalidate(): void;
@@ -43,5 +61,18 @@ export type DefineLoaderOpts<T> = {
     __loaderName?: string;
     cache?: LoaderCache<T>;
     params?: string[] | '*';
+    /**
+     * Per-loader timeout in milliseconds. When omitted, the handler applies
+     * its configured default (30s). Pass `false` to disable the timeout for
+     * this loader (rely solely on the request signal).
+     */
+    timeoutMs?: number | false;
+    /**
+     * Per-loader middleware and (for streaming loaders) stream observers.
+     * The element type LoaderUse<T, Streaming> structurally gates stream
+     * observers off non-streaming loaders, but a tighter compile-time gate
+     * via defineLoader overloads can be added in a follow-up if needed.
+     */
+    use?: LoaderUse<T, boolean>;
 };
 export declare function defineLoader<T>(fn: Loader<T>, opts?: DefineLoaderOpts<T>): LoaderRef<T>;

package/dist/iso/define-loader.js

@@ -42,7 +42,15 @@ function ViewRenderer({ loaderRef, props, render, }) {
     const reload = reloadCtx?.reload ?? (() => { });
     return render({ data, error, reload, ...props });
 }
+function validateTimeoutMs(value, context) {
+    if (value === undefined || value === false)
+        return;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new RangeError(`${context}: timeoutMs must be a non-negative finite number or false, got ${String(value)}`);
+    }
+}
 export function defineLoader(fn, opts) {
+    validateTimeoutMs(opts?.timeoutMs, 'defineLoader');
     const idKey = opts?.__moduleKey
         ? opts.__loaderName
             ? `${opts.__moduleKey}::${opts.__loaderName}`
@@ -80,6 +88,11 @@ export function defineLoader(fn, opts) {
         fn,
         cache: cache,
         params: opts?.params ?? [],
+        timeoutMs: opts?.timeoutMs,
+        // LoaderUse<T, boolean> structurally collapses to the same shape the
+        // partitioner accepts; the cast hides only the generic narrowing on
+        // StreamObserver's TChunk/TResult which is invariant. Identity-preserving.
+        use: (opts?.use ?? []),
         useData() {
             const ctx = useContext(LoaderDataContext);
             if (!ctx) {
@@ -93,26 +106,27 @@ export function defineLoader(fn, opts) {
         invalidate() {
             cache.invalidate();
         },
-        Boundary: null,
-        View: null,
-    };
-    const Boundary = ({ fallback, errorFallback, children, }) => {
-        return h(LoaderHost, {
+        // `Boundary` and `View` close over `ref`. The captures are by reference
+        // and only deref at call time (component render), so the cycle is safe;
+        // both are fully initialized before any consumer can invoke them.
+        Boundary: ({ fallback, errorFallback, children }) => h((LoaderHost), {
             loader: ref,
             fallback,
             errorFallback,
             children,
-        });
-    };
-    ref.Boundary = Boundary;
-    const View = (render, viewOpts) => {
-        const Wrapped = (props) => h(ref.Boundary, {
-            fallback: viewOpts?.fallback,
-            errorFallback: viewOpts?.errorFallback,
-            children: h((ViewRenderer), { loaderRef: ref, props, render }),
-        });
-        return Wrapped;
+        }),
+        View: (render, viewOpts) => {
+            const Wrapped = (props) => h(ref.Boundary, {
+                fallback: viewOpts?.fallback,
+                errorFallback: viewOpts?.errorFallback,
+                children: h((ViewRenderer), {
+                    loaderRef: ref,
+                    props,
+                    render,
+                }),
+            });
+            return Wrapped;
+        },
     };
-    ref.View = View;
     return ref;
 }

package/dist/iso/define-middleware.d.ts

@@ -0,0 +1,43 @@
+import type { Context } from 'hono';
+import type { RouteHook } from 'preact-iso';
+import type { Outcome } from './outcomes.js';
+export type Scope = 'page' | 'loader' | 'action';
+export type ServerBaseCtx = {
+    c: Context;
+    signal: AbortSignal;
+};
+export type ServerPageCtx = ServerBaseCtx & {
+    scope: 'page';
+    location: RouteHook;
+};
+export type ServerLoaderCtx = ServerBaseCtx & {
+    scope: 'loader';
+    location: RouteHook;
+    module: string;
+    loader: string;
+};
+export type ServerActionCtx = ServerBaseCtx & {
+    scope: 'action';
+    module: string;
+    action: string;
+    payload: unknown;
+};
+export type ServerCtx<S extends Scope = Scope> = S extends 'page' ? ServerPageCtx : S extends 'loader' ? ServerLoaderCtx : S extends 'action' ? ServerActionCtx : ServerPageCtx | ServerLoaderCtx | ServerActionCtx;
+export type ClientPageCtx = {
+    scope: 'page';
+    location: RouteHook;
+};
+export type Next = () => Promise<unknown>;
+export type ServerMiddleware<S extends Scope = Scope> = {
+    __kind: 'middleware';
+    runs: 'server';
+    fn: (ctx: ServerCtx<S>, next: Next) => Promise<void | Outcome>;
+};
+export type ClientMiddleware = {
+    __kind: 'middleware';
+    runs: 'client';
+    fn: (ctx: ClientPageCtx, next: Next) => Promise<void | Outcome>;
+};
+export type Middleware = ServerMiddleware | ClientMiddleware;
+export declare function defineServerMiddleware<S extends Scope = Scope>(fn: ServerMiddleware<S>['fn']): ServerMiddleware<S>;
+export declare function defineClientMiddleware(fn: ClientMiddleware['fn']): ClientMiddleware;

package/dist/iso/define-middleware.js

@@ -0,0 +1,6 @@
+export function defineServerMiddleware(fn) {
+    return { __kind: 'middleware', runs: 'server', fn };
+}
+export function defineClientMiddleware(fn) {
+    return { __kind: 'middleware', runs: 'client', fn };
+}

package/dist/iso/define-page.d.ts

@@ -1,10 +1,15 @@
 import type { ComponentType, FunctionComponent, JSX } from 'preact';
 import type { RouteHook } from 'preact-iso';
-import type { GuardFn } from './guard.js';
+import type { PageUse } from './internal/use-types.js';
 import { type WrapperProps } from './page.js';
 export type PageBindings = {
     Wrapper?: ComponentType<WrapperProps>;
     errorFallback?: JSX.Element | ((error: Error, reset: () => void) => JSX.Element);
-    guards?: GuardFn[];
+    /**
+     * Page-scope middleware and stream observers. The dispatcher partitions
+     * server vs client members by their `runs` tag, so mixed arrays of
+     * defineServerMiddleware + defineClientMiddleware work as one list.
+     */
+    use?: PageUse;
 };
 export declare function definePage(Component: ComponentType, bindings?: PageBindings): FunctionComponent<RouteHook>;

package/dist/iso/define-page.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
 import { Page } from './page.js';
 export function definePage(Component, bindings) {
-    const PageRoute = (location) => (_jsx(Page, { Wrapper: bindings?.Wrapper, errorFallback: bindings?.errorFallback, guards: bindings?.guards, location: location, children: _jsx(Component, {}) }));
+    const PageRoute = (location) => (_jsx(Page, { Wrapper: bindings?.Wrapper, errorFallback: bindings?.errorFallback, use: bindings?.use, location: location, children: _jsx(Component, {}) }));
     PageRoute.displayName = `definePage(${Component.displayName ?? Component.name ?? 'Anonymous'})`;
     return PageRoute;
 }

package/dist/iso/define-routes.d.ts

@@ -7,7 +7,7 @@ export type ViewProps = RouteHook;
 type LazyImport<T> = () => Promise<{
     default: T;
 }>;
-type LazyServerImport = () => Promise<unknown>;
+export type LazyServerImport = () => Promise<unknown>;
 export type RouteDef = {
     path: string;
     view?: LazyImport<ComponentType<ViewProps>>;
@@ -20,10 +20,33 @@ export type FlatRoute = {
     component: ComponentType<ViewProps>;
     key: string;
 };
+export type ServerRoute = {
+    /** Absolute route path the server module belongs to. */
+    path: string;
+    /** Lazy `.server.*` module loader. */
+    server: LazyServerImport;
+    /**
+     * Lazy server-module loaders for every server-bearing ancestor in the
+     * route tree, outermost first, NOT including this route's own server.
+     * Used by the server-side pageUse resolver to compose page-layer
+     * middleware along the actual tree of layouts rather than relying on
+     * URL-prefix matching (which conflates siblings that share a path
+     * prefix, e.g. `/demo/projects` and `/demo/projects/:projectId/...`).
+     */
+    ancestors: ReadonlyArray<LazyServerImport>;
+};
 export type RoutesManifest = {
     tree: ReadonlyArray<RouteDef>;
     flat: ReadonlyArray<FlatRoute>;
     serverImports: ReadonlyArray<LazyServerImport>;
+    /**
+     * Path-keyed view of every server module in the tree. Lets server-side
+     * consumers (e.g. the page-layer `use` resolver) load a per-page module
+     * by the route path that matched, without re-walking the tree. The order
+     * mirrors `serverImports`; the two arrays exist side-by-side because most
+     * existing call sites only need the lazy thunks.
+     */
+    serverRoutes: ReadonlyArray<ServerRoute>;
 };
 export declare function defineRoutes(tree: RouteDef[]): RoutesManifest;
 export type RoutesProps = {

package/dist/iso/define-routes.js

@@ -67,6 +67,39 @@ function collectServerImports(routes) {
     walk(routes);
     return out;
 }
+function collectServerRoutes(routes, parentPath = '') {
+    const out = [];
+    // `serverStack` tracks the lazy server-thunks for every server-bearing
+    // route on the path from the tree root down to (but not including) the
+    // node being emitted. Pushing on the way in / popping on the way out
+    // means each emitted ServerRoute captures its TRUE tree-walk ancestry,
+    // not whichever other patterns happen to share a URL prefix.
+    const walk = (rs, pp, serverStack) => {
+        for (const r of rs) {
+            const here = pp === '' ? r.path : pp + (r.path === '' ? '' : '/' + r.path);
+            if (r.server) {
+                // Capture the stack BEFORE pushing self -- ancestors exclude self.
+                out.push({
+                    path: here,
+                    server: r.server,
+                    ancestors: serverStack.slice(),
+                });
+            }
+            if (r.children) {
+                if (r.server) {
+                    serverStack.push(r.server);
+                    walk(r.children, here, serverStack);
+                    serverStack.pop();
+                }
+                else {
+                    walk(r.children, here, serverStack);
+                }
+            }
+        }
+    };
+    walk(routes, parentPath, []);
+    return out;
+}
 /**
  * Memoize `lazy(view)` per view-thunk identity. When the same `view` thunk is
  * referenced by multiple route registrations (e.g. `/docs` and `/docs/*`),
@@ -240,6 +273,7 @@ export function defineRoutes(tree) {
         tree,
         flat: flattenTree(tree, viewCache, keyCache),
         serverImports: collectServerImports(tree),
+        serverRoutes: collectServerRoutes(tree),
     };
 }
 export const Routes = ({ routes, onRouteChange, }) => {

package/dist/iso/define-stream-observer.d.ts

@@ -0,0 +1,20 @@
+import type { ServerLoaderCtx, ServerActionCtx } from './define-middleware.js';
+export type ServerStreamCtx = ServerLoaderCtx | ServerActionCtx;
+export type StreamObserver<TChunk = unknown, TResult = void> = {
+    __kind: 'observer';
+    onStart?: (ctx: ServerStreamCtx) => void;
+    onChunk?: (ctx: ServerStreamCtx, chunk: TChunk, index: number) => void;
+    onEnd?: (ctx: ServerStreamCtx, info: {
+        chunks: number;
+        result: TResult;
+    }) => void;
+    onError?: (ctx: ServerStreamCtx, err: unknown, info: {
+        chunks: number;
+    }) => void;
+    onAbort?: (ctx: ServerStreamCtx, info: {
+        chunks: number;
+    }) => void;
+};
+type Spec<TChunk, TResult> = Omit<StreamObserver<TChunk, TResult>, '__kind'>;
+export declare function defineStreamObserver<TChunk = unknown, TResult = void>(spec: Spec<TChunk, TResult>): StreamObserver<TChunk, TResult>;
+export {};

package/dist/iso/define-stream-observer.js

@@ -0,0 +1,3 @@
+export function defineStreamObserver(spec) {
+    return { __kind: 'observer', ...spec };
+}

package/dist/iso/form.d.ts

@@ -1,7 +1,16 @@
 import type { JSX, ComponentChildren } from 'preact';
-export type FormProps<TPayload extends Record<string, unknown>> = Omit<JSX.HTMLAttributes<HTMLFormElement>, 'onSubmit'> & {
-    mutate: (payload: TPayload) => Promise<unknown> | unknown;
-    pending?: boolean;
+import type { ActionStub } from './action.js';
+import { type UseOptimisticActionResult } from './optimistic-action.js';
+/**
+ * The `action` prop accepts either a plain action stub or the branded value
+ * returned by `useOptimisticAction`. The union lets `<Form>` discover the
+ * optimistic apply via `OPTIMISTIC_BRAND in action` narrowing without
+ * casting away the type.
+ */
+type FormActionInput<TPayload, TResult> = ActionStub<TPayload, TResult, never> | UseOptimisticActionResult<TPayload, TResult, unknown>;
+export type FormProps<TPayload, TResult> = Omit<JSX.HTMLAttributes<HTMLFormElement>, 'action' | 'method' | 'onSubmit' | 'enctype'> & {
+    action: FormActionInput<TPayload, TResult>;
     children?: ComponentChildren;
 };
-export declare function Form<TPayload extends Record<string, unknown>>({ mutate, pending, children, ...rest }: FormProps<TPayload>): JSX.Element;
+export declare function Form<TPayload, TResult>({ action, children, ...rest }: FormProps<TPayload, TResult>): JSX.Element;
+export {};

package/dist/iso/form.js

@@ -1,40 +1,122 @@
-import { jsx as _jsx } from "preact/jsx-runtime";
-/**
- * Collect a FormData into a plain payload object.
- *
- * Repeated field names (checkboxes sharing a name, multi-select, multiple
- * `<input type="file" multiple>` entries) collect into an array. The old
- * `Object.fromEntries(fd)` produced the LAST value only, which was silent
- * data loss: a four-checkbox group would submit one value with no warning.
- *
- * Single-value fields stay scalar. Files survive as `File` instances.
- *
- * Consumers should type their `defineAction<TPayload, ...>` to match:
- * `tags: string[]`, `photos: File[]`, etc. for fields that may have multiple
- * values; scalar types for fields that won't.
- */
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useState, useCallback, useMemo } from 'preact/hooks';
+import { OPTIMISTIC_BRAND, } from './optimistic-action.js';
+import { beginSubmit, endSubmit } from './internal/form-submit-store.js';
+import { setLastActionResult } from './internal/action-result-store.js';
+import { assignSafeRedirect } from './internal/safe-redirect.js';
+function hasOptimisticBrand(action) {
+    return OPTIMISTIC_BRAND in action;
+}
 function collectFormData(fd) {
-    const payload = {};
+    const out = {};
     for (const [key, value] of fd.entries()) {
-        if (key in payload) {
-            const existing = payload[key];
-            payload[key] = Array.isArray(existing)
-                ? [...existing, value]
-                : [existing, value];
-        }
-        else {
-            payload[key] = value;
-        }
+        if (key === '__module' || key === '__action')
+            continue;
+        const existing = out[key];
+        out[key] =
+            existing === undefined
+                ? value
+                : Array.isArray(existing)
+                    ? [...existing, value]
+                    : [existing, value];
     }
-    return payload;
+    return out;
 }
-export function Form({ mutate, pending, children, ...rest }) {
-    const handleSubmit = (e) => {
+export function Form({ action, children, ...rest }) {
+    const [pending, setPending] = useState(false);
+    const moduleKey = action.__module;
+    const actionName = action.__action;
+    const optimistic = useMemo(() => (hasOptimisticBrand(action) ? action[OPTIMISTIC_BRAND] : undefined), [action]);
+    const handleSubmit = useCallback(async (e) => {
         e.preventDefault();
         const formEl = e.currentTarget;
-        const formData = new FormData(formEl);
-        const payload = collectFormData(formData);
-        void mutate(payload);
-    };
-    return (_jsx("form", { ...rest, onSubmit: handleSubmit, children: _jsx("fieldset", { disabled: pending, class: "hp-form-fieldset", children: children }) }));
+        const target = typeof window !== 'undefined'
+            ? window.location.pathname + window.location.search
+            : '/';
+        const fd = new FormData(formEl);
+        const payload = collectFormData(fd);
+        let handle;
+        if (optimistic)
+            handle = optimistic.addOptimistic(payload);
+        setPending(true);
+        beginSubmit(moduleKey, actionName);
+        try {
+            const res = await fetch(target, {
+                method: 'POST',
+                body: fd,
+                headers: { Accept: 'application/json' },
+            });
+            const env = (await res.json().catch(() => null));
+            if (!env) {
+                handle?.revert();
+                if (typeof window !== 'undefined')
+                    window.location.reload();
+                return;
+            }
+            if (env.__outcome === 'redirect' && typeof env.to === 'string') {
+                const navigated = assignSafeRedirect(env.to);
+                if (navigated) {
+                    handle?.settle();
+                    return;
+                }
+                // Cross-origin: revert optimistic, surface as error result so useActionResult sees it.
+                handle?.revert();
+                setLastActionResult(moduleKey, actionName, {
+                    kind: 'error',
+                    message: `Refused cross-origin redirect to ${env.to}`,
+                    submittedPayload: payload,
+                });
+                return;
+            }
+            if (env.__outcome === 'success') {
+                handle?.settle();
+                setLastActionResult(moduleKey, actionName, {
+                    kind: 'success',
+                    data: env.data,
+                    submittedPayload: payload,
+                });
+                return;
+            }
+            if (env.__outcome === 'deny') {
+                handle?.revert();
+                setLastActionResult(moduleKey, actionName, {
+                    kind: 'deny',
+                    status: env.status ?? res.status,
+                    message: env.message ?? `Request denied (${env.status ?? res.status})`,
+                    data: env.data,
+                    submittedPayload: payload,
+                });
+                return;
+            }
+            if (env.__outcome === 'error') {
+                handle?.revert();
+                setLastActionResult(moduleKey, actionName, {
+                    kind: 'error',
+                    message: env.message ?? 'Action failed',
+                    submittedPayload: payload,
+                });
+                return;
+            }
+            // Unknown outcome (e.g. 'timeout'): treat as error.
+            handle?.revert();
+            setLastActionResult(moduleKey, actionName, {
+                kind: 'error',
+                message: env.message ?? `Unexpected outcome: ${env.__outcome ?? 'unknown'}`,
+                submittedPayload: payload,
+            });
+        }
+        catch (err) {
+            handle?.revert();
+            setLastActionResult(moduleKey, actionName, {
+                kind: 'error',
+                message: err instanceof Error ? err.message : String(err),
+                submittedPayload: payload,
+            });
+        }
+        finally {
+            setPending(false);
+            endSubmit(moduleKey, actionName);
+        }
+    }, [moduleKey, actionName, optimistic]);
+    return (_jsxs("form", { ...rest, method: "post", enctype: "multipart/form-data", onSubmit: handleSubmit, children: [_jsx("input", { type: "hidden", name: "__module", value: moduleKey }), _jsx("input", { type: "hidden", name: "__action", value: actionName }), _jsx("fieldset", { disabled: pending, class: "hp-form-fieldset", children: children })] }));
 }

package/dist/iso/index.d.ts

@@ -4,23 +4,31 @@ export { definePage } from './define-page.js';
 export type { PageBindings } from './define-page.js';
 export { Route, Router, lazy, useLocation, useRoute } from 'preact-iso';
 export { defineRoutes, Routes } from './define-routes.js';
-export type { RouteDef, RoutesManifest, FlatRoute, LayoutProps, ViewProps, } from './define-routes.js';
+export type { RouteDef, RoutesManifest, FlatRoute, ServerRoute, LayoutProps, ViewProps, } from './define-routes.js';
 export { defineLoader } from './define-loader.js';
 export type { LoaderRef, LoaderCtx, Loader as LoaderFn, } from './define-loader.js';
-export { defineAction, useAction } from './action.js';
-export type { ActionStub, UseActionOptions, UseActionResult, MutateResult, ActionGuardContext, ActionGuardFn, } from './action.js';
-export { ActionGuardError, defineActionGuard } from './action.js';
+export { defineAction, useAction, TimeoutError } from './action.js';
+export type { ActionStub, UseActionOptions, UseActionResult, MutateResult, } from './action.js';
 export type { ContentfulStatusCode } from 'hono/utils/http-status';
 export { useReload } from './reload-context.js';
 export { useOptimistic } from './optimistic.js';
-export type { OptimisticHandle } from './optimistic.js';
+export type { OptimisticHandle, UseOptimisticOptions } from './optimistic.js';
 export { useOptimisticAction } from './optimistic-action.js';
 export type { UseOptimisticActionOptions, UseOptimisticActionResult, } from './optimistic-action.js';
 export { Form } from './form.js';
+export { useActionResult, type ActionResult } from './use-action-result.js';
+export { ActionResultContext, type ActionResultContextValue, } from './action-result-context.js';
+export { useFormStatus, type FormStatus } from './use-form-status.js';
 export { createCache } from './cache.js';
 export type { LoaderCache } from './cache.js';
-export { defineServerGuard, defineClientGuard, GuardRedirect, runServerGuards, runClientGuards, } from './guard.js';
-export type { GuardFn, ServerGuardFn, ClientGuardFn, GuardResult, ServerGuardContext, ClientGuardContext, GuardRunsOn, } from './guard.js';
+export { defineServerMiddleware, defineClientMiddleware, } from './define-middleware.js';
+export type { ServerMiddleware, ClientMiddleware, Middleware, ServerBaseCtx, ServerPageCtx, ServerLoaderCtx, ServerActionCtx, ServerCtx, ClientPageCtx, Scope, Next, } from './define-middleware.js';
+export { defineStreamObserver } from './define-stream-observer.js';
+export type { StreamObserver, ServerStreamCtx, } from './define-stream-observer.js';
+export { defineApp } from './define-app.js';
+export type { AppConfig, AppUseElement } from './define-app.js';
+export { redirect, deny, timeoutOutcome, isOutcome, isRedirect, isDeny, isRender, isTimeout, } from './outcomes.js';
+export type { Outcome, RedirectOutcome, DenyOutcome, RenderOutcome, TimeoutOutcome, RedirectStatusCode, ErrorStatusCode, } from './outcomes.js';
 export { prefetch } from './prefetch.js';
 export { isBrowser, env } from './is-browser.js';
 export { useRouteChange } from './route-change.js';

package/dist/iso/index.js

@@ -8,18 +8,23 @@ export { Route, Router, lazy, useLocation, useRoute } from 'preact-iso';
 export { defineRoutes, Routes } from './define-routes.js';
 // Server bindings.
 export { defineLoader } from './define-loader.js';
-export { defineAction, useAction } from './action.js';
-export { ActionGuardError, defineActionGuard } from './action.js';
+export { defineAction, useAction, TimeoutError } from './action.js';
 // Hooks.
 export { useReload } from './reload-context.js';
 export { useOptimistic } from './optimistic.js';
 export { useOptimisticAction } from './optimistic-action.js';
 // Forms.
 export { Form } from './form.js';
+export { useActionResult } from './use-action-result.js';
+export { ActionResultContext, } from './action-result-context.js';
+export { useFormStatus } from './use-form-status.js';
 // Cache + invalidation.
 export { createCache } from './cache.js';
-// Guards.
-export { defineServerGuard, defineClientGuard, GuardRedirect, runServerGuards, runClientGuards, } from './guard.js';
+// Middleware + outcomes (the new system).
+export { defineServerMiddleware, defineClientMiddleware, } from './define-middleware.js';
+export { defineStreamObserver } from './define-stream-observer.js';
+export { defineApp } from './define-app.js';
+export { redirect, deny, timeoutOutcome, isOutcome, isRedirect, isDeny, isRender, isTimeout, } from './outcomes.js';
 // Utilities.
 export { prefetch } from './prefetch.js';
 export { isBrowser, env } from './is-browser.js';

package/dist/iso/internal/action-envelope.d.ts

@@ -0,0 +1,37 @@
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+import type { Outcome } from '../outcomes.js';
+export type ActionEnvelope = {
+    __outcome: 'success';
+    data: unknown;
+} | {
+    __outcome: 'redirect';
+    to: string;
+    status: number;
+} | {
+    __outcome: 'deny';
+    status: number;
+    message: string;
+    data?: unknown;
+} | {
+    __outcome: 'error';
+    message: string;
+} | {
+    __outcome: 'timeout';
+    timeoutMs: number;
+};
+export type ActionResolution = {
+    kind: 'success';
+    data: unknown;
+} | {
+    kind: 'outcome';
+    outcome: Outcome;
+} | {
+    kind: 'error';
+    message: string;
+};
+export type SerializedEnvelope = {
+    body: ActionEnvelope;
+    status: ContentfulStatusCode;
+    headers: Record<string, string> | undefined;
+};
+export declare function serializeActionOutcome(resolution: ActionResolution): SerializedEnvelope;

package/dist/iso/internal/action-envelope.js

@@ -0,0 +1,47 @@
+export function serializeActionOutcome(resolution) {
+    if (resolution.kind === 'success') {
+        return {
+            body: { __outcome: 'success', data: resolution.data },
+            status: 200,
+            headers: undefined,
+        };
+    }
+    if (resolution.kind === 'error') {
+        return {
+            body: { __outcome: 'error', message: resolution.message },
+            status: 500,
+            headers: undefined,
+        };
+    }
+    const { outcome } = resolution;
+    if (outcome.__outcome === 'redirect') {
+        return {
+            body: { __outcome: 'redirect', to: outcome.to, status: outcome.status },
+            status: 200,
+            headers: outcome.headers,
+        };
+    }
+    if (outcome.__outcome === 'deny') {
+        const body = {
+            __outcome: 'deny',
+            status: outcome.status,
+            message: outcome.message,
+        };
+        if (outcome.data !== undefined)
+            body.data = outcome.data;
+        return { body, status: outcome.status, headers: outcome.headers };
+    }
+    if (outcome.__outcome === 'timeout') {
+        return {
+            body: { __outcome: 'timeout', timeoutMs: outcome.timeoutMs },
+            status: 504,
+            headers: undefined,
+        };
+    }
+    // 'render' outcome is page-scope only; should never reach an action.
+    return {
+        body: { __outcome: 'error', message: 'render outcome is page-scope only' },
+        status: 500,
+        headers: undefined,
+    };
+}