@absolutejs/absolute 0.20.0-beta.169 → 0.20.0-beta.170

package/dist/src/core/formActions.d.ts

@@ -0,0 +1,249 @@
+import { type UnwrapSchema } from 'elysia';
+import type { TObject } from 'typebox';
+import type { ActionErrorState, ActionFieldErrors, ActionResult, ActionData, ActionSuccessState, AnyFormAction, FormActionDefinition } from '../../types/formAction';
+/** What `fail(...)` returns; the action answers with an error state. */
+export declare class ActionFailure<Fields extends string = string> {
+    readonly errors: ActionFieldErrors<Fields>;
+    readonly message: string | undefined;
+    constructor(errors: ActionFieldErrors<Fields>, message?: string);
+}
+export type ActionCsrfOptions = {
+    /** Origins (scheme://host[:port]) allowed to post besides the page's
+     *  own, e.g. a separate front-end domain. */
+    trustedOrigins?: readonly string[];
+};
+/** What a handler returning `Result` hands the page on success. */
+export type ActionDataOf<Result, Fields extends string = string> = Exclude<Awaited<Result>, ActionFailure<Fields> | Response>;
+export type ActionHandlerContext<Body, Fields extends string> = {
+    body: Body;
+    /** The full Elysia context (derived values such as the signed-in user
+     *  live here). Untyped in Phase 1. */
+    context: Record<string, unknown>;
+    /** Answer with field errors (and an optional form-level message)
+     *  instead of a result. */
+    fail: (errors: ActionFieldErrors<Fields>, message?: string) => ActionFailure<Fields>;
+    request: Request;
+    set: {
+        headers: Record<string, unknown>;
+        status?: unknown;
+    };
+};
+export type DefineActionOptions<Schema extends TObject, Result, Fields extends string = Extract<keyof UnwrapSchema<Schema>, string>> = {
+    /** The form's fields (an Elysia `t.Object`). Field names are the keys;
+     *  add `error: 'message'` to a property for a friendlier message than
+     *  the validator's. */
+    body: Schema;
+    /** Runs after validation, before the handler; return a response (e.g.
+     *  `status(401)`) to stop. Use it for auth checks. */
+    beforeHandle?: (context: {
+        request: Request;
+        set: {
+            headers: Record<string, unknown>;
+            status?: unknown;
+        };
+    }) => unknown;
+    /** Cross-origin protection: requests whose `Sec-Fetch-Site` / `Origin`
+     *  say another site sent them get 403. Default on; `false` turns it
+     *  off (for an API meant to be called from other sites). */
+    csrf?: ActionCsrfOptions | false;
+    handler: (context: ActionHandlerContext<UnwrapSchema<Schema>, Fields>) => Result | Promise<Result>;
+    /** HTMX requests only: the HTML fragment to swap in for a result
+     *  (answered with 200, which HTMX swaps by default). Return undefined
+     *  to fall back to the no-JavaScript behaviour (`HX-Redirect`). The
+     *  result's type comes from `handler` only. */
+    htmx?: (result: ActionResult<NoInfer<ActionDataOf<Result, Fields>>, Fields>, request: Request) => string | undefined | Promise<string | undefined>;
+    /** Bytes; requests that declare a larger body get 413 before it is
+     *  read. Default 10 MiB. */
+    maxBodySize?: number;
+    /** Echo what the user typed back to the page after a failed
+     *  submission without JavaScript (files and secret-looking fields are
+     *  never echoed). Default true. */
+    preserveValues?: boolean;
+    /** Where to send the browser after success. Default: back to the page
+     *  the form was on. */
+    redirect?: string | ((data: NoInfer<ActionDataOf<Result, Fields>>) => string);
+};
+export declare const isCrossOriginRequest: (request: Request, trustedOrigins?: readonly string[]) => boolean;
+/** Defines a form action: a POST route at `path` that validates its body
+ *  against `options.body` and works with or without JavaScript. Mount it
+ *  with `app.use(action)`. */
+export declare const defineAction: <const Path extends string, const Schema extends TObject, Result>(path: Path, options: DefineActionOptions<Schema, Result>) => import("elysia/types").AddRoute<"", "local", import("elysia").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia").DefaultMetadata, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral, "post", Path, import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{
+    beforeHandle: ((context: {
+        request: Request;
+        set: {
+            headers: Record<string, unknown>;
+            status?: unknown;
+        };
+    }) => unknown) | undefined;
+    body: Schema;
+    error: unknown;
+    parse: unknown;
+    transform: unknown;
+}, {}, import("elysia/types").JoinPath<"", Path>>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, (context: {
+    body: import("elysia/types").IntersectIfObject<import("elysia/types").UnwrapBodySchema<Schema, {}, "output">, unknown> extends infer T ? T extends import("elysia/types").IntersectIfObject<import("elysia/types").UnwrapBodySchema<Schema, {}, "output">, unknown> ? T extends object ? { [K in keyof T]: T[K]; } : T : never : never;
+    query: Record<string, string | undefined>;
+    params: undefined extends import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown> ? Record<string, string> : import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown> extends infer T_1 ? T_1 extends import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown> ? T_1 extends object ? { [K_1 in keyof T_1]: T_1[K_1]; } : T_1 : never : never;
+    headers: Record<string, string | undefined>;
+    cookie: Record<string, import("elysia").Cookie<unknown>>;
+    server: import("elysia").Server | null;
+    redirect: import("elysia").redirect;
+    set: {
+        headers: import("elysia").HTTPHeaders;
+        status?: number | keyof import("elysia").StatusMap;
+        cookie?: Record<string, import("elysia").BaseCookie>;
+        redirect?: never;
+    };
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T_2 = import("elysia").StatusResponse<Code>>(code: Code, response?: T_2) => import("elysia").ElysiaStatus<Code, T_2, import("elysia").NumericStatus<Code>>;
+    problem: typeof import("elysia").problem;
+    defer: (fn: import("elysia/types").AfterResponseHandler<NoInfer<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{
+        beforeHandle: ((context: {
+            request: Request;
+            set: {
+                headers: Record<string, unknown>;
+                status?: unknown;
+            };
+        }) => unknown) | undefined;
+        body: Schema;
+        error: unknown;
+        parse: unknown;
+        transform: unknown;
+    }, {}, import("elysia/types").JoinPath<"", Path>>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>>, NoInfer<import("elysia").DefaultSingleton & {
+        derive: {};
+    }>>) => import("elysia/types").MaybePromise<void>;
+    readonly path: string;
+    route?: string | undefined;
+    rid?: string | undefined;
+    request: Request;
+    store: {};
+}) => Promise<Response>, {
+    beforeHandle: ((context: {
+        request: Request;
+        set: {
+            headers: Record<string, unknown>;
+            status?: unknown;
+        };
+    }) => unknown) | undefined;
+    body: Schema;
+    error: ({ error, request }: {
+        body: import("elysia/types").IntersectIfObject<import("elysia/types").UnwrapBodySchema<Schema, {}, "output">, unknown>;
+        query: Record<string, string | undefined>;
+        params: undefined extends import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown> ? {
+            [x: string]: string;
+        } : import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>;
+        headers: Record<string, string | undefined>;
+        cookie: Record<string, import("elysia").Cookie<string | undefined>>;
+        server: import("elysia").Server | null;
+        redirect: import("elysia").redirect;
+        set: {
+            headers: import("elysia").HTTPHeaders;
+            status?: number | keyof import("elysia").StatusMap;
+            cookie?: Record<string, import("elysia").BaseCookie>;
+            redirect?: never;
+        };
+        status: <const Code extends number | keyof import("elysia").StatusMap, const T = import("elysia").StatusResponse<Code>>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, import("elysia").NumericStatus<Code>>;
+        problem: typeof import("elysia").problem;
+        defer: (fn: import("elysia/types").AfterResponseHandler<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{
+            beforeHandle: ((context: {
+                request: Request;
+                set: {
+                    headers: Record<string, unknown>;
+                    status?: unknown;
+                };
+            }) => unknown) | undefined;
+            body: Schema;
+            error: unknown;
+            parse: unknown;
+            transform: unknown;
+        }, {}, import("elysia/types").JoinPath<"", Path>>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {
+            store: {};
+            decorator: {};
+            derive: {};
+        }>) => import("elysia/types").MaybePromise<void>;
+        readonly path: string;
+        route?: string | undefined;
+        rid?: string | undefined;
+        request: Request;
+        store: {};
+    } & {
+        error: T_1[number]["error"] | unknown;
+    }) => Response | Promise<Response> | undefined;
+    parse: ({ request }: Omit<{
+        body: unknown;
+        query: Record<string, string | undefined>;
+        params: undefined extends { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; } ? Record<string, string> : { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; } extends infer T_1 ? T_1 extends { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; } ? T_1 extends object ? { [K_1 in keyof T_1]: T_1[K_1]; } : T_1 : never : never;
+        headers: Record<string, string | undefined>;
+        cookie: Record<string, import("elysia").Cookie<unknown>>;
+        server: import("elysia").Server | null;
+        redirect: import("elysia").redirect;
+        set: {
+            headers: import("elysia").HTTPHeaders;
+            status?: number | keyof import("elysia").StatusMap;
+            cookie?: Record<string, import("elysia").BaseCookie>;
+            redirect?: never;
+        };
+        status: <const Code extends number | keyof import("elysia").StatusMap, const T = import("elysia").StatusResponse<Code>>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, import("elysia").NumericStatus<Code>>;
+        problem: typeof import("elysia").problem;
+        defer: (fn: import("elysia/types").AfterResponseHandler<{
+            params: { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; };
+            query: undefined;
+            response: unknown;
+        }, {
+            decorator: {};
+            store: {};
+            derive: {};
+        } & {
+            decorator: {
+                contentType: string;
+            };
+        }>) => import("elysia/types").MaybePromise<void>;
+        readonly path: string;
+        route?: string | undefined;
+        rid?: string | undefined;
+        request: Request;
+        store: {};
+        contentType: string;
+    }, "cookie"> & {
+        cookie: undefined;
+    }) => {} | undefined;
+    transform: ({ body, request }: Omit<{
+        body: unknown;
+        query: Record<string, string | undefined>;
+        params: undefined extends { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; } ? Record<string, string> : { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; } extends infer T_1 ? T_1 extends { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; } ? T_1 extends object ? { [K_1 in keyof T_1]: T_1[K_1]; } : T_1 : never : never;
+        headers: Record<string, string | undefined>;
+        cookie: Record<string, import("elysia").Cookie<unknown>>;
+        server: import("elysia").Server | null;
+        redirect: import("elysia").redirect;
+        set: {
+            headers: import("elysia").HTTPHeaders;
+            status?: number | keyof import("elysia").StatusMap;
+            cookie?: Record<string, import("elysia").BaseCookie>;
+            redirect?: never;
+        };
+        status: <const Code extends number | keyof import("elysia").StatusMap, const T = import("elysia").StatusResponse<Code>>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, import("elysia").NumericStatus<Code>>;
+        problem: typeof import("elysia").problem;
+        defer: (fn: import("elysia/types").AfterResponseHandler<{
+            params: { [K in keyof import("elysia/types").IntersectIfObject<import("elysia/types").ResolvePath<import("elysia/types").JoinPath<"", Path>>, unknown>]: string; };
+            query: undefined;
+            response: unknown;
+        }, {
+            decorator: {};
+            store: {};
+            derive: {};
+        }>) => import("elysia/types").MaybePromise<void>;
+        readonly path: string;
+        route?: string | undefined;
+        rid?: string | undefined;
+        request: Request;
+        store: {};
+    }, "cookie"> & {
+        cookie: undefined;
+    }) => void;
+}> & FormActionDefinition<Path, UnwrapSchema<Schema>, Exclude<Awaited<Result>, Response | ActionFailure<Extract<keyof UnwrapSchema<Schema>, string>>>>;
+/** The result the last submission of `action` left for this page, when
+ *  the browser posted without JavaScript and was redirected here. Read it
+ *  in the page's route and pass it to the page as a prop. Undefined when
+ *  there is none. */
+export declare const getActionState: <Action extends AnyFormAction>(action: Action | Action["actionPath"], request?: Request | undefined) => ActionErrorState<string> | ActionSuccessState<ActionData<Action>> | undefined;

package/dist/src/core/index.d.ts

@@ -1,4 +1,5 @@
 export * from './lookup';
+export { fileRoutes } from './fileRoutes';
 export * from './islands';
 export * from './pageHandlers';
 export * from './prepare';
@@ -6,4 +7,8 @@ export * from './requestContext';
 export * from './renderIslandMarkup';
 export * from './responseEnhancers';
 export * from './wrapPageHandlerWithStreamingSlots';
+export * from './formActions';
+export { formActionRuntime } from './formActionFlash';
 export { onHotDispose } from '../dev/hotResources';
+export { getCspNonce } from './cspNonce';
+export { onVital, type VitalHandler, type VitalReport, type VitalName } from './vitals';

package/dist/src/core/partialPrerender.d.ts

@@ -0,0 +1,28 @@
+import type { StreamingSlot } from '../utils/streamingSlots';
+/** Response header listing a captured shell's dynamic slot ids. */
+export declare const PARTIAL_HOLES_HEADER = "X-Absolute-Partial-Holes";
+/** Request header asking a page render for its static shell. */
+export declare const PARTIAL_SHELL_HEADER = "X-Absolute-Partial-Shell";
+type HolesSink = {
+    slots: StreamingSlot[] | undefined;
+};
+/** The hole sink of the request being rendered, when it's a hole
+ *  collection render. */
+export declare const activePartialHolesSink: () => HolesSink | undefined;
+/** Runs `render` (a request through the app) and returns the dynamic
+ *  slots the page registered. `slots` is undefined when the request never
+ *  reached a page that collects streaming slots. */
+export declare const collectPartialHoles: (render: () => Promise<Response> | Response) => Promise<{
+    response: Response;
+    slots: StreamingSlot[] | undefined;
+}>;
+export declare const decodePartialHoles: (value: string | null | undefined) => string[];
+export declare const encodePartialHoles: (ids: string[]) => string;
+export declare const isDynamicStreamingSlot: (slot: StreamingSlot) => boolean;
+export declare const isPartialShellCapture: (request: Request | undefined) => boolean;
+/** Dynamic slot ids a shell was captured with; none for a fully
+ *  pre-rendered page. */
+export declare const readPartialHoles: (htmlPath: string) => string[];
+/** Stores (or clears) the holes a shell render reported, returning them. */
+export declare const writePartialHoles: (htmlPath: string, response: Response) => Promise<string[]>;
+export {};

package/dist/src/core/partialPrerenderServe.d.ts

@@ -0,0 +1,24 @@
+type AppHandle = (request: Request) => Promise<Response> | Response;
+export type ServePartialPrerenderInput = {
+    /** The route's pre-rendered shell. */
+    filePath: string;
+    /** The app's request handler, used to render the route's holes. */
+    handle: AppHandle;
+    /** Dynamic slot ids the shell was captured with. */
+    holes: string[];
+    /** Header that makes the app skip the pre-render cache. */
+    bypassHeader: string;
+    request: Request;
+    /** This request's CSP nonce and security headers under secureHeaders(). */
+    nonce?: string;
+    securityHeaders?: Record<string, string>;
+};
+/** The response for a partially pre-rendered page: the cached shell at
+ *  once, its dynamic holes streamed in as they resolve. Returns the headers
+ *  to drop when the shell can't be served under the CSP (see
+ *  servePrerenderedPage). */
+export declare const servePartialPrerender: (input: ServePartialPrerenderInput) => Promise<{
+    dropHeaders: string[];
+    response: Response;
+}>;
+export {};

package/dist/src/core/precompressed.d.ts

@@ -10,10 +10,20 @@ export declare const acceptedEncodings: (header: string | null) => ({
 /** The cache policy for a static file: forever for a content-hashed name,
  *  revalidate for anything else. */
 export declare const assetCacheControl: (pathname: string) => "public, max-age=31536000, immutable" | "public, max-age=0, must-revalidate";
+/** Applies `assetCacheControl` to static-file responses. @elysia/static
+ *  answers a plain GET with the file itself and its blanket policy on
+ *  `set.headers`, and a precompressed or HEAD answer with a `Response`;
+ *  both get the policy replaced (not appended). Only paths with an
+ *  extension are touched, and a non-Response value only when a policy was
+ *  already set, so pages and APIs keep their own headers. */
+export declare const createAssetCachePlugin: () => import("elysia/types").GlobalHookReturn<"", "local", import("elysia").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia").DefaultMetadata, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral, {}>;
 /** Serves the precompressed copy of a static file to a browser that accepts
  *  it. Files without copies, and browsers that accept neither, fall through
  *  to the regular static handler. */
-export declare const createPrecompressedPlugin: (buildDir: string) => Promise<Elysia<"", "local", import("elysia").DefaultSingleton, {
+export declare const createPrecompressedPlugin: (buildDir: string, ignorePatterns?: readonly (string | RegExp)[]) => Promise<Elysia<"", "local", import("elysia").DefaultSingleton, {
     typebox: {};
     error: [];
 }, import("elysia").DefaultMetadata, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral>>;

package/dist/src/core/prerenderNonce.d.ts

@@ -0,0 +1,9 @@
+export declare const renderedNonce: (response: Response) => string | undefined;
+export declare const writeRenderedNonce: (htmlPath: string, nonce: string | undefined) => Promise<void>;
+/** The response for a cached page, given this request's nonce and security
+ *  headers. Returns the headers to drop when the page can't be served
+ *  under the policy. */
+export declare const servePrerenderedPage: (htmlPath: string, nonce: string, securityHeaders: Record<string, string>) => Promise<{
+    dropHeaders: string[];
+    response: Response;
+}>;

package/dist/src/core/productionRuntime.d.ts

@@ -1,7 +1,9 @@
 import type { BuildConfig } from '../../types/build';
 export declare const PRODUCTION_RUNTIME_FILE = "absolute-runtime.json";
-declare const RUNTIME_KEYS: readonly ["angularDirectory", "assetsDirectory", "astroDirectory", "emberDirectory", "htmlDirectory", "htmxDirectory", "images", "islands", "mobile", "openapi", "publicDirectory", "reactDirectory", "static", "svelteDirectory", "telemetry", "vueDirectory"];
-export type ProductionRuntimeConfig = Pick<BuildConfig, (typeof RUNTIME_KEYS)[number]>;
+declare const RUNTIME_KEYS: readonly ["angularDirectory", "assetsDirectory", "astroDirectory", "emberDirectory", "htmlDirectory", "htmxDirectory", "images", "islands", "mobile", "openapi", "publicDirectory", "reactDirectory", "static", "svelteDirectory", "telemetry", "vitals", "vueDirectory"];
+export type ProductionRuntimeConfig = Pick<BuildConfig, (typeof RUNTIME_KEYS)[number]> & {
+    angular?: Pick<NonNullable<BuildConfig['angular']>, 'changeDetection'>;
+};
 export declare const productionRuntimeConfigOf: (config: BuildConfig) => ProductionRuntimeConfig;
 export declare const writeProductionRuntime: (config: BuildConfig, buildDirectory: string) => void;
 /** The build's runtime config, or null when this build has none (built by

package/dist/src/core/serverOnlyStaticFiles.d.ts

@@ -0,0 +1,8 @@
+/** Written by the build: every file the server pass produced, relative to
+ *  the build directory. */
+export declare const SERVER_OUTPUTS_FILE = "server-outputs.json";
+/** Static-plugin ignore patterns for a production build directory.
+ *  `serverBundle` is the running server's entry file (`Bun.main` under
+ *  `absolute start`); when it lives inside the build directory, it and its
+ *  compressed copies are excluded too. */
+export declare const productionStaticIgnorePatterns: (buildDir: string, serverBundle: string) => (string | RegExp)[];

package/dist/src/core/staticHtmlNonce.d.ts

@@ -0,0 +1,2 @@
+export declare const nonceStaticHtml: (html: string, nonce?: string | undefined) => Promise<string>;
+export declare const withHtmxStyleNonce: (html: string, nonce?: string | undefined) => Promise<string>;

package/dist/src/core/vitals.d.ts

@@ -0,0 +1,108 @@
+export type VitalName = 'CLS' | 'FCP' | 'INP' | 'LCP' | 'TTFB';
+export type VitalReport = {
+    delta?: number;
+    /** Unique per metric instance and page load (web-vitals' `id`). */
+    id: string;
+    name: VitalName;
+    navigationType?: string;
+    rating?: 'good' | 'needs-improvement' | 'poor';
+    /** The page's path when it loaded. */
+    route: string;
+    value: number;
+};
+export type VitalHandler = (report: VitalReport, request: Request) => void | Promise<void>;
+/** Receives every web vital the built-in endpoint accepts. Returns a
+ *  function that removes the handler. */
+export declare const onVital: (handler: VitalHandler) => () => void;
+export declare const vitalsBatchSchema: import("typebox").TObject<{
+    metrics: import("typebox").TArray<import("typebox").TObject<{
+        delta: import("typebox").TOptional<import("typebox").TNumber>;
+        id: import("typebox").TString;
+        name: import("typebox").TUnion<[import("typebox").TLiteral<"CLS">, import("typebox").TLiteral<"FCP">, import("typebox").TLiteral<"INP">, import("typebox").TLiteral<"LCP">, import("typebox").TLiteral<"TTFB">]>;
+        navigationType: import("typebox").TOptional<import("typebox").TString>;
+        rating: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"good">, import("typebox").TLiteral<"needs-improvement">, import("typebox").TLiteral<"poor">]>>;
+        value: import("typebox").TNumber;
+    }>>;
+    navigationType: import("typebox").TOptional<import("typebox").TString>;
+    route: import("typebox").TString;
+}>;
+/** POST `path`: validates a batch and passes each metric to the `onVital`
+ *  handlers. Answers 204; a handler that throws is logged, not surfaced. */
+export declare const createVitalsPlugin: (path: string) => import("elysia/types").AddRoute<"", "local", import("elysia").DefaultSingleton, {
+    typebox: {};
+    error: [];
+}, import("elysia").DefaultMetadata, {}, import("elysia").DefaultEphemeral, import("elysia").DefaultEphemeral, "post", string, import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{
+    body: import("typebox").TObject<{
+        metrics: import("typebox").TArray<import("typebox").TObject<{
+            delta: import("typebox").TOptional<import("typebox").TNumber>;
+            id: import("typebox").TString;
+            name: import("typebox").TUnion<[import("typebox").TLiteral<"CLS">, import("typebox").TLiteral<"FCP">, import("typebox").TLiteral<"INP">, import("typebox").TLiteral<"LCP">, import("typebox").TLiteral<"TTFB">]>;
+            navigationType: import("typebox").TOptional<import("typebox").TString>;
+            rating: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"good">, import("typebox").TLiteral<"needs-improvement">, import("typebox").TLiteral<"poor">]>>;
+            value: import("typebox").TNumber;
+        }>>;
+        navigationType: import("typebox").TOptional<import("typebox").TString>;
+        route: import("typebox").TString;
+    }>;
+}, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, ({ body, request, set }: {
+    body: {
+        navigationType?: string | undefined;
+        route: string;
+        metrics: {
+            delta?: number | undefined;
+            navigationType?: string | undefined;
+            rating?: "good" | "needs-improvement" | "poor" | undefined;
+            name: "CLS" | "FCP" | "INP" | "LCP" | "TTFB";
+            value: number;
+            id: string;
+        }[];
+    };
+    query: Record<string, string | undefined>;
+    params: {};
+    headers: Record<string, string | undefined>;
+    cookie: Record<string, import("elysia").Cookie<unknown>>;
+    server: import("elysia").Server | null;
+    redirect: import("elysia").redirect;
+    set: {
+        headers: import("elysia").HTTPHeaders;
+        status?: number | keyof import("elysia").StatusMap;
+        cookie?: Record<string, import("elysia").BaseCookie>;
+        redirect?: never;
+    };
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = import("elysia").StatusResponse<Code>>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, import("elysia").NumericStatus<Code>>;
+    problem: typeof import("elysia").problem;
+    defer: (fn: import("elysia/types").AfterResponseHandler<NoInfer<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{
+        body: import("typebox").TObject<{
+            metrics: import("typebox").TArray<import("typebox").TObject<{
+                delta: import("typebox").TOptional<import("typebox").TNumber>;
+                id: import("typebox").TString;
+                name: import("typebox").TUnion<[import("typebox").TLiteral<"CLS">, import("typebox").TLiteral<"FCP">, import("typebox").TLiteral<"INP">, import("typebox").TLiteral<"LCP">, import("typebox").TLiteral<"TTFB">]>;
+                navigationType: import("typebox").TOptional<import("typebox").TString>;
+                rating: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"good">, import("typebox").TLiteral<"needs-improvement">, import("typebox").TLiteral<"poor">]>>;
+                value: import("typebox").TNumber;
+            }>>;
+            navigationType: import("typebox").TOptional<import("typebox").TString>;
+            route: import("typebox").TString;
+        }>;
+    }, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>>, NoInfer<import("elysia").DefaultSingleton & {
+        derive: {};
+    }>>) => import("elysia/types").MaybePromise<void>;
+    readonly path: string;
+    route?: string | undefined;
+    rid?: string | undefined;
+    request: Request;
+    store: {};
+}) => Promise<null>, {
+    body: import("typebox").TObject<{
+        metrics: import("typebox").TArray<import("typebox").TObject<{
+            delta: import("typebox").TOptional<import("typebox").TNumber>;
+            id: import("typebox").TString;
+            name: import("typebox").TUnion<[import("typebox").TLiteral<"CLS">, import("typebox").TLiteral<"FCP">, import("typebox").TLiteral<"INP">, import("typebox").TLiteral<"LCP">, import("typebox").TLiteral<"TTFB">]>;
+            navigationType: import("typebox").TOptional<import("typebox").TString>;
+            rating: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<"good">, import("typebox").TLiteral<"needs-improvement">, import("typebox").TLiteral<"poor">]>>;
+            value: import("typebox").TNumber;
+        }>>;
+        navigationType: import("typebox").TOptional<import("typebox").TString>;
+        route: import("typebox").TString;
+    }>;
+}>;

package/dist/src/dev/angular/fastHmrCompiler.d.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import type { AngularEntityKind } from './resolveOwningComponents';
-export type FastHmrFallbackReason = 'file-not-found' | 'class-not-found' | 'no-component-decorator' | 'unsupported-decorator-args' | 'inherits-decorated-class' | 'multiple-decorators-on-class' | 'template-parse-error' | 'template-resource-not-found' | 'style-resource-not-found' | 'structural-change' | 'unexpected-error';
+export type FastHmrFallbackReason = 'file-not-found' | 'class-not-found' | 'no-component-decorator' | 'unsupported-decorator-args' | 'inherits-decorated-class' | 'multiple-decorators-on-class' | 'template-parse-error' | 'template-resource-not-found' | 'style-resource-not-found' | 'style-compile-error' | 'structural-change' | 'unexpected-error';
 export type ComponentFingerprint = {
     className: string;
     selector: string | null;

package/dist/src/dev/client/cspNonce.d.ts

@@ -0,0 +1,2 @@
+export declare const applyPageNonce: <Element extends HTMLElement>(element: Element) => Element;
+export declare const readPageNonce: () => string | undefined;

package/dist/src/dev/fileRouteRefresher.d.ts

@@ -0,0 +1,5 @@
+import type { BuildConfig } from '../../types/build';
+export declare const createFileRouteRefresher: (config: BuildConfig, notify: (path: string) => void) => {
+    /** Call for every watcher event; only route folders count. */
+    onFileChange: (filePath: string) => void;
+} | null;

package/dist/src/dev/importCost/instrument.d.ts

@@ -1,5 +1,5 @@
 export type ImportCostLoader = 'js' | 'jsx' | 'ts' | 'tsx';
 /** The Bun loader to hand back with the rewritten contents. Bun infers
  *  CommonJS versus ESM from the source, so `.cjs`/`.mjs` both take `js`. */
-export declare const importCostLoader: (path: string) => "ts" | "js" | "tsx" | "jsx";
+export declare const importCostLoader: (path: string) => "tsx" | "ts" | "jsx" | "js";
 export declare const instrumentModuleSource: (source: string, moduleIndex: number) => string;

package/dist/src/dev/reactServerComponentsRebuild.d.ts

@@ -0,0 +1,3 @@
+import type { BuildConfig } from '../../types/build';
+import type { HMRState } from './clientManager';
+export declare const rebuildReactServerComponents: (state: HMRState, config: BuildConfig, filePath: string, currentHash: number) => Promise<boolean>;

package/dist/src/i18n/defineMessages.d.ts

@@ -0,0 +1,5 @@
+import type { MessageCatalog } from '../../types/i18n';
+/** Declare the default locale's catalog. Returns it unchanged, typed with
+ *  its literal strings so `t()` checks keys and ICU parameters (the same
+ *  as writing `as const`). */
+export declare const defineMessages: <const Catalog extends MessageCatalog>(catalog: Catalog) => Catalog;

package/dist/src/i18n/formatMessage.d.ts

@@ -0,0 +1,26 @@
+type TextNode = {
+    kind: 'text';
+    value: string;
+};
+type PoundNode = {
+    kind: 'pound';
+};
+type ArgumentNode = {
+    kind: 'argument';
+    name: string;
+    format: string | undefined;
+    style: string | undefined;
+};
+type BranchNode = {
+    kind: 'plural' | 'select' | 'selectordinal';
+    name: string;
+    offset: number;
+    options: Record<string, MessageNode[]>;
+};
+export type MessageNode = ArgumentNode | BranchNode | PoundNode | TextNode;
+/** Parse an ICU message into nodes. Throws `SyntaxError` on bad syntax. */
+export declare const parseMessage: (source: string) => MessageNode[];
+/** Format an ICU message for `locale`. A message that fails to parse is
+ *  returned as written; a missing parameter renders as `{name}`. */
+export declare const formatMessage: (locale: string, message: string, params?: Record<string, unknown>) => string;
+export {};

package/dist/src/i18n/index.d.ts

@@ -0,0 +1,6 @@
+export { defineMessages } from './defineMessages';
+export { formatMessage, parseMessage } from './formatMessage';
+export type { MessageNode } from './formatMessage';
+export { alternateLinks, localeDirection, localeFromPath, localizePath, matchLocale, negotiateLocale, parseAcceptLanguage, readCookie, stripLocalePrefix } from './routing';
+export { createTranslator, isI18nPayload, isMessageTree, lookupMessage } from './translator';
+export type * from '../../types/i18n';

package/dist/src/i18n/intlCache.d.ts

@@ -0,0 +1,5 @@
+export declare const getDateTimeFormat: (locale: string, options?: Intl.DateTimeFormatOptions) => Intl.DateTimeFormat;
+export declare const getListFormat: (locale: string, options?: Intl.ListFormatOptions) => Intl.ListFormat;
+export declare const getNumberFormat: (locale: string, options?: Intl.NumberFormatOptions) => Intl.NumberFormat;
+export declare const getPluralRules: (locale: string, options?: Intl.PluralRulesOptions) => Intl.PluralRules;
+export declare const getRelativeTimeFormat: (locale: string, options?: Intl.RelativeTimeFormatOptions) => Intl.RelativeTimeFormat;

package/dist/src/i18n/routing.d.ts

@@ -0,0 +1,28 @@
+import type { AlternateLink, LocaleRoutingConfig, TextDirection } from '../../types/i18n';
+/** `rtl` for locales written right to left (Arabic, Hebrew, Persian,
+ *  Urdu, … or any tag with an RTL script subtag), else `ltr`. */
+export declare const localeDirection: (locale: string) => TextDirection;
+/** Language tags from an `Accept-Language` header, best first. */
+export declare const parseAcceptLanguage: (header: string | null | undefined) => string[];
+/** The locale named by the path's first segment, if it is one. */
+export declare const localeFromPath: <Locale extends string>(pathname: string, locales: readonly Locale[]) => Locale | undefined;
+/** The configured locale that best matches one requested tag: an exact
+ *  (case-insensitive) match, then the same language (`fr-CA` → `fr`, or
+ *  `fr` → `fr-FR`). */
+export declare const matchLocale: <Locale extends string>(tag: string, locales: readonly Locale[]) => Locale | undefined;
+/** The first requested tag that matches a configured locale, else
+ *  `fallback`. */
+export declare const negotiateLocale: <Locale extends string>(requested: readonly string[], locales: readonly Locale[], fallback: Locale) => Locale;
+/** A cookie's value from a `Cookie` header. */
+export declare const readCookie: (header: string | null | undefined, name: string) => string | undefined;
+/** `pathname` without a leading locale segment (`/fr/about` → `/about`). */
+export declare const stripLocalePrefix: (pathname: string, locales: readonly string[]) => string;
+/** `path` as it is addressed in `locale`. Under `prefix` this swaps or
+ *  adds the locale segment (the default locale stays unprefixed unless
+ *  `prefixDefault`); other strategies keep one path for every locale. */
+export declare const localizePath: <Locale extends string>(path: string, locale: Locale, routing: LocaleRoutingConfig<Locale>) => string;
+/** hreflang alternates for `path` (with or without a locale prefix): one
+ *  per locale plus `x-default`. Empty under `negotiate`, where every
+ *  locale shares one URL. `origin` makes the hrefs absolute, as search
+ *  engines require. */
+export declare const alternateLinks: <Locale extends string>(path: string, routing: LocaleRoutingConfig<Locale>, origin: string) => AlternateLink[];

package/dist/src/i18n/translator.d.ts

@@ -0,0 +1,11 @@
+import type { I18nPayload, MessageCatalog, MessageTree, Translator } from '../../types/i18n';
+/** The message at a dot-separated key, or undefined. */
+export declare const lookupMessage: (messages: MessageTree, key: string) => string | undefined;
+/** Whether `value` is an i18n payload (as passed through page props). */
+export declare const isI18nPayload: (value: unknown) => value is I18nPayload;
+/** Whether `value` is a catalog: nested plain objects of strings. */
+export declare const isMessageTree: (value: unknown) => value is MessageTree;
+/** A translator over a payload's messages. Pass your default catalog's
+ *  type (`createTranslator<typeof en>(payload)`) to type-check keys and
+ *  ICU parameters. */
+export declare const createTranslator: <Catalog = MessageCatalog>(payload: I18nPayload) => Translator<Catalog>;