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

package/dist/types/angular.d.ts

@@ -9,6 +9,8 @@ export type AngularDeps = {
     NgComponentOutlet: typeof import('@angular/common').NgComponentOutlet;
     provideClientHydration: typeof import('@angular/platform-browser').provideClientHydration;
     provideServerRendering: typeof import('@angular/platform-server').provideServerRendering;
+    CSP_NONCE: typeof import('@angular/core').CSP_NONCE;
+    provideZoneChangeDetection: typeof import('@angular/core').provideZoneChangeDetection;
     provideZonelessChangeDetection: typeof import('@angular/core').provideZonelessChangeDetection;
     reflectComponentType: typeof import('@angular/core').reflectComponentType;
     renderApplication: typeof import('@angular/platform-server').renderApplication;

package/dist/types/build.d.ts

@@ -1,8 +1,14 @@
 import { build } from '../src/core/build';
 import { devBuild } from '../src/core/devBuild';
 import type { BuildConfig as BunBuildConfig } from 'bun';
+import type { FileRoutesConfig } from './fileRoutes';
+import type { FontsConfig } from './fonts';
 import type { ImageConfig } from './image';
 import type { SitemapConfig } from './sitemap';
+/** How Angular pages run change detection. `'zoneless'` (the default)
+ *  uses signals and explicit scheduling; `'zone'` loads zone.js on the
+ *  server and in the browser for apps and libraries that rely on NgZone. */
+export type AngularChangeDetection = 'zone' | 'zoneless';
 export type BunBuildPassKey = 'server' | 'reactClient' | 'nonReactClient' | 'islandClient' | 'globalCss' | 'vueCss';
 export type ReservedBunBuildConfigKey = 'entrypoints' | 'outdir' | 'outfile' | 'root' | 'target' | 'format' | 'throw' | 'compile';
 type DistributivePartialOmit<T, K extends PropertyKey> = T extends unknown ? Partial<Omit<T, Extract<keyof T, K>>> : never;
@@ -425,6 +431,11 @@ export type BaseBuildConfig = {
         bootstrap?: string;
     };
     reactDirectory?: string;
+    /** Opt-in React Server Components. Pages are the files directly in
+     *  `<dir>/pages`; serve one with `handleReactServerPageRequest({ page:
+     *  asset(manifest, '<Page>RSC') })`. Requires react-server-dom-webpack
+     *  at the version of react. */
+    reactServerComponentsDirectory?: string;
     vueDirectory?: string;
     angularDirectory?: string;
     /** Per-framework Angular config. `providers` is the global default
@@ -438,6 +449,9 @@ export type BaseBuildConfig = {
      *  come from page-level `export const routes` and are auto-wired by
      *  the build — users never write `provideRouter` themselves. */
     angular?: {
+        /** `'zone'` opts every Angular page into zone.js change detection
+         *  (zone.js must be installed in the app). Defaults to `'zoneless'`. */
+        changeDetection?: AngularChangeDetection;
         providers?: ReadonlyArray<import('@angular/core').Provider | import('@angular/core').EnvironmentProviders>;
     };
     astroDirectory?: string;
@@ -515,7 +529,20 @@ export type BaseBuildConfig = {
     static?: StaticConfig;
     compile?: CompileConfig;
     images?: ImageConfig;
+    /** Build-time font optimization: self-hosts Google Fonts or local font
+     *  files with hashed names, preloads the critical faces and adds
+     *  metric-matched fallback faces. Use `fontAssets(manifest)` to put them
+     *  in a page's head. See docs/FONTS.md. */
+    fonts?: FontsConfig;
+    /** Opt-in Core Web Vitals reporting (LCP, INP, CLS, FCP, TTFB) from real
+     *  visits. See docs/WEB_VITALS.md. */
+    vitals?: VitalsConfig;
     sitemap?: SitemapConfig;
+    /** Opt-in file-system routing: route files under each framework
+     *  directory's `routes/` folder become GET routes (React and Svelte for
+     *  now). Explicit routes stay the default and take precedence. See
+     *  docs/FILE_ROUTER_PLAN.md. */
+    fileRoutes?: boolean | FileRoutesConfig;
     openapi?: boolean | OpenApiConfig;
     telemetry?: boolean | OtelConfig;
     sourcemaps?: 'external' | 'inline' | boolean;
@@ -569,4 +596,14 @@ export type Result = BuildResult | DevBuildResult;
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
+export type VitalsConfig = {
+    /** Where the browser sends each page's batch. A path is served by the
+     *  built-in route (handlers registered with `onVital()`); a full URL
+     *  posts elsewhere. Default `/__absolute/vitals`. */
+    endpoint?: string;
+    /** Share of page loads that report, 0–1. Default 1. */
+    sampleRate?: number;
+    /** Report from `absolute dev` too. Default false. */
+    dev?: boolean;
+};
 export {};

package/dist/types/conventions.d.ts

@@ -19,6 +19,9 @@ export type ConventionsMap = {
     angular?: FrameworkConventionEntry;
     ember?: FrameworkConventionEntry;
     html?: FrameworkConventionEntry;
+    /** Conventions from the HTMX pages directory only. HTMX pages try these
+     *  first, then `html` (which also includes them). */
+    htmx?: FrameworkConventionEntry;
 };
 export type ErrorPageProps = Pick<Error, 'name' | 'message' | 'stack'>;
 export type HtmlDocument = `<!DOCTYPE html>${string}` | `<!doctype html>${string}`;

package/dist/types/fileRoutes.d.ts

@@ -0,0 +1,72 @@
+import type { Context } from 'elysia';
+export type FileRouteFramework = 'react' | 'svelte';
+export type FileRoutesConfig = {
+    /** Folder inside each framework directory that holds route files.
+     *  Default `routes`, so React routes live in `<reactDirectory>/routes`. */
+    directory?: string;
+    /** Where the generated route module is written, relative to the project
+     *  root. Your server imports `routeTree` from it. Default
+     *  `src/routes.gen.ts`. */
+    output?: string;
+};
+type ParamNamesOf<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? Param | ParamNamesOf<`/${Rest}`> : Path extends `${string}:${infer Param}` ? Param : never;
+/** The params of an Elysia-style path: `'/blog/:slug'` → `{ slug: string }`.
+ *  An unknown path (`string`) has string params of any name. */
+export type FileRouteParams<Path extends string> = string extends Path ? Record<string, string> : {
+    [Name in ParamNamesOf<Path>]: string;
+};
+export type FileRouteRedirectStatus = 301 | 302 | 303 | 307 | 308;
+/** What `load` and `beforeHandle` receive for a request to `Path`. */
+export type FileRouteContext<Path extends string = string> = {
+    headers: Record<string, string | undefined>;
+    params: FileRouteParams<Path>;
+    path: string;
+    query: Record<string, string | undefined>;
+    request: Request;
+    /** Response status and headers, as on an Elysia context. */
+    set: Context['set'];
+    /** A redirect response; return it from `beforeHandle` or `load`. */
+    redirect: (url: string, status?: FileRouteRedirectStatus) => Response;
+};
+type MaybePromise<Value> = Value | Promise<Value>;
+/** The shape of a route's co-located `<Route>.server.ts` module. */
+export type FileRouteServerModule<Path extends string = string, Props = Record<string, unknown>> = {
+    /** Runs before `load`; return a value (a `Response`, a redirect) to
+     *  answer the request instead of rendering the page. */
+    beforeHandle?: (context: FileRouteContext<Path>) => unknown;
+    /** Returns the props the page renders with. */
+    load?: (context: FileRouteContext<Path>) => MaybePromise<Props | Response>;
+};
+type RequiredKeysOf<Value> = {
+    [Key in keyof Value]-?: undefined extends Value[Key] ? never : Key;
+}[keyof Value];
+/** Props a route's `load` has to supply: the page's props minus the `url`
+ *  the page handler fills in from the request. */
+export type FileRouteLoadProps<Props> = Omit<Props, 'url'>;
+/** A route with required page props needs a server module whose `load`
+ *  returns them; otherwise the server module is optional. */
+export type FileRouteServerModuleFor<Path extends string, Props> = [
+    RequiredKeysOf<FileRouteLoadProps<Props>>
+] extends [never] ? FileRouteServerModule<Path, FileRouteLoadProps<Props>> | undefined : FileRouteServerModule<Path, FileRouteLoadProps<Props>> & {
+    load: (context: FileRouteContext<Path>) => MaybePromise<FileRouteLoadProps<Props> | Response>;
+};
+/** What `fileRoutes()` needs to serve one request. Built by the framework
+ *  adapters (`reactFileRoute`, `svelteFileRoute`) in the generated module. */
+export type FileRouteRenderInput = {
+    manifest: Record<string, string>;
+    props: Record<string, unknown>;
+    request: Request;
+};
+export type FileRouteDefinition = {
+    framework: FileRouteFramework;
+    /** Page name in the manifest (`<name>Index`, …). */
+    name: string;
+    /** Elysia path, e.g. `/blog/:slug`. */
+    path: string;
+    /** Route file, relative to the project root. */
+    source: string;
+    beforeHandle?: (context: FileRouteContext) => unknown;
+    load?: (context: FileRouteContext) => Promise<unknown>;
+    render: (input: FileRouteRenderInput) => Promise<Response>;
+};
+export {};

package/dist/types/fonts.d.ts

@@ -0,0 +1,86 @@
+export type FontStyle = 'normal' | 'italic';
+export type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+/** The generic family the size-adjusted fallback face is built from:
+ *  Arial for `sans-serif`, Times New Roman for `serif`, Courier New for
+ *  `monospace`. */
+export type FontFallbackCategory = 'sans-serif' | 'serif' | 'monospace';
+/** A face to preload. Omitted fields match any value. */
+export type FontPreloadSelector = {
+    weight?: number | string;
+    style?: FontStyle;
+    subset?: string;
+};
+/** One font file from the project, for a family with `src`. */
+export type LocalFontSource = {
+    /** Path to a `.woff2`, `.woff`, `.ttf` or `.otf` file, relative to the
+     *  project root. */
+    path: string;
+    /** A number (`400`) or, for a variable font, a range (`'100 900'`).
+     *  Defaults to 400. */
+    weight?: number | string;
+    /** Defaults to `normal`. */
+    style?: FontStyle;
+};
+export type FontFamilyConfig = {
+    /** The family name, e.g. `'Poppins'` or `'Open Sans'`. */
+    family: string;
+    /** Local font files. When set, the family is self-hosted from these
+     *  files instead of downloaded from Google Fonts. */
+    src?: LocalFontSource[];
+    /** Google Fonts weights: numbers (`[400, 700]`) or one variable range
+     *  (`'100..900'`). Defaults to `[400]`. */
+    weights?: Array<number | string> | string;
+    /** Google Fonts styles. Defaults to `['normal']`. */
+    styles?: FontStyle[];
+    /** Google Fonts subsets to keep. Defaults to `['latin']`. */
+    subsets?: string[];
+    /** `font-display` for this family. Defaults to the top-level `display`. */
+    display?: FontDisplay;
+    /** Which faces to preload. `true` (the default) preloads the first
+     *  weight and style in the latin subset (or the first subset); `false`
+     *  preloads nothing; a list picks faces explicitly. */
+    preload?: boolean | FontPreloadSelector[];
+    /** Generic family for the metric-matched fallback face. Inferred from
+     *  the family name when omitted (`Mono` -> monospace, `Serif` -> serif,
+     *  otherwise sans-serif). */
+    fallback?: FontFallbackCategory;
+    /** Generate the size-adjusted fallback `@font-face`. Defaults to true. */
+    adjustFallback?: boolean;
+    /** CSS custom property name. Defaults to `--font-<family-kebab>`. */
+    variable?: string;
+    /** Class name that applies the family. Defaults to `font-<family-kebab>`. */
+    className?: string;
+};
+export type FontsConfig = {
+    families: FontFamilyConfig[];
+    /** Default `font-display` for every family. Defaults to `swap`. */
+    display?: FontDisplay;
+    /** When a Google Fonts download fails (offline, blocked), link the
+     *  remote stylesheet instead of failing the build. Defaults to false. */
+    fallbackToRemote?: boolean;
+    /** Where downloads are cached between builds. Defaults to
+     *  `.absolutejs/cache/fonts` under the project root. */
+    cacheDirectory?: string;
+    /** Add the font stylesheet and preloads to the `<head>` of HTML and
+     *  HTMX pages. Defaults to true. */
+    injectHtml?: boolean;
+};
+/** What a page needs in its `<head>` to use the built fonts. Plain data,
+ *  so it can be passed as a page prop and serialized for hydration. */
+export type FontAssets = {
+    preload: string[];
+    stylesheets: string[];
+};
+/** Vertical and horizontal metrics read from a font file. */
+export type FontMetrics = {
+    ascent: number;
+    descent: number;
+    lineGap: number;
+    unitsPerEm: number;
+    /** Average advance width of latin text, weighted by letter frequency. */
+    averageWidth: number;
+};
+export type FontFetch = (url: string, init?: {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<Response>;

package/dist/types/formAction.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Public type surface for form actions (`defineAction` on the server,
+ * `useFormAction` / `enhanceForms` in the browser). Browser code imports
+ * these types only, so a page can type its form against a server action
+ * with `import type { createUser } from '../../server'` and never pull
+ * server code into its bundle.
+ */
+/** Field name → message, one message per field. */
+export type ActionFieldErrors<Fields extends string = string> = Partial<Record<Fields, string>>;
+/** What the user typed, echoed back after a submission without
+ *  JavaScript failed, so the form can be refilled. Files and fields whose
+ *  name looks secret (password, token, card…) are never echoed. */
+export type ActionFormValues<Fields extends string = string> = Partial<Record<Fields, string | string[]>>;
+export type ActionIdleState = {
+    status: 'idle';
+};
+export type ActionSuccessState<Data = unknown> = {
+    status: 'success';
+    /** The handler's return value. Undefined after a submission without
+     *  JavaScript when the value didn't fit the result cookie (~3.5 KB). */
+    data?: Data;
+    /** Where the browser goes next, when the action sets `redirect`. */
+    redirect?: string;
+};
+export type ActionErrorState<Fields extends string = string> = {
+    status: 'error';
+    errors: ActionFieldErrors<Fields>;
+    /** A message for the whole form (`fail(errors, message)`, or a
+     *  network / server failure seen by the browser helpers). */
+    message?: string;
+    values?: ActionFormValues<Fields>;
+};
+/** What a submission produces. */
+export type ActionResult<Data = unknown, Fields extends string = string> = ActionErrorState<Fields> | ActionSuccessState<Data>;
+/** A form's state: idle until the first submission. */
+export type ActionState<Data = unknown, Fields extends string = string> = ActionIdleState | ActionResult<Data, Fields>;
+/** The phantom type a `defineAction(...)` result carries, so browser code
+ *  can name the action with `typeof createUser` and get its path, field
+ *  names and result type. */
+export type FormActionDefinition<Path extends string = string, Body = unknown, Data = unknown> = {
+    readonly actionPath: Path;
+    readonly '~formAction'?: {
+        body: Body;
+        data: Data;
+    };
+};
+export type AnyFormAction = FormActionDefinition;
+export type ActionPath<Action extends AnyFormAction> = Action['actionPath'];
+export type ActionBody<Action extends AnyFormAction> = NonNullable<Action['~formAction']>['body'];
+export type ActionData<Action extends AnyFormAction> = NonNullable<Action['~formAction']>['data'];
+/** The body's field names; any string for an untyped action. */
+export type ActionFields<Action extends AnyFormAction> = unknown extends ActionBody<Action> ? string : Extract<keyof ActionBody<Action>, string>;
+export type ActionResultOf<Action extends AnyFormAction> = ActionResult<ActionData<Action>, ActionFields<Action>>;
+export type ActionStateOf<Action extends AnyFormAction> = ActionState<ActionData<Action>, ActionFields<Action>>;

package/dist/types/globals.d.ts

@@ -75,6 +75,10 @@ declare global {
 	 *  detect this and call `.reload({ fetch })` on the existing server
 	 *  instead of re-binding the port. Stays unset outside dev. */
 	var __absoluteBunServer: import('bun').Server | null | undefined;
+	/** Angular change detection mode for this process, set by the build
+	 *  and by `installAngularZoneRuntime` (src/angular/zoneRuntime.ts). */
+	var __absoluteAngularChangeDetection:
+		import('./build').AngularChangeDetection | undefined;
 	/** "Building…" placeholder bound by the dev bootstrap before the entry
 	 *  is imported; released by `networking` right before the real listen.
 	 *  See `src/dev/earlyListener.ts`. */
@@ -160,6 +164,12 @@ declare global {
 		__ABS_HMR_APPLIES__?: NonNullable<Window['__ABS_HMR_LAST_APPLY__']>[];
 		__ERROR_BOUNDARY__?: { reset: () => void };
 		__INITIAL_PROPS__?: Record<string, unknown>;
+		/** `useServerData` results the Vue page handler serialized for
+		 *  hydration. Entries are removed as components read them. */
+		__ABSOLUTE_SERVER_DATA__?: Record<
+			string,
+			import('./vue').ServerDataEntry
+		>;
 		__ABSOLUTE_PAGE_RENDER_MODE__?: 'client' | 'hydrate';
 		__ABS_REACT_REMOUNT__?: (module: Record<string, unknown>) => void;
 		__REACT_COMPONENT_KEY__?: string;

package/dist/types/i18n.d.ts

@@ -0,0 +1,185 @@
+/** A message catalog: nested objects whose leaves are ICU MessageFormat
+ *  strings. Top-level keys double as namespaces (what a page loads). */
+export type MessageCatalog = {
+    readonly [key: string]: string | MessageCatalog;
+};
+/** Runtime shape of a catalog after loading (no literal types). */
+export type MessageTree = {
+    [key: string]: string | MessageTree;
+};
+/** A value a simple `{name}` argument accepts. Numbers are formatted with
+ *  `Intl.NumberFormat`, dates with `Intl.DateTimeFormat`. */
+export type MessageValue = string | number | bigint | Date;
+/** The same shape as `Source`, with every leaf widened to `string` — the
+ *  type a non-default locale's catalog must satisfy. A missing key is a
+ *  type error. */
+export type Translation<Source> = {
+    readonly [K in keyof Source]: Source[K] extends string ? string : Translation<Source[K]>;
+};
+/** Every dot-separated key that leads to a message in `Catalog`. */
+export type MessageKey<Catalog> = string extends keyof Catalog ? string : {
+    [K in keyof Catalog & string]: Catalog[K] extends string ? K : `${K}.${MessageKey<Catalog[K]>}`;
+}[keyof Catalog & string];
+/** The message string (literal when the catalog is `as const`) at `Key`. */
+export type MessageAt<Catalog, Key extends string> = Key extends `${infer Head}.${infer Rest}` ? Head extends keyof Catalog ? MessageAt<Catalog[Head], Rest> : never : Key extends keyof Catalog ? Catalog[Key] : never;
+type Whitespace = ' ' | '\n' | '\t' | '\r';
+type Trim<Value extends string> = Value extends `${Whitespace}${infer Rest}` ? Trim<Rest> : Value extends `${infer Rest}${Whitespace}` ? Trim<Rest> : Value;
+type HasChar<Value extends string, Char extends string> = Value extends `${string}${Char}${string}` ? true : false;
+type ArgumentType<Kind extends string> = Kind extends 'number' | 'plural' | 'selectordinal' ? number : Kind extends 'date' | 'time' ? Date | number : Kind extends 'select' ? string : MessageValue;
+type Branching = 'plural' | 'select' | 'selectordinal';
+/** Parse the branches after `{name, plural,` up to the closing `}`. */
+type ParseBranches<Source extends string, Params> = Source extends `${infer Selector}{${infer Body}` ? HasChar<Selector, '}'> extends true ? Source extends `${string}}${infer After}` ? [Params, After] : [Params, ''] : ParseBody<Body, Params> extends [infer Next, infer Rest] ? Rest extends string ? ParseBranches<Rest, Next> : [Params, ''] : [Params, ''] : Source extends `${string}}${infer After}` ? [Params, After] : [Params, ''];
+/** Parse an argument; `Source` starts just after its `{`. */
+type ParseArgument<Source extends string, Params> = Source extends `${infer Head}}${infer After}` ? HasChar<Head, ',' | '{'> extends false ? [Params & Record<Trim<Head>, MessageValue>, After] : ParseTypedArgument<Source, Params> : [Params, ''];
+type ParseTypedArgument<Source extends string, Params> = Source extends `${infer Name},${infer Rest}` ? Rest extends `${infer Kind},${infer Branches}` ? Trim<Kind> extends Branching ? ParseBranches<Branches, Params & Record<Trim<Name>, ArgumentType<Trim<Kind>>>> : ParseFormattedArgument<Name, Rest, Params> : ParseFormattedArgument<Name, Rest, Params> : [Params, ''];
+/** `{name, number}` or `{name, date, short}` (a style never nests). */
+type ParseFormattedArgument<Name extends string, Rest extends string, Params> = Rest extends `${infer Kind}}${infer After}` ? HasChar<Kind, ','> extends false ? [Params & Record<Trim<Name>, ArgumentType<Trim<Kind>>>, After] : Rest extends `${infer StyledKind},${string}}${infer StyledAfter}` ? [
+    Params & Record<Trim<Name>, ArgumentType<Trim<StyledKind>>>,
+    StyledAfter
+] : [Params, ''] : [Params, ''];
+/** Parse a branch body up to its closing `}`. */
+type ParseBody<Source extends string, Params> = Source extends `${infer Text}{${infer Inner}` ? HasChar<Text, '}'> extends true ? Source extends `${string}}${infer After}` ? [Params, After] : [Params, ''] : ParseArgument<Inner, Params> extends [infer Next, infer Rest] ? Rest extends string ? ParseBody<Rest, Next> : [Params, ''] : [Params, ''] : Source extends `${string}}${infer After}` ? [Params, After] : [Params, ''];
+type ParseMessage<Source extends string, Params> = Source extends `${string}{${infer Inner}` ? ParseArgument<Inner, Params> extends [infer Next, infer Rest] ? Rest extends string ? ParseMessage<Rest, Next> : Params : Params : Params;
+type Flatten<Value> = {
+    [K in keyof Value]: Value[K];
+} & {};
+/** The parameters an ICU message string needs, e.g.
+ *  `MessageParams<'{count, plural, one {# item} other {# items}}'>` is
+ *  `{ count: number }`. */
+export type MessageParams<Message extends string> = Flatten<ParseMessage<Message, Record<never, never>>>;
+/** The rest arguments `t(key, …)` takes for `Key`: nothing when the
+ *  message has no arguments, the typed params object when it has. A
+ *  catalog without literal types (JSON, or `MessageCatalog`) accepts any
+ *  params. */
+export type TranslateArgs<Catalog, Key extends string> = string extends keyof Catalog ? [params?: Record<string, MessageValue>] : LiteralTranslateArgs<MessageAt<Catalog, Key>>;
+type LiteralTranslateArgs<Message> = Message extends string ? string extends Message ? [params?: Record<string, MessageValue>] : keyof MessageParams<Message> extends never ? [] : [params: MessageParams<Message>] : [params?: Record<string, MessageValue>];
+export type Translate<Catalog> = <Key extends MessageKey<Catalog>>(key: Key, ...args: TranslateArgs<Catalog, Key>) => string;
+export type TextDirection = 'ltr' | 'rtl';
+/** What a page needs to translate on the server and hydrate in the
+ *  browser: one locale's messages (optionally only some namespaces),
+ *  already merged over the default locale's. Pass it as a page prop. */
+export type I18nPayload<Locale extends string = string> = {
+    locale: Locale;
+    defaultLocale: Locale;
+    dir: TextDirection;
+    messages: MessageTree;
+};
+export type DateInput = Date | number | string;
+export type Translator<Catalog = MessageCatalog> = {
+    locale: string;
+    dir: TextDirection;
+    /** Format the message at `key` with its ICU parameters. A key missing
+     *  from the catalog renders as the key itself. */
+    t: Translate<Catalog>;
+    /** Whether the loaded catalog has a message at `key`. */
+    has: (key: string) => boolean;
+    formatNumber: (value: number | bigint, options?: Intl.NumberFormatOptions) => string;
+    formatDate: (value: DateInput, options?: Intl.DateTimeFormatOptions) => string;
+    formatRelativeTime: (value: number, unit: Intl.RelativeTimeFormatUnit, options?: Intl.RelativeTimeFormatOptions) => string;
+    formatList: (items: readonly string[], options?: Intl.ListFormatOptions) => string;
+};
+/** `<link rel="alternate" hreflang="…" href="…">` in the document head. */
+export type AlternateLink = {
+    hreflang: string;
+    href: string;
+};
+/** How the request's locale is chosen.
+ *  - `prefix`: the first path segment (`/fr/about`); unprefixed paths are
+ *    the default locale unless `prefixDefault` is set.
+ *  - `domain`: the request host, mapped through `domains`.
+ *  - `negotiate`: one URL for every locale; the locale cookie, then
+ *    `Accept-Language`, then the default. */
+export type LocaleStrategy = 'domain' | 'negotiate' | 'prefix';
+/** The routing half of the config: everything needed to map paths and
+ *  hosts to locales, shared by the server plugin and the sitemap. */
+export type LocaleRoutingConfig<Locale extends string = string> = {
+    locales: readonly Locale[];
+    defaultLocale: Locale;
+    /** Default `prefix`. */
+    strategy?: LocaleStrategy;
+    /** `prefix` only: put the default locale under its prefix too
+     *  (`/en/about`). Unprefixed paths then negotiate. Default `false`. */
+    prefixDefault?: boolean;
+    /** `domain` only: locale → host (`{ fr: 'example.fr' }`). */
+    domains?: Partial<Record<Locale, string>>;
+};
+/** A non-default locale's catalog: the object itself, a module whose
+ *  default export is it, or a loader returning either (lazy). */
+export type MessageSource<Source> = Translation<Source> | (() => Translation<Source> | {
+    default: Translation<Source>;
+} | Promise<Translation<Source> | {
+    default: Translation<Source>;
+}>);
+export type I18nConfig<Locale extends string, Default extends Locale, Catalog extends MessageCatalog> = Omit<LocaleRoutingConfig<Locale>, 'defaultLocale' | 'domains'> & {
+    /** One of `locales`. */
+    defaultLocale: Default;
+    /** `domain` only: locale → host (`{ fr: 'example.fr' }`). */
+    domains?: Partial<Record<NoInfer<Locale>, string>>;
+    /** The default locale's catalog: the source of truth for keys and
+     *  parameter types, and the fallback for any other locale. */
+    messages: Catalog;
+    /** Every other locale's catalog, loaded on first use. */
+    loaders: Record<Exclude<Locale, Default>, MessageSource<NoInfer<Catalog>>>;
+    /** Cookie that remembers a visitor's choice (read by `negotiate` and
+     *  by unprefixed paths under `prefixDefault`). Default `locale`. */
+    cookieName?: string;
+    /** Route param that carries the locale (`/:locale/about`). A request
+     *  whose param is not a configured locale gets a 404. Default `locale`. */
+    localeParam?: string;
+    /** `prefix` + `prefixDefault` only: redirect unprefixed page
+     *  navigations to the negotiated locale's prefix. Default `false`. */
+    redirect?: boolean;
+    /** Origin for absolute hreflang URLs (`https://example.com`). Default:
+     *  the request's origin. */
+    baseUrl?: string;
+};
+/** Where a request's locale came from. */
+export type LocaleSource = 'cookie' | 'default' | 'domain' | 'header' | 'path';
+export type LocaleResolution<Locale extends string = string> = {
+    locale: Locale;
+    source: LocaleSource;
+};
+/** What `defineI18n(config)` returns: usable on its own (prerendering,
+ *  scripts, tests) and the input to `i18nPlugin()`. */
+export type I18nInstance<Locale extends string = string, Default extends Locale = Locale, Catalog extends MessageCatalog = MessageCatalog> = {
+    config: I18nConfig<Locale, Default, Catalog>;
+    locales: readonly Locale[];
+    defaultLocale: Default;
+    isLocale: (value: unknown) => value is Locale;
+    /** Which locale `request` is in, and why. */
+    resolve: (request: Request) => LocaleResolution<Locale>;
+    /** The locale's messages merged over the default locale's; loaded on
+     *  first use, then cached. */
+    load: (locale: Locale) => Promise<MessageTree>;
+    /** The hydration payload for `locale`, optionally only the given
+     *  top-level namespaces. */
+    payload: (locale: Locale, namespaces?: readonly (keyof Catalog & string)[]) => Promise<I18nPayload<Locale>>;
+    translator: (locale: Locale) => Promise<Translator<Catalog>>;
+    /** hreflang alternates for `path`, absolute against `origin` (or the
+     *  configured `baseUrl`). */
+    alternates: (path: string, origin: string) => AlternateLink[];
+    localizePath: (path: string, locale: Locale) => string;
+    /** A `Set-Cookie` value that remembers `locale`. */
+    cookie: (locale: Locale) => string;
+};
+/** The `i18n` object `i18nPlugin()` puts on every request's context. */
+export type RequestI18n<Locale extends string = string, Catalog extends MessageCatalog = MessageCatalog> = Translator<Catalog> & {
+    locale: Locale;
+    source: LocaleSource;
+    /** hreflang alternates for `path` (default: this request's path). */
+    alternates: (path?: string) => AlternateLink[];
+    /** `path` in `locale` (default: this request's locale). */
+    localizePath: (path: string, locale?: Locale) => string;
+    /** This locale's messages for hydration — pass it as a page prop.
+     *  Namespaces limit it to those top-level keys, so a page ships only
+     *  what it uses. */
+    payload: (namespaces?: readonly (keyof Catalog & string)[]) => I18nPayload<Locale>;
+};
+/** Sitemap localization: every page is listed once per locale with
+ *  `xhtml:link` alternates. Routes registered as `/:locale/…` or
+ *  `/:locale?/…` are picked up under their unprefixed path. */
+export type SitemapI18nConfig<Locale extends string = string> = LocaleRoutingConfig<Locale> & {
+    /** Route param that carries the locale. Default `locale`. */
+    localeParam?: string;
+};
+export {};

package/dist/types/index.d.ts

@@ -3,7 +3,10 @@ export * from './conventions';
 export * from './build';
 export * from './cli';
 export * from './env';
+export * from './fileRoutes';
 export * from './client';
+export * from './fonts';
+export * from './i18n';
 export * from './image';
 export * from './island';
 export * from './messages';
@@ -15,3 +18,4 @@ export * from './metadata';
 export * from './packageJson';
 export * from './sitemap';
 export * from './websocket';
+export * from './formAction';

package/dist/types/metadata.d.ts

@@ -35,6 +35,8 @@ export type MetaTag = {
     httpEquiv?: 'accept-ch' | 'content-security-policy' | 'content-type' | 'default-style' | 'refresh' | 'x-ua-compatible';
     content: string;
 };
+import type { FontAssets } from './fonts';
+import type { AlternateLink } from './i18n';
 import type { JsonLdSchema } from './jsonLd';
 /** A `<link rel="preload">` (or `rel="modulepreload"` when `module` is
  *  set) emitted in the document head so the browser starts fetching the
@@ -61,9 +63,18 @@ export type Metadata = {
     title?: string;
     description?: string;
     icon?: string;
+    /** A Google Fonts family name linked from fonts.googleapis.com at
+     *  runtime. Prefer the `fonts` build config with `fonts` below. */
     font?: string;
+    /** Self-hosted fonts built from the `fonts` config; pass
+     *  `fontAssets(manifest)`. */
+    fonts?: FontAssets;
     cssPath?: string | string[];
     canonical?: string;
+    /** Localized versions of this page, rendered as
+     *  `<link rel="alternate" hreflang="…" href="…">`. The i18n plugin's
+     *  `i18n.alternates()` builds the list (with `x-default`). */
+    alternates?: AlternateLink[];
     openGraph?: OpenGraph;
     twitter?: TwitterCard;
     robots?: RobotsDirective;

package/dist/types/navigation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Public type surface for cross-framework document navigation
+ * (`src/client/navigation.ts`, `@absolutejs/absolute/client/navigation`).
+ */
+/** How a navigation ended.
+ *
+ *  - `'swapped'` — the target page replaced the current one in place: no
+ *    full page load.
+ *  - `'reloaded'` — the layer handed the navigation to the browser (an
+ *    error, a non-HTML / non-2xx response, a cross-origin redirect, or a
+ *    current page that can't be torn down).
+ *  - `'superseded'` — a newer navigation started before this one finished.
+ *  - `'cancelled'` — an `absolute:before-navigate` listener called
+ *    `preventDefault()`. */
+export type DocumentNavigationOutcome = 'cancelled' | 'reloaded' | 'superseded' | 'swapped';
+/** What started a document navigation. */
+export type DocumentNavigationType = 'link' | 'navigate' | 'traverse';
+export type EnableNavigationOptions = {
+    /** Decide per URL whether the layer may soft-navigate to it. Return
+     *  `false` for a full page load. Runs after the built-in checks
+     *  (same origin, no `target` / `download` / modifier keys, no
+     *  `data-absolute-navigation="off"`). */
+    shouldIntercept?: (url: URL) => boolean;
+    /** Wrap the swap in `document.startViewTransition` where supported.
+     *  Default `true`; skipped for users who prefer reduced motion. */
+    viewTransition?: boolean;
+};
+export type NavigateDocumentOptions = {
+    /** Replace the current history entry instead of pushing one. */
+    replace?: boolean;
+};
+/** `detail` of the `absolute:before-navigate` (cancelable) and
+ *  `absolute:after-navigate` events dispatched on `window`. */
+export type DocumentNavigationEventDetail = {
+    type: DocumentNavigationType;
+    url: string;
+};

package/dist/types/prefetch.d.ts

@@ -37,6 +37,16 @@ export type PrefetchMode = 'hover' | 'viewport' | 'none';
 export type HoverPrefetchOptions = PrefetchOptions & {
     /** Also inject a prerender speculation rule when the hover fires. */
     prerender?: boolean;
+    /** Called when the debounced hover trigger fires, after the prefetch —
+     *  for warming something the URL alone doesn't name (the Svelte
+     *  router's lazy route chunks). */
+    onPrefetch?: () => void;
+};
+/** Options for a viewport trigger. */
+export type ViewportPrefetchOptions = PrefetchOptions & {
+    /** Called once when the element scrolls into view, after the
+     *  prefetch. */
+    onVisible?: () => void;
 };
 export type HoverPrefetchHandle = {
     cancel: () => void;

package/dist/types/sitemap.d.ts

@@ -1,3 +1,4 @@
+import type { SitemapI18nConfig } from './i18n';
 export type ChangeFrequency = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
 export type SitemapRouteOverride = {
     changefreq?: ChangeFrequency;
@@ -21,4 +22,7 @@ export type SitemapConfig = {
     defaultPriority?: number;
     overrides?: Record<string, SitemapRouteOverride>;
     routes?: () => string[] | Promise<string[]>;
+    /** List every page once per locale, each with `xhtml:link` hreflang
+     *  alternates. Pass the same locales/strategy as `defineI18n()`. */
+    i18n?: SitemapI18nConfig;
 };