intor 2.3.3 → 2.3.5

package/dist/types/src/routing/locale/types.d.ts

@@ -0,0 +1,36 @@
+import type { RoutingLocaleSource } from "../../shared/types/routing";
+/** Context for locale resolution. */
+export interface LocaleContext {
+    /** Locale extracted from the URL pathname, if present */
+    path?: {
+        locale?: string;
+    };
+    /** Locale inferred from the request host, if applicable */
+    host?: {
+        locale?: string;
+    };
+    /** Locale provided via query parameters, if applicable */
+    query?: {
+        locale?: string;
+    };
+    /** Locale read from cookies, if present */
+    cookie?: {
+        locale?: string;
+    };
+    /**
+     * Fallback locale determined by the system.
+     *
+     * - This value is always available and represents the
+     * final fallback when no other source matches.
+     */
+    detected: {
+        locale: string;
+    };
+}
+/** Final resolved locale. */
+export interface ResolvedLocale {
+    /** Resolved locale identifier */
+    locale: string;
+    /** Source from which the locale was resolved */
+    localeSource: RoutingLocaleSource;
+}

package/dist/types/src/routing/pathname/index.d.ts

@@ -0,0 +1 @@
+export { resolvePathname } from "./resolve-pathname";

package/dist/types/src/routing/pathname/resolve-pathname.d.ts

@@ -0,0 +1,19 @@
+import type { IntorResolvedConfig } from "../../config";
+import type { PathnameContext, ResolvedPathname } from "../../routing/pathname/types";
+/**
+ * Resolve the final pathname based on routing configuration.
+ *
+ * - This function determines how locale prefixes should be
+ * applied to the given pathname based on `config.routing.prefix`.
+ *
+ * - It delegates the decision to a corresponding prefix
+ * strategy (`all`, `except-default`, or `none`) and derives
+ * a routing directive from the current pathname context.
+ *
+ * - The pathname is then localized into its final form,
+ * producing a single canonical pathname for the routing flow.
+ *
+ * - The result also indicates whether a redirect is required
+ * to reach the resolved pathname.
+ */
+export declare const resolvePathname: (config: IntorResolvedConfig, pathname: string, context: PathnameContext) => ResolvedPathname;

package/dist/types/src/routing/pathname/strategies/all.d.ts

@@ -0,0 +1,6 @@
+import type { PathnameContext, PathnameDirective } from "../types";
+import type { IntorResolvedConfig } from "../../../config";
+/**
+ * Resolve pathname decision for routing prefix strategy: "all".
+ */
+export declare function all(context: PathnameContext, config: IntorResolvedConfig): PathnameDirective;

package/dist/types/src/routing/pathname/strategies/except-default.d.ts

@@ -0,0 +1,6 @@
+import type { PathnameContext, PathnameDirective } from "../types";
+import type { IntorResolvedConfig } from "../../../config";
+/**
+ * Resolve pathname decision for routing prefix strategy: "except-default".
+ */
+export declare function exceptDefault(context: PathnameContext, config: IntorResolvedConfig): PathnameDirective;

package/dist/types/src/routing/pathname/strategies/index.d.ts

@@ -0,0 +1,3 @@
+export { all } from "./all";
+export { exceptDefault } from "./except-default";
+export { none } from "./none";

package/dist/types/src/routing/pathname/strategies/none.d.ts

@@ -0,0 +1,5 @@
+import type { PathnameContext, PathnameDirective } from "../types";
+/**
+ * Resolve pathname decision for routing prefix strategy: "none".
+ */
+export declare function none(context: PathnameContext): PathnameDirective;

package/dist/types/src/routing/pathname/types.d.ts

@@ -0,0 +1,28 @@
+import type { RoutingLocaleSource } from "../../shared/types/routing";
+/**
+ * Context for pathname processing.
+ *
+ * - Assumes the locale has already been resolved.
+ */
+export interface PathnameContext {
+    /** Final resolved locale (single source of truth) */
+    locale: string;
+    /** Source from which the locale was resolved */
+    localeSource: RoutingLocaleSource;
+}
+/**
+ * Directive describing how the pathname should be handled.
+ */
+export interface PathnameDirective {
+    /** Indicates whether a redirect is required */
+    type: "pass" | "redirect";
+}
+/**
+ * Final resolved pathname result.
+ */
+export interface ResolvedPathname {
+    /** Normalized pathname after applying routing rules */
+    pathname: string;
+    /** Whether a redirect should occur */
+    shouldRedirect: boolean;
+}

package/dist/types/src/routing/resolve-navigation-target.d.ts

@@ -0,0 +1,20 @@
+import type { IntorResolvedConfig } from "../config/types/intor-config.types";
+import type { Locale } from "intor-translator";
+export interface NavigationTarget {
+    /** Locale selected for this navigation */
+    locale: Locale;
+    /** Final navigation destination (app-relative or external) */
+    destination: string;
+    /** Whether the destination should bypass app routing */
+    isExternal: boolean;
+}
+/**
+ * Resolves the destination of a navigation attempt.
+ *
+ * This is pure decision logic.
+ * No side effects and no framework-specific behavior.
+ */
+export declare function resolveNavigationTarget(config: IntorResolvedConfig, currentLocale: Locale, currentPathname: string, input: {
+    destination?: string;
+    locale?: Locale;
+}): NavigationTarget;

package/dist/types/src/routing/resolve-routing.d.ts

@@ -0,0 +1,30 @@
+import type { IntorResolvedConfig } from "../config";
+import type { RoutingLocaleSource } from "../shared/types/routing";
+interface ResolveRoutingResult {
+    /** Final resolved locale */
+    locale: string;
+    /** Source from which the locale was resolved */
+    localeSource: RoutingLocaleSource;
+    /** Final resolved pathname */
+    pathname: string;
+    /** Whether a redirect is required */
+    shouldRedirect: boolean;
+}
+/**
+ * Resolves routing decision based on locale inputs and routing config.
+ *
+ * This function orchestrates locale resolution and pathname resolution
+ * as a single routing decision step.
+ *
+ * Responsibilities:
+ * - Collect locale candidates from different sources
+ * - Resolve the final locale and its source
+ * - Resolve the final pathname and redirect behavior
+ */
+export declare function resolveRouting(config: IntorResolvedConfig, pathname: string, localeInputs: {
+    host?: string;
+    query?: Record<string, string | string[] | undefined>;
+    cookie?: string;
+    detected: string;
+}): ResolveRoutingResult;
+export {};

package/dist/types/src/server/helpers/index.d.ts

@@ -0,0 +1 @@
+export { loadLocalMessagesFromUrl } from "./local-messages-from-url";

package/dist/types/src/server/helpers/local-messages-from-url.d.ts

@@ -0,0 +1,21 @@
+import type { LoadLocalMessagesExtraOptions } from "../../server/messages/load-local-messages";
+/**
+ * Load local locale messages from a URL-based query protocol.
+ *
+ * - A convenience helper for exposing local messages through a URL-accessible interface.
+ *
+ * @example
+ * ```ts
+ * const url = new URL(
+ *   "https://example.com/messages" +
+ *   "?locale=en-US" +
+ *   "&rootDir=./messages" +
+ *   "&namespaces=common" +
+ *   "&namespaces=homepage" +
+ *   "&fallbackLocales=zh-TW"
+ * );
+ *
+ * const messages = await loadLocalMessagesFromUrl(url);
+ * ```
+ */
+export declare function loadLocalMessagesFromUrl(url: URL, extraOptions?: LoadLocalMessagesExtraOptions): Promise<import("intor-translator").LocaleMessages | undefined>;

package/dist/types/src/server/index.d.ts

@@ -0,0 +1,6 @@
+export { intor, type IntorResult } from "./intor";
+export { loadMessages, isValidMessages, type Messages, type MessagesReader, } from "./messages";
+export { getTranslator } from "./translator";
+export { clearLoggerPool } from "./shared/logger/global-logger-pool";
+export { clearMessagesPool, setGlobalMessagesPool, } from "./shared/messages/global-messages-pool";
+export { loadLocalMessagesFromUrl } from "./helpers";

package/dist/types/src/server/intor/index.d.ts

@@ -0,0 +1,2 @@
+export { intor } from "./intor";
+export type { IntorResult } from "./types";

package/dist/types/src/server/intor/intor.d.ts

@@ -0,0 +1,20 @@
+import type { IntorResolvedConfig } from "../../config";
+import type { GetLocale, IntorResult } from "../../server/intor/types";
+import type { MessagesReader } from "../../server/messages";
+import type { GenConfigKeys } from "../../shared/types";
+/**
+ * Entry point for initializing Intor.
+ *
+ * This function orchestrates the initialization flow:
+ *
+ * - Resolves the initial locale using a provided locale resolver
+ * - Loads locale messages if the message loader is enabled
+ * - Returns a fully-initialized Intor result
+ *
+ * This function does not perform routing decisions itself.
+ * Locale resolution is delegated to the provided `getLocale` implementation.
+ */
+export declare const intor: <CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, getLocale: GetLocale, loadMessagesOptions?: {
+    exts?: string[];
+    messagesReader?: MessagesReader;
+}) => Promise<IntorResult<CK>>;

package/dist/types/src/server/intor/types.d.ts

@@ -0,0 +1,9 @@
+import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
+import type { GenConfigKeys, GenLocale } from "../../shared/types/generated";
+import type { LocaleMessages } from "intor-translator";
+export type GetLocale<CK extends GenConfigKeys = "__default__"> = GenLocale<CK> | ((config: IntorResolvedConfig) => GenLocale<CK> | Promise<GenLocale<CK>>);
+export interface IntorResult<CK extends GenConfigKeys = "__default__"> {
+    config: IntorResolvedConfig;
+    initialLocale: GenLocale<CK>;
+    messages: LocaleMessages;
+}

package/dist/types/src/server/messages/index.d.ts

@@ -0,0 +1,3 @@
+export { loadMessages } from "./load-messages";
+export { isValidMessages } from "./shared/utils/is-valid-messages";
+export type { Messages, MessagesReader } from "./shared/types";

package/dist/types/src/server/messages/load-local-messages/index.d.ts

@@ -0,0 +1,2 @@
+export type { LoadLocalMessagesParams, LoadLocalMessagesExtraOptions, } from "./types";
+export { loadLocalMessages } from "./load-local-messages";

package/dist/types/src/server/messages/load-local-messages/load-local-messages.d.ts

@@ -0,0 +1,15 @@
+import type { LoadLocalMessagesParams } from "./types";
+import type { LocaleMessages } from "intor-translator";
+/**
+ * Load locale messages from the local file system.
+ *
+ * This function acts as the orchestration layer for local message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Limiting concurrent file reads for performance
+ *
+ * File system traversal, parsing, and message validation are delegated to lower-level utilities.
+ */
+export declare const loadLocalMessages: ({ pool, rootDir, locale, fallbackLocales, namespaces, extraOptions: { concurrency, cacheOptions, loggerOptions, exts, messagesReader, }, allowCacheWrite, }: LoadLocalMessagesParams) => Promise<LocaleMessages | undefined>;

package/dist/{src → types/src}/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.d.ts

@@ -1,4 +1,4 @@
-import type { CollectFileEntriesOptions } from "./types";
+import type { CollectFileEntriesParams } from "./types";
 import type { FileEntry } from "../../../../../server/messages/load-local-messages/read-locale-messages";
 /**
  * Recursively collects all message files under a given root directory.
@@ -8,22 +8,13 @@ import type { FileEntry } from "../../../../../server/messages/load-local-messag
  *
  * @example
  * ```ts
- * [
- *   {
- *     namespace: "index", // "index" = messages under locale root (no namespace)
- *     fullPath: "/Users/john/my-app/messages/en-US/index.json",
- *     relativePath: "index.json",
- *     segments: ["index"],
- *     basename: "index",
- *   },
- *   {
- *     namespace: "auth",
+ * [{
+ *     namespace: "auth", // If messages under locale root (no namespace) -> "index"
  *     fullPath: "/Users/john/my-app/messages/en-US/auth/login.json",
  *     relativePath: "auth/login.json",
  *     segments: ["auth", "login"],
  *     basename: "login",
- *   },
- * ];
+ * }, ... ];
  * ```
  */
-export declare function collectFileEntries({ readdir, limit, rootDir, namespaces, extraOptions: { exts, loggerOptions }, }: CollectFileEntriesOptions): Promise<FileEntry[]>;
+export declare function collectFileEntries({ readdir, limit, rootDir, namespaces, extraOptions: { exts, loggerOptions }, }: CollectFileEntriesParams): Promise<FileEntry[]>;

package/dist/{src → types/src}/server/messages/load-local-messages/read-locale-messages/collect-file-entries/types.d.ts

@@ -1,7 +1,7 @@
 import type { LoggerOptions } from "../../../../../config/types/logger.types";
 import type fs from "node:fs/promises";
 import type { LimitFunction } from "p-limit";
-export interface CollectFileEntriesOptions {
+export interface CollectFileEntriesParams {
     readdir?: (typeof fs)["readdir"];
     limit: LimitFunction;
     rootDir: string;

package/dist/{src → types/src}/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.d.ts

@@ -1,4 +1,4 @@
-import type { ParseFileEntriesOptions } from "./types";
+import type { ParseFileEntriesParams } from "./types";
 import type { Messages } from "../../../../../server/messages/shared/types";
 /**
  * Parse locale message files (JSON or custom formats) into a unified LocaleMessages object.
@@ -31,4 +31,4 @@ import type { Messages } from "../../../../../server/messages/shared/types";
  * }
  * ```
  */
-export declare function parseFileEntries({ fileEntries, limit, extraOptions: { messagesReader, loggerOptions }, }: ParseFileEntriesOptions): Promise<Messages>;
+export declare function parseFileEntries({ fileEntries, limit, extraOptions: { messagesReader, loggerOptions }, }: ParseFileEntriesParams): Promise<Messages>;

package/dist/{src → types/src}/server/messages/load-local-messages/read-locale-messages/parse-file-entries/types.d.ts

@@ -2,7 +2,7 @@ import type { LoggerOptions } from "../../../../../config/types/logger.types";
 import type { FileEntry } from "../../../../../server/messages/load-local-messages/read-locale-messages/types";
 import type { MessagesReader, Messages } from "../../../../../server/messages/shared/types";
 import type { LimitFunction } from "p-limit";
-export interface ParseFileEntriesOptions {
+export interface ParseFileEntriesParams {
     fileEntries: FileEntry[];
     limit: LimitFunction;
     extraOptions?: {

package/dist/{src → types/src}/server/messages/load-local-messages/read-locale-messages/read-locale-messages.d.ts

@@ -1,4 +1,4 @@
-import type { ReadLocaleMessagesOptions } from "./types";
+import type { ReadLocaleMessagesParams } from "../../../../server/messages/load-local-messages/read-locale-messages/types";
 import type { LocaleMessages } from "intor-translator";
 /**
  * Read messages for a specific locale from the file system.
@@ -7,4 +7,4 @@ import type { LocaleMessages } from "intor-translator";
  * 2. Parses each file into a messages object.
  * 3. Wraps the parsed messages under the locale key.
  */
-export declare const readLocaleMessages: ({ limit, rootDir, locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions }, }: ReadLocaleMessagesOptions) => Promise<LocaleMessages>;
+export declare const readLocaleMessages: ({ limit, rootDir, locale, namespaces, extraOptions: { exts, messagesReader, loggerOptions }, }: ReadLocaleMessagesParams) => Promise<LocaleMessages>;

package/dist/{src → types/src}/server/messages/load-local-messages/read-locale-messages/types.d.ts

@@ -8,7 +8,7 @@ export interface FileEntry {
     segments: string[];
     basename: string;
 }
-export interface ReadLocaleMessagesOptions {
+export interface ReadLocaleMessagesParams {
     limit: LimitFunction;
     rootDir?: string;
     locale: string;

package/dist/types/src/server/messages/load-local-messages/types.d.ts

@@ -0,0 +1,22 @@
+import type { CacheResolvedOptions } from "../../../config/types/cache.types";
+import type { LoggerOptions } from "../../../config/types/logger.types";
+import type { MessagesReader } from "../../../server/messages/shared/types";
+import type { MessagesPool } from "../../../server/shared/messages/global-messages-pool";
+export interface LoadLocalMessagesExtraOptions {
+    concurrency?: number;
+    cacheOptions?: CacheResolvedOptions;
+    loggerOptions?: LoggerOptions & {
+        id?: string;
+    };
+    exts?: string[];
+    messagesReader?: MessagesReader;
+}
+export interface LoadLocalMessagesParams {
+    pool?: MessagesPool;
+    rootDir?: string;
+    locale: string;
+    fallbackLocales?: string[];
+    namespaces?: string[];
+    extraOptions?: LoadLocalMessagesExtraOptions;
+    allowCacheWrite?: boolean;
+}

package/dist/types/src/server/messages/load-messages.d.ts

@@ -0,0 +1,14 @@
+import type { LoadMessagesOptions, LoadMessagesResult } from "../../server/messages/types";
+import type { GenConfigKeys } from "../../shared/types/generated";
+/**
+ * Load locale messages based on the resolved Intor configuration.
+ *
+ * This function acts as a thin orchestration layer that:
+ *
+ * - Selects the appropriate message loader (local or remote)
+ * - Applies fallback locale resolution
+ * - Delegates caching and concurrency behavior to the underlying loader
+ *
+ * It does not perform message normalization or transformation itself.
+ */
+export declare const loadMessages: <CK extends GenConfigKeys = "__default__">({ config, locale, extraOptions: { exts, messagesReader }, allowCacheWrite, }: LoadMessagesOptions) => LoadMessagesResult<CK>;

package/dist/{src → types/src}/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.d.ts

@@ -6,4 +6,4 @@ import type { LocaleMessages } from "intor-translator";
  * - Validates that the returned JSON matches the expected `NamespaceMessages` structure.
  * - Uses `fetch` with `no-store` cache to always get fresh data.
  */
-export declare const fetchLocaleMessages: ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions }, }: FetcherOptions) => Promise<LocaleMessages | undefined>;
+export declare const fetchLocaleMessages: ({ remoteUrl, remoteHeaders, searchParams, locale, extraOptions: { loggerOptions }, signal, }: FetcherOptions) => Promise<LocaleMessages | undefined>;

package/dist/{src → types/src}/server/messages/load-remote-messages/fetch-locale-messages/types.d.ts

@@ -10,4 +10,5 @@ export interface FetcherOptions {
             id?: string;
         };
     };
+    signal?: AbortSignal;
 }

package/dist/types/src/server/messages/load-remote-messages/index.d.ts

@@ -0,0 +1,2 @@
+export { loadRemoteMessages } from "./load-remote-messages";
+export type { LoadRemoteMessagesParams as LoadRemoteMessagesOptions } from "./types";

package/dist/types/src/server/messages/load-remote-messages/load-remote-messages.d.ts

@@ -0,0 +1,15 @@
+import type { LoadRemoteMessagesParams } from "./types";
+import type { LocaleMessages } from "intor-translator";
+/**
+ * Load locale messages from a remote API.
+ *
+ * This function acts as the orchestration layer for remote message loading.
+ * It is responsible for:
+ *
+ * - Resolving fallback locales in order
+ * - Coordinating cache read / write behavior
+ * - Respecting abort signals across the entire async flow
+ *
+ * Network fetching and data validation are delegated to lower-level utilities.
+ */
+export declare const loadRemoteMessages: ({ pool, rootDir, locale, fallbackLocales, namespaces, remoteUrl, remoteHeaders, extraOptions: { cacheOptions, loggerOptions, }, allowCacheWrite, signal, }: LoadRemoteMessagesParams) => Promise<LocaleMessages | undefined>;

package/dist/{src → types/src}/server/messages/load-remote-messages/types.d.ts

@@ -1,12 +1,12 @@
 import type { CacheResolvedOptions } from "../../../config/types/cache.types";
 import type { RemoteHeaders } from "../../../config/types/loader.types";
 import type { LoggerOptions } from "../../../config/types/logger.types";
-import type { MessagesPool } from "../../../server/messages/shared/global-messages-pool";
-export interface LoadRemoteMessagesOptions {
+import type { MessagesPool } from "../../../server/shared/messages/global-messages-pool";
+export interface LoadRemoteMessagesParams {
     pool?: MessagesPool;
     rootDir?: string;
     locale: string;
-    fallbackLocales: string[];
+    fallbackLocales?: string[];
     namespaces?: string[];
     remoteUrl: string;
     remoteHeaders?: RemoteHeaders;
@@ -17,4 +17,5 @@ export interface LoadRemoteMessagesOptions {
         };
     };
     allowCacheWrite?: boolean;
+    signal?: AbortSignal;
 }

package/dist/{src → types/src}/server/messages/types.d.ts

@@ -1,15 +1,14 @@
 import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
 import type { MessagesReader } from "../../server/messages/shared/types";
-import type { GenConfigKeys, GenMessages } from "../../shared/types/generated.types";
+import type { GenConfigKeys, GenMessages } from "../../shared/types/generated";
 import type { Locale } from "intor-translator";
 export type LoadMessagesOptions = {
     config: IntorResolvedConfig;
     locale: Locale;
-    pathname?: string;
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;
     };
     allowCacheWrite?: boolean;
 };
-export type LoadMessagesResult<C extends GenConfigKeys = "__default__"> = Promise<GenMessages<C> | undefined>;
+export type LoadMessagesResult<CK extends GenConfigKeys = "__default__"> = Promise<GenMessages<CK> | undefined>;

package/dist/{src → types/src}/server/shared/logger/get-logger.d.ts

@@ -5,7 +5,7 @@ import type { Logger } from "logry";
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-export declare function getLogger({ id, formatterConfig, preset, ...options }: {
+export declare function getLogger({ id, formatConfig, renderConfig, preset, ...options }: {
     id?: string;
     scope?: string;
 } & LoggerOptions): Logger;

package/dist/{src/server/messages/shared → types/src/server/shared/messages}/global-messages-pool.d.ts

@@ -8,8 +8,15 @@ declare global {
     var __INTOR_MESSAGES_POOL__: MessagesPool | undefined;
 }
 export declare function getGlobalMessagesPool(): MessagesPool;
+/**
+ * Replace the global messages pool.
+ *
+ * - Intended for advanced usage (e.g. Redis, custom cache backends).
+ * - Must be called during application bootstrap.
+ */
+export declare function setGlobalMessagesPool(pool: MessagesPool): void;
 /**
  * Optional: clear all cache
- * Useful in tests or dynamic reloads.
+ * - Useful in tests or dynamic reloads.
  */
 export declare function clearMessagesPool(): void;

package/dist/{src → types/src}/server/translator/get-translator.d.ts

@@ -1,20 +1,16 @@
 import type { IntorResolvedConfig } from "../../config/types/intor-config.types";
-import type { GenConfigKeys, GenLocale, GenMessages } from "../../shared/types/generated.types";
-import type { TranslatorInstance } from "../../shared/types/translator-instance.types";
-import type { LocalizedNodeKeys, TranslateHandlers } from "intor-translator";
+import type { GenConfigKeys, GenLocale, GenMessages } from "../../shared/types/generated";
+import type { TranslatorInstance } from "../../shared/types/translator-instance";
+import type { LocalizedNodeKeys, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 import { type MessagesReader } from "../../server/messages";
 /**
- * Create a translator instance for a specific locale and pathname
- *
- * - Loads messages using the provided config, locale, and pathname.
- * - Initializes a translator with `t`, `hasKey`, and optional scoped methods.
- * - Supports optional `preKey` to create a scoped translator for nested keys.
+ * Create a translator instance for a specific locale.
  */
 export declare function getTranslator<CK extends GenConfigKeys = "__default__">(options: {
     config: IntorResolvedConfig;
-    locale: GenLocale;
-    pathname?: string;
+    locale: GenLocale<CK>;
     handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;
@@ -22,9 +18,9 @@ export declare function getTranslator<CK extends GenConfigKeys = "__default__">(
 }): Promise<TranslatorInstance<GenMessages<CK>>>;
 export declare function getTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(options: {
     config: IntorResolvedConfig;
-    locale: GenLocale;
-    pathname?: string;
+    locale: GenLocale<CK>;
     handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
     extraOptions?: {
         exts?: string[];
         messagesReader?: MessagesReader;

package/dist/types/src/shared/constants/index.d.ts

@@ -0,0 +1 @@
+export { PREFIX_PLACEHOLDER } from "./prefix-placeholder";

package/dist/{src → types/src}/shared/error/intor-error.d.ts

@@ -1,10 +1,10 @@
-type IntorErrorOptions = {
+interface IntorErrorOptions {
     message: string;
-    code?: string;
+    code?: IntorErrorCode;
     id?: string;
-};
+}
 export declare class IntorError extends Error {
-    readonly code?: string;
+    readonly code?: IntorErrorCode;
     readonly id?: string;
     constructor({ message, code, id }: IntorErrorOptions);
 }

package/dist/types/src/shared/types/generated.d.ts

@@ -0,0 +1,53 @@
+import type { PREFIX_PLACEHOLDER } from "../../shared/constants/prefix-placeholder";
+import type { LocaleMessages } from "intor-translator";
+/**
+ * ================================================
+ * Generated-aware type system for Intor.
+ *
+ * This module defines conditional and fallback types that adapt
+ * based on whether generated types are present.
+ * ================================================
+ */
+/**
+ * Internal sentinel key indicating that Intor generated types are present.
+ * - Used by conditional types to switch between fallback and generated modes.
+ * - Type-level only. Not for runtime or user-facing usage.
+ */
+export type INTOR_GENERATED_KEY = "__intor_generated__";
+/**
+ * Conditional type for generated types.
+ * - Uses key presence on `IntorGeneratedTypes` to detect generation.
+ */
+export type IfGen<Then, Else = never> = IntorGeneratedTypes extends {
+    [K in INTOR_GENERATED_KEY]: true;
+} ? Then : Else;
+/**
+ * Config keys provided by generated types.
+ * - Excludes internal sentinel
+ */
+type GeneratedConfigKeys = Exclude<keyof IntorGeneratedTypes, INTOR_GENERATED_KEY>;
+/**
+ * Union of all configuration keys.
+ * - Defaults to `string` if `IntorGeneratedTypes` does not exist.
+ */
+export type GenConfigKeys = IfGen<GeneratedConfigKeys, string>;
+/**
+ * Configuration shape for a given config key.
+ * - If `IntorGeneratedTypes` is not defined, falls back to default shape.
+ * Otherwise, picks `Locales` and `Messages` according to the key.
+ */
+export type GenConfig<CK extends GenConfigKeys> = IfGen<CK extends keyof IntorGeneratedTypes ? IntorGeneratedTypes[CK] extends {
+    Locales: infer L extends string;
+    Messages: Record<typeof PREFIX_PLACEHOLDER, infer M>;
+} ? {
+    Locales: L;
+    Messages: Record<L, M>;
+} : never : never, {
+    Locales: string;
+    Messages: LocaleMessages;
+}>;
+/** Extracts messages for a given config key */
+export type GenMessages<CK extends GenConfigKeys> = GenConfig<CK>["Messages"];
+/** Extracts locales for a given config key */
+export type GenLocale<CK extends GenConfigKeys> = GenConfig<CK>["Locales"];
+export {};

package/dist/types/src/shared/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { INTOR_GENERATED_KEY, GenConfigKeys, GenConfig, GenMessages, GenLocale, } from "./generated";
+export type { MessageKey, TranslatorInstance, KeyMode, } from "./translator-instance";

package/dist/types/src/shared/types/routing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Locale resolution sources used by routing and config.
+ *
+ * - Represents resolved data sources, not detection strategies.
+ */
+export type RoutingLocaleSource = "path" | "host" | "query" | "cookie" | "detected";