@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/types-DsdWBG0b.d.ts

@@ -0,0 +1,558 @@
+//#region src/runtime/typed.d.ts
+/**
+ * Augmented by the generated `vi18n.gen.ts`:
+ *
+ * ```ts
+ * declare module "@menapo/vi18n" {
+ *   interface Register {
+ *     locales: "en" | "de";
+ *   }
+ * }
+ * ```
+ */
+interface Register {}
+/** The configured locales once `vi18n.gen.ts` is included, otherwise `string`. */
+type Locale = Register extends {
+  locales: infer L extends string;
+} ? L : string;
+/**
+ * Manual id → text of the messages the packages in `extraction.dependencies`
+ * declare (`vi18n.messages.json`), as `vi18n.gen.ts` lists them; none
+ * otherwise. `msg({ id })` names one of them without repeating its text.
+ */
+type LibraryMessages = Register extends {
+  messages: infer M extends {
+    readonly [id: string]: string;
+  };
+} ? M : Record<never, never>;
+/**
+ * Rest-parameter tuple of `t(message, ...values)` for a literal message `M`:
+ *
+ * - no arguments → `[]` (tags need no value in `t`, they render their children);
+ * - otherwise `[values: { … }]` with one required property per argument:
+ *   `string | number | bigint | Date` for `{x}` (a `Date` renders as
+ *   `{x, date, medium}`), `number | bigint` for `number`,
+ *   `Date | number` for `date`/`time`, `string` for `select`, `number` for
+ *   `plural`/`selectordinal`. A name used with two kinds takes the more
+ *   specific kind's type, as the compiler's `structureOf` does: a plain `{x}`
+ *   goes with any kind (`{d, date} ({d})` takes `Date | number`);
+ * - a non-literal `string` → `never`, so `t(props.label)` does not type-check
+ *   (only literals and `MessageRef`s do). So does a union with any non-literal
+ *   member (`"Save" | (string & {})`, or a template literal type): the
+ *   extractor lets such an expression through, so this type is its only guard;
+ * - a union of two or more literals (`cond ? "Draft" : "Live"`, or a variable
+ *   of type `"Draft" | "Live"`) → `never` too. The extractor takes one literal
+ *   message per call, so neither text would reach the catalogs or be
+ *   rewritten, and a production client would render "". It reports the
+ *   `? :`, `||`, `??` and `&&` forms and a `const` holding one in the same
+ *   module; a parameter or an import of such a type only this type catches.
+ *   Choose between calls (`cond ? t("Draft") : t("Live")`) or between
+ *   `msg()` references, which `t(ref)` takes as a union.
+ *
+ * A message this parser cannot read (an unclosed `{`, an unknown argument
+ * type) takes `[values?: Values]`: the compiler reports the syntax error with
+ * its position, which a type error at the call site could not. So does an
+ * MF2 complex message, whose values this ICU parser does not type.
+ */
+type ValuesOf<M extends string> = Read<M, M>;
+/**
+ * What the message parameter of `rich()`, `richHtml()`, `richParts()` and a
+ * translator's `rich*` adds to the message's own type `M`: `unknown` for one
+ * message, `never` for a choice between texts, for the reason `ValuesOf`
+ * gives (one literal per call, §6 D120, D128). A choice is a union of two or
+ * more string types, a descriptor whose `message` is one, or a union of a
+ * text (a literal string or a descriptor of one) with anything else.
+ *
+ * Unlike `t()`, these take a non-literal `string`, descriptor or
+ * `MessageKey` (a runtime id), whose values they never type. So does an
+ * explicit tag type, `rich<ReactNode>(…)`: TypeScript infers no type
+ * argument once one is given, so `M` is `MessageKey` and only the build's
+ * scan rejects a choice there.
+ */
+type OneText<M> = [Choice<M>] extends [never] ? unknown : never;
+/**
+ * Something (`1`) when `M` is a choice, else `never`. Strings, nearly every
+ * call, take one union test; a `MessageKey` that is no literal is no choice.
+ */
+type Choice<M> = [M] extends [string] ? Many<M> : [Literal<Alternatives<M>>] extends [never] ? never : Many<Alternatives<M>>;
+/** One alternative per member: a descriptor's `message`, any other member itself. */
+type Alternatives<M> = M extends {
+  readonly message: infer T;
+} ? T : M;
+/** The literal strings among `A` (as `Read` tells them from `string` and patterns). */
+type Literal<A> = A extends string ? Record<never, never> extends Record<A, 1> ? never : A : never;
+/** `1` when `T` is a union of two or more types, else `never`. */
+type Many<T, All = T> = T extends unknown ? ([All] extends [T] ? never : 1) : never;
+/**
+ * Rest-parameter tuple of `rich(message, ...values)` (PLAN §4.12 "Typed
+ * rich-text tag handlers", §6 D212): for a literal message, one property per
+ * ICU argument, typed as `ValuesOf` types it, and one handler `H` per tag,
+ * so a missing handler, a misspelt one and one for a tag the message does
+ * not have are type errors. A plain `{x}` also takes `N`, the node type, as
+ * `rich()` renders a node passed as a value in place. Tags with a global
+ * handler (`defaults.tags`, the generated `Register`'s `defaultTags`) may be
+ * left out.
+ *
+ * Untyped (`[values?: Values]`), as before: a non-literal message (a runtime
+ * id, a `MessageKey`, a `MessageRef`, whose tags its type does not carry), a
+ * message `ValuesOf` cannot read, and one whose tags this reader cannot tell
+ * (a `'#` before a tag: whether it quotes depends on an enclosing plural).
+ */
+type RichValuesOf<M, H, N = never> = Rich<TextOf<M>, H, N, true>;
+/** `richParts()`'s values: arguments only, since every tag becomes a part and handlers are ignored. */
+type RichPartsValuesOf<M> = Rich<TextOf<M>, never, never, false>;
+/** Tag names that `defaults.tags` gives a global handler (`vi18n.gen.ts`); `never` without it. */
+type DefaultTags = Register extends {
+  defaultTags: infer T extends string;
+} ? T : never;
+/** The literal text of a message, `never` for anything typed as a runtime id. */
+type TextOf<M> = M extends string ? Record<never, never> extends Record<M, 1> ? never : M : M extends {
+  readonly message: infer T extends string;
+} ? Record<never, never> extends Record<T, 1> ? never : T : never;
+type Untyped = [values?: Values];
+type Rich<S extends string, H, N, WithTags extends boolean> = [S] extends [never] ? Untyped : ValuesOf<S> extends (infer A) ? Unreadable extends A ? Untyped : (WithTags extends true ? TagsOf<S, never> : never) extends (infer Tg extends string) ? string extends Tg ? Untyped : Handlers<Tg, H, Args<A, N>> : never : never;
+/** The argument object of a `ValuesOf` result; a plain `{x}` takes nodes too. */
+type Args<A, N> = A extends [values: infer O] ? [N] extends [never] ? O : { [K in keyof O]: [Plain] extends [O[K]] ? O[K] | N : O[K]; } : unknown;
+/**
+ * The values tuple: required while an argument or a tag without a global
+ * handler needs a value, else optional; with nothing to fill in, any key is
+ * an error (`{}` would take every object).
+ */
+type Handlers<Tg extends string, H, O> = [Tg] extends [never] ? unknown extends O ? [values?: {
+  readonly [name: string]: never;
+}] : [values: O] : [Extract<Tg, DefaultTags>] extends [never] ? [values: unknown extends O ? { [K in Tg]: H; } : { [K in keyof O | Tg]: K extends Tg ? H : O[K & keyof O]; }] : [Exclude<Tg, DefaultTags>] extends [never] ? unknown extends O ? [values?: { [K in Tg]?: H; }] : [values: One<O & { [K in Tg]?: H; }>] : [values: One<O & { [K in Exclude<Tg, DefaultTags>]: H; } & { [K in Extract<Tg, DefaultTags>]?: H; }>];
+/** One object type, as editors show it; `keyof` keeps each property's `?`. */
+type One<T> = { [K in keyof T]: T[K]; };
+/** First characters of a tag name: `<` and anything else is text (INTERNALS §2.1). */
+type AsciiLetter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+/**
+ * The tag names of a message, read like `Body` reads arguments: one template
+ * match per `<` and per `'`, never per character. Tags only stand in text,
+ * and argument names, types, option keys and styles hold neither `<` nor `'`
+ * in a message the compiler accepts, so no frame stack is needed; only
+ * quoted text hides a tag. `string` when a `'#` comes first: it quotes only
+ * inside a plural, which this reader does not track.
+ */
+type TagsOf<S extends string, Acc extends string> = S extends `${infer A}<${infer R}` ? A extends `${string}'${string}` ? TagQuote<S, Acc> : R extends `${infer F}${string}` ? F extends AsciiLetter ? R extends `${infer N}>${infer Rest}` ? TagsOf<Rest, Acc | TagName<N>> : string : TagsOf<R, Acc> : Acc : Acc;
+/** `S` has a `'` before its first `<`. */
+type TagQuote<S extends string, Acc extends string> = S extends `${string}'${infer R}` ? R extends `'${infer Rest}` ? TagsOf<Rest, Acc> : R extends `${"{" | "}" | "<" | ">"}${infer Rest}` ? TagQuoted<Rest, Acc> : R extends `#${string}` ? string : TagsOf<R, Acc> : Acc;
+/** Quoted text ends at the next single `'`; `''` inside it is a literal `'`. */
+type TagQuoted<S extends string, Acc extends string> = S extends `${string}'${infer R}` ? R extends `'${infer Rest}` ? TagQuoted<Rest, Acc> : TagsOf<R, Acc> : Acc;
+/** `b`, `br/`, `br /` → the name (the compiler allows space before `/>` and `>`). */
+type TagName<N extends string> = N extends `${infer X}/${string}` ? TrimTag<X> : TrimTag<N>;
+type TrimTag<N extends string> = N extends `${infer X}${Space}` ? TrimTag<X> : N;
+/**
+ * Reads `M` one member of `All` at a time. A member that is not the whole of
+ * `All` belongs to a union of literals, and every member of a union reads as
+ * `never`, so the union does.
+ */
+type Read<M extends string, All extends string> = M extends string ? [All] extends [M] ? Record<never, never> extends Record<M, 1> ? never : M extends `${string}{${string}` ? Mf2Form<M> extends true ? Unreadable : Flat<Body<M, [], unknown>> : [] : never : never;
+/**
+ * A parse result with its values made one object: the accumulator is an
+ * intersection of one object per use, and a name used only plainly (still
+ * `unknown`, see `PlainUse`) takes `Plain`. `[]` and `Unreadable` stay.
+ */
+type Flat<R> = R extends [values: infer I] ? [values: { [K in keyof I]: unknown extends I[K] ? Plain : I[K]; }] : R;
+type Pound = "0" | "1";
+type Frame = `b${Pound}` | `o${Pound}`;
+/** Pound sensitivity of the frame on top of the stack; the root message has none. */
+type PoundOf<St extends Frame[]> = St extends [...Frame[], `${"b" | "o"}${infer P extends Pound}`] ? P : "0";
+/** Characters that an apostrophe quotes (FormatJS's apostrophe rules). */
+type QuoteStart<P extends Pound> = "{" | "}" | "<" | ">" | (P extends "1" ? "#" : never);
+type Plain = string | number | bigint | Date;
+/**
+ * What a plain `{x}` adds to the accumulator: `unknown`, so intersecting it
+ * with another kind's type keeps that type (`Date | number` survives, where
+ * `Plain & (Date | number)` would lose `Date`); `Flat` maps what is left to `Plain`.
+ */
+type PlainUse = unknown;
+/** `{n, number}`, `{d, date}`, `{t, time}`: the value types they format. */
+interface Formatted {
+  number: number | bigint;
+  date: Date | number;
+  time: Date | number;
+}
+/** The whole message's result once its text ends outside any option; `Flat` flattens it. */
+type Done<Acc> = [keyof Acc] extends [never] ? [] : [values: Acc];
+/** What an unreadable message takes (see `ValuesOf`). */
+type Unreadable = [values?: Values];
+/**
+ * An MF2 complex message (`.input`, `.local`, `.match` or `{{` after
+ * whitespace), which the compiler reads as MF2 (INTERNALS §2.1.4): its
+ * values are not typed, so it takes what an unreadable message takes.
+ */
+type Mf2Form<M extends string> = M extends `${" " | "\n" | "\t" | "\r"}${infer R}` ? Mf2Form<R> : M extends `${".input" | ".local" | ".match" | "{{"}${string}` ? true : false;
+/** Message text: an argument when `{` comes before any `}` or `'`. */
+type Body<S extends string, St extends Frame[], Acc> = S extends `${infer A}{${infer B}` ? A extends `${string}${"}" | "'"}${string}` ? CloseOrQuote<S, St, Acc> : B extends `${infer N}}${infer R}` ? N extends `${string},${string}` ? B extends `${infer N1},${infer T}` ? Typed<Trim<N1>, T, St, Acc> : never : Trim<N> extends (infer Name extends string) ? Name extends "" ? Unreadable : Body<R, St, Acc & { [K in Name]: PlainUse; }> : never : B extends `${infer N1},${infer T}` ? Typed<Trim<N1>, T, St, Acc> : Unreadable : CloseOrQuote<S, St, Acc>;
+/** Message text without a `{` before the first `}` or `'`. */
+type CloseOrQuote<S extends string, St extends Frame[], Acc> = S extends `${infer A}'${infer R}` ? A extends `${string}}${infer B}` ? St extends [...infer Up extends Frame[], Frame] ? Options<`${B}'${R}`, Up, Acc> : Body<`${B}'${R}`, St, Acc> : R extends `'${infer Rest}` ? Body<Rest, St, Acc> : R extends `${QuoteStart<PoundOf<St>>}${infer Rest}` ? Quoted<Rest, St, Acc> : Body<R, St, Acc> : S extends `${string}}${infer B}` ? St extends [...infer Up extends Frame[], Frame] ? Options<B, Up, Acc> : Body<B, St, Acc> : St extends [] ? Done<Acc> : Unreadable;
+/** Quoted text ends at the next single `'`; `''` inside it is a literal `'`. */
+type Quoted<S extends string, St extends Frame[], Acc> = S extends `${string}'${infer R}` ? R extends `'${infer Rest}` ? Quoted<Rest, St, Acc> : Body<R, St, Acc> : St extends [] ? Done<Acc> : Unreadable;
+/** After `{name,`: the type, then `}`, a style (see `Style`), or an option list. */
+type Typed<N extends string, S extends string, St extends Frame[], Acc> = N extends "" ? Unreadable : S extends `${infer K}}${infer R}` ? K extends `${string},${string}` ? Styled<N, S, St, Acc> : Trim<K> extends (infer Type extends keyof Formatted) ? Body<R, St, Acc & { [P in N]: Formatted[Type]; }> : Unreadable : Styled<N, S, St, Acc>;
+type Styled<N extends string, S extends string, St extends Frame[], Acc> = S extends `${infer K},${infer R}` ? Trim<K> extends (infer Type) ? Type extends keyof Formatted ? Style<R, [], St, Acc & { [P in N]: Formatted[Type]; }> : Type extends "select" ? Options<R, [...St, `o${PoundOf<St>}`], Acc & { [P in N]: string; }> : Type extends "plural" | "selectordinal" ? Options<R, [...St, "o1"], Acc & { [P in N]: number; }> : Unreadable : never : Unreadable;
+/**
+ * An option list: keys (`male`, `=0`, `offset:1 one`) carry no arguments, so
+ * only the next `{` (an option body) or `}` (the end of the argument) matters.
+ */
+type Options<S extends string, St extends Frame[], Acc> = S extends `${infer K}{${infer B}` ? K extends `${string}}${infer R}` ? St extends [...infer Up extends Frame[], Frame] ? Body<`${R}{${B}`, Up, Acc> : Unreadable : St extends [...Frame[], `o${infer P extends Pound}`] ? Body<B, [...St, `b${P}`], Acc> : Unreadable : S extends `${string}}${infer R}` ? St extends [...infer Up extends Frame[], Frame] ? Body<R, Up, Acc> : Unreadable : Unreadable;
+/**
+ * A number, date or time style, read as the compiler's `simpleStyle` reads
+ * it: up to the first `}` that closes no `{` of the style, with quoted text
+ * (`'…'`, no `''` escape) opaque. `D` counts the open `{`. Without this a
+ * `'}'` in a skeleton would end the style early and hide every later argument.
+ */
+type Style<S extends string, D extends 0[], St extends Frame[], Acc> = S extends `${infer A}}${infer R}` ? A extends `${string}${"'" | "{"}${string}` ? StyleQuoteOrOpen<S, D, St, Acc> : D extends [0, ...infer Up extends 0[]] ? Style<R, Up, St, Acc> : Body<R, St, Acc> : Unreadable;
+/** Style text whose first `'`, `{` or `}` is a `'` or a `{`. */
+type StyleQuoteOrOpen<S extends string, D extends 0[], St extends Frame[], Acc> = S extends `${infer A}'${infer R}` ? A extends `${string}{${string}` ? StyleOpen<S, D, St, Acc> : R extends `${string}'${infer Rest}` ? Style<Rest, D, St, Acc> : Unreadable : StyleOpen<S, D, St, Acc>;
+type StyleOpen<S extends string, D extends 0[], St extends Frame[], Acc> = S extends `${string}{${infer R}` ? Style<R, [...D, 0], St, Acc> : never;
+/** ICU's Pattern_White_Space, which the compiler skips around names and keywords. */
+type Space = " " | "\t" | "\n" | "\v" | "\f" | "\r" | "…" | "‎" | "‏" | "
" | "
";
+type Trim<S extends string> = S extends `${Space}${infer R}` ? Trim<R> : S extends `${string}${Space}` ? TrimEnd<S, ""> : S;
+/**
+ * LRM and RLM are Pattern_White_Space but not White_Space, so a name
+ * (`[^\p{White_Space}\p{Pattern_Syntax}]*`) may end with them: `{a\u200e}`
+ * names `a\u200e`. A trailing mark is space only when White_Space comes before
+ * it, so marks wait in `Marks` until that is known.
+ */
+type TrimEnd<S extends string, Marks extends string> = S extends `${infer R}${Space}` ? S extends `${R}\u200e` ? TrimEnd<R, `\u200e${Marks}`> : S extends `${R}\u200f` ? TrimEnd<R, `\u200f${Marks}`> : TrimEnd<R, ""> : `${S}${Marks}`;
+//#endregion
+//#region src/runtime/types.d.ts
+/**
+ * A compiled message. Plain text stays a string (about 81 % of real messages),
+ * everything else is a list of parts. Never a function: the IR has to cross
+ * JSON, the SSR payload and RSC boundaries.
+ */
+type Message = string | Part[];
+/**
+ * One element of a compiled message. Arrays are told apart by length and by
+ * the numeric opcode in the second slot; `0` alone is `#`.
+ */
+type Part = string | PoundPart | ArgPart | SelectPart | PluralPart | FormatPart | TagPart | StandaloneTagPart;
+/** `#` inside an immediate plural or selectordinal branch: value − offset, number-formatted. */
+type PoundPart = 0;
+/** `{name}` */
+type ArgPart = [name: string];
+/** `{name, select, …}`; cases are read with `Object.hasOwn`, falling back to `other`. */
+type SelectPart = [name: string, op: 1, cases: Cases];
+/**
+ * `{name, plural|selectordinal, [offset:N] …}`. `=N` keys match the raw value,
+ * category keys match value − offset. `offset` is omitted when 0.
+ */
+type PluralPart = [name: string, op: 2 | 3, cases: Cases, offset?: number];
+/**
+ * `{name, number|date|time[, style]}`. The style or skeleton is resolved to Intl
+ * options at compile time; options are omitted when Intl defaults apply.
+ */
+type FormatPart = [name: string, op: 4 | 5 | 6, options?: IntlOptions];
+/** `<tag>children</tag>`; children are spread parts (an empty tag is `[tag, 7]`). */
+type TagPart = [tag: string, op: 7, ...children: Part[]];
+/** `<tag/>` */
+type StandaloneTagPart = [tag: string, op: 8];
+/** Case table of a select or plural part. Keys: select values, `=N`, CLDR categories, `other`. */
+type Cases = {
+  [key: string]: Message;
+};
+/** Options handed to `Intl.NumberFormat` / `Intl.DateTimeFormat` as they are. */
+type IntlOptions = {
+  [option: string]: string | number | boolean;
+};
+/** Values passed to `t()` and friends. Rich-text tag handlers are passed here too. */
+type Values = {
+  readonly [name: string]: unknown;
+};
+/** What the developer writes: `t({ id?, message, context?, maxLength? })`. */
+interface Descriptor {
+  readonly id?: string;
+  readonly message: string;
+  readonly context?: string;
+  readonly maxLength?: number;
+}
+/**
+ * What the dev transform emits in place of a message argument. Build output
+ * is the bare id string instead, so source text never reaches client JS.
+ */
+interface CompiledDescriptor {
+  readonly id: string;
+  /** Canonical source text; used for warnings only, never parsed at runtime. */
+  readonly message: string;
+  /** The source locale's compiled IR, rendered while no catalog has the id. */
+  readonly ir: Message;
+  /**
+   * Manual ids only: the hash label of the code's current text. A dev catalog
+   * whose label differs holds a translation of other text (D10), so the
+   * runtime renders `ir` and warns once.
+   */
+  readonly h?: string;
+}
+/**
+ * A message reference created by `msg()`: at runtime the id string (build) or
+ * a {@link CompiledDescriptor} (dev). The `~values` key is a phantom that
+ * carries the argument tuple for `t(ref, ...values)`; it never exists at runtime.
+ */
+interface MessageRef<V extends readonly unknown[] = readonly unknown[]> {
+  readonly "~values": V;
+}
+/** Anything `t()` accepts at runtime, after or without the plugin's rewrite. */
+type MessageKey = string | Descriptor | CompiledDescriptor | MessageRef;
+/** `richParts()` output. A standalone tag has `children: []`. */
+type RichPart = string | {
+  readonly tag: string;
+  readonly children: RichPart[];
+};
+/** A rich-text tag handler: receives rendered children and a stable key (the part index). */
+type TagHandler<R> = (children: (string | R)[], key: number) => R;
+/** A `richHtml()` tag handler: children arrive HTML-escaped; the return value is trusted HTML. */
+type HtmlTagHandler = (children: string, key: number) => string;
+/** Where a locale may come from, in `routing.strategy` order. */
+type LocaleStrategy = "url" | "cookie" | "header" | "localStorage" | "default";
+/** URL codec strategies (Nuxt i18n names); domains are `routing.domains` on top of `prefix_except_default`. */
+type UrlStrategy = "prefix_except_default" | "prefix" | "prefix_and_default" | "no_prefix";
+/**
+ * The slice of the resolved config that runtime code needs. It is serialised
+ * into the boot module, into `vi18n compile --out`'s `config.json`, and passed
+ * to `registerCatalogs()`. Locale inputs are matched against `locales` only.
+ */
+interface RuntimeConfig {
+  sourceLocale: string;
+  /** Configured locales followed by the active pseudo-locales. */
+  locales: string[];
+  /** Pseudo-locales active in this build (a subset of `locales`). */
+  pseudoLocales: string[];
+  fallbacks: {
+    [locale: string]: string[];
+  };
+  routing: {
+    strategy: LocaleStrategy[];
+    /** Glob (`*`, `**`) on the delocalized pathname → strategy chain. First match wins. */
+    routeStrategies: {
+      [pattern: string]: LocaleStrategy[];
+    };
+    url: UrlStrategy;
+    redirectRoot: boolean;
+    propagate: "header" | false;
+    switch: "in-place" | "navigate";
+    cookie: {
+      name: string;
+      maxAge: number;
+    };
+    /** The app's base path (Vite `base`), starting and ending with `/`. */
+    base: string;
+    /**
+     * Localized paths (PLAN §5.14): route path → locale → that locale's path,
+     * base-free, `*` and `**` segments as in `routing.paths`. Present only
+     * when configured, so default registrations carry no table.
+     */
+    paths?: {
+      [path: string]: {
+        [locale: string]: string;
+      };
+    };
+    /**
+     * Domain routing: origin (`https://example.de`) → the locale its host
+     * serves; the first origin of a locale is where links to it go. Present
+     * only when configured; its hosts are the allowlist (§6 D135).
+     */
+    domains?: {
+      [origin: string]: string;
+    };
+    /**
+     * Set at runtime, never serialised: the locale of the listed host the
+     * page (client) or the codec call (server, per request) is on. It plays
+     * the part `sourceLocale` plays in the URL codec: the unprefixed locale.
+     */
+    home?: string;
+  };
+  ssr: {
+    timeZone: string;
+    /** Glob on the delocalized pathname → time-zone source for that route. */
+    timeZoneFrom: {
+      [pattern: string]: "config" | "request";
+    };
+    normalizeSpaces: boolean;
+    /**
+     * Servers reading their catalogs from static assets (`ssr.catalogs:
+     * "assets"`, `vi18n compile --assets`): at most this many locales stay
+     * loaded, the least recently used evicted. Absent for module catalogs.
+     */
+    maxLoadedLocales?: number;
+    /**
+     * `ssr.payload: "preload"`: payloads name the page's bundles and the page
+     * preloads them instead of inlining them. Present only when configured,
+     * so default registrations stay as they were; servers read it.
+     */
+    payload?: "preload";
+  };
+}
+/**
+ * Everything `t()` and `fmt` read. The page has one scope; on the server each
+ * request (and each `withLocale` / `createTranslator`) has its own.
+ */
+interface Scope {
+  readonly kind: "page" | "request" | "translator";
+  locale: string;
+  /** Complete for the locale after fallbacks; never mutated in place (merges build new Maps). */
+  messages: ReadonlyMap<string, Message>;
+  /** IANA zone; undefined means the environment's zone (client after hydration only). */
+  timeZone: string | undefined;
+  /** Epoch ms used by `fmt.relative` and serialised to the client; undefined means `Date.now()`. */
+  now: number | undefined;
+  /** Where `timeZone` came from (server); "cookie" and "cf" are per-user zones. */
+  timeZoneSource?: "explicit" | "cookie" | "cf" | "config" | "client";
+  /** Set by the runtime when it formats time-bearing output in this scope. */
+  formattedTime?: boolean;
+  /** Server: every id looked up while rendering (payload). The runtime adds to it when present, outside `State.untracked`. */
+  used?: Set<string>;
+  /**
+   * Exact source literal → generated id, from `registerCatalogs({ sources })`.
+   * The only place `t()` resolves source-text keys (untransformed server code).
+   */
+  readonly sources?: ReadonlyMap<string, string>;
+  /**
+   * Dev only: manual id → hash label of the source its dev-catalog
+   * translation was made from (`DevCatalog.labels`). `t()` compares it with a
+   * descriptor's `h` before looking the id up (INTERNALS §2.11.2 step 1).
+   */
+  labels?: ReadonlyMap<string, string>;
+  /**
+   * Server, with `routing.domains`: the locale of the request's host when
+   * that host is listed (never an unlisted `Host`), so links rendered in the
+   * request leave its domain only for another listed one.
+   */
+  home?: string;
+  /**
+   * Set only by `@menapo/vi18n/test` on the page scope (PLAN §5.22): the
+   * message to render for every key, chosen with the descriptor that a
+   * catalog map never sees (ids and pseudo modes, messages keyed by source
+   * text). Builds never read it (INTERNALS §6 D189).
+   */
+  test?: (id: string, descriptor: CompiledDescriptor | undefined, text: string) => Message;
+  /**
+   * Dev only, set on the page scope by the in-context editor (`devtools`,
+   * INTERNALS §2.18): hears every id the page looks up. Builds fold the
+   * call away.
+   */
+  seen?: (id: string) => void;
+}
+/** Reported through `onMissing`. */
+interface MissingInfo {
+  /** The id looked up, or the source text for unprocessed calls. */
+  key: string;
+  locale: string;
+  reason: "unknown-id" | "not-loaded" | "source-mismatch" | "no-scope";
+}
+type MissingHandler = (info: MissingInfo) => void;
+/**
+ * A Temporal value (`Temporal.Instant`, `ZonedDateTime`, `PlainDate`,
+ * `PlainDateTime`, `PlainTime`, `PlainYearMonth`, `PlainMonthDay`), native or
+ * a polyfill's, recognised by its tag (PLAN §4.2): typed structurally, so
+ * runtime types need neither `lib.esnext.temporal` nor a polyfill.
+ */
+interface TemporalInput {
+  readonly [Symbol.toStringTag]: `Temporal.${string}`;
+}
+/** What the date members of `fmt` take. */
+type DateInput = Date | number | TemporalInput;
+/** `fmt` namespace members (PLAN §5.17). Every member reads the scope's locale, zone and `now`. */
+interface Fmt {
+  number(value: number | bigint, options?: Intl.NumberFormatOptions): string;
+  currency(value: number | bigint, currency: string, options?: Intl.NumberFormatOptions): string;
+  /** Minor units; fraction digits from the currency (JPY 0, USD 2, BHD 3). */
+  currencyMinor(minor: number | bigint, currency: string, options?: Intl.NumberFormatOptions): string;
+  unit(value: number, unit: string, options?: Intl.NumberFormatOptions): string;
+  compact(value: number, options?: Intl.NumberFormatOptions): string;
+  percent(value: number, options?: Intl.NumberFormatOptions): string;
+  /** Temporal values too: exact times in the scope's zone (a ZonedDateTime in its own), wall-clock values as they are. */
+  date(value: DateInput, options?: Intl.DateTimeFormatOptions): string;
+  time(value: DateInput, options?: Intl.DateTimeFormatOptions): string;
+  dateRange(start: DateInput, end: DateInput, options?: Intl.DateTimeFormatOptions): string;
+  /** Exact times: a `Date`, epoch ms, a Temporal `Instant` or `ZonedDateTime`. */
+  relative(value: DateInput, options?: Intl.RelativeTimeFormatOptions & {
+    now?: number;
+    unit?: Intl.RelativeTimeFormatUnit;
+  }): string;
+  list(items: readonly string[], options?: Intl.ListFormatOptions): string;
+  displayName(code: string, options: Intl.DisplayNamesOptions): string | undefined;
+  duration(duration: DurationInput, options?: {
+    style?: "long" | "short" | "narrow" | "digital";
+  }): string;
+  /** The locale's string order: `-1`, `0` or `1`, from a cached `Intl.Collator`. */
+  compare(a: string, b: string, options?: Intl.CollatorOptions): number;
+  /** The cached `Intl.Collator`, for `items.sort(fmt.collator().compare)`. */
+  collator(options?: Intl.CollatorOptions): Intl.Collator;
+  /** Graphemes (default), words or sentences, from a cached `Intl.Segmenter`. */
+  segment(text: string, options?: Intl.SegmenterOptions): Intl.Segments;
+}
+/** `fmt.duration` input, the `Intl.DurationFormat` record. */
+interface DurationInput {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+  milliseconds?: number;
+}
+/** The translation function's call signatures (PLAN §5.18). */
+interface TFunction {
+  <const M extends string>(message: M, ...values: ValuesOf<M>): string;
+  <const D extends Descriptor>(descriptor: D, ...values: ValuesOf<D["message"]>): string;
+  <V extends readonly unknown[]>(ref: MessageRef<V>, ...values: V): string;
+}
+/**
+ * `rich()`'s signature (PLAN §5.16): `R` is what tag handlers return,
+ * inferred from them. A choice between texts takes `never` (`OneText`); a
+ * literal message types its arguments and one handler per tag
+ * (`RichValuesOf`).
+ */
+type RichFunction = <R = unknown, const M extends MessageKey = MessageKey>(message: M & OneText<M>, ...values: RichValuesOf<M, TagHandler<R>, R>) => (string | R)[];
+/** `richHtml()`'s signature. */
+type RichHtmlFunction = <const M extends MessageKey>(message: M & OneText<M>, ...values: RichValuesOf<M, HtmlTagHandler>) => string;
+/** `richParts()`'s signature: tags become parts, so it takes no handlers. */
+type RichPartsFunction = <const M extends MessageKey>(message: M & OneText<M>, ...values: RichPartsValuesOf<M>) => RichPart[];
+/** `createTranslator()` result: the API bound to one locale, zone and `now`. */
+interface Translator {
+  readonly locale: string;
+  readonly t: TFunction;
+  readonly rich: RichFunction;
+  readonly richHtml: RichHtmlFunction;
+  readonly richParts: RichPartsFunction;
+  readonly fmt: Fmt;
+}
+declare global {
+  /**
+   * Defined by `vi18n:config` (`true` in `vite dev`, `false` in builds). Runtime
+   * code reads it as `typeof __VI18N_DEV__ !== "undefined" && __VI18N_DEV__`, so
+   * code bundled without the plugin behaves as production. `var`, not `const`:
+   * the two pack configs each inline this file into their own `.d.ts` chunk,
+   * and a consumer importing both would hit a block-scoped redeclaration.
+   */
+  var __VI18N_DEV__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether the config has `routing.paths` or
+   * `routing.domains`. Code bundled without the plugin keeps the support
+   * (`typeof __VI18N_ROUTES__ === "undefined" || __VI18N_ROUTES__`), and a
+   * plugin build of a config without either folds it out (PLAN §6).
+   */
+  var __VI18N_ROUTES__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether `ssr.payload` is `"preload"`. Code
+   * bundled without the plugin keeps the support (a Nitro-built `/server`
+   * copy reads the registration's config), and a plugin build of the default
+   * config folds it out of the engine and `/server` (PLAN §6).
+   */
+  var __VI18N_PRELOAD__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether `output.compactIds` is on. Only the
+   * plugin's boot module imports the engine, so undefined reads as false.
+   */
+  var __VI18N_COMPACT__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether `output.perLocale` is on. Undefined
+   * is false, as for `__VI18N_COMPACT__`.
+   */
+  var __VI18N_INLINE__: boolean | undefined;
+}
+//#endregion
+export { Locale as C, ValuesOf as D, RichValuesOf as E, LibraryMessages as S, RichPartsValuesOf as T, TagHandler as _, Message as a, Values as b, MissingHandler as c, RichHtmlFunction as d, RichPart as f, TFunction as g, Scope as h, HtmlTagHandler as i, MissingInfo as l, RuntimeConfig as m, Descriptor as n, MessageKey as o, RichPartsFunction as p, Fmt as r, MessageRef as s, DateInput as t, RichFunction as u, TemporalInput as v, Register as w, DefaultTags as x, Translator as y };