intor 2.3.29 → 2.3.31

package/dist/svelte-kit/src/server/messages/load-messages.js

@@ -0,0 +1,77 @@
+import '../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
+import { getLogger } from '../../core/logger/get-logger.js';
+import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
+import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
+
+/**
+ * Load locale messages according to the resolved Intor loader configuration.
+ *
+ * This function is the top-level orchestration entry for message loading.
+ * It is responsible for:
+ *
+ * - Resolving the active loader strategy (local or remote)
+ * - Dispatching to the appropriate loader implementation
+ * - Passing through cache and read-related options
+ *
+ * Message traversal, parsing, fallback resolution, and caching logic
+ * are delegated to the selected loader.
+ */
+const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
+    const baseLogger = getLogger(config.logger);
+    const logger = baseLogger.child({ scope: "load-messages" });
+    // ---------------------------------------------------------------------------
+    // Resolve loader configuration
+    // ---------------------------------------------------------------------------
+    const loader = resolveLoaderOptions(config, "server");
+    if (!loader) {
+        logger.warn("No loader options have been configured in the current config.");
+        return;
+    }
+    const { type, namespaces, concurrency } = loader;
+    const fallbackLocales = config.fallbackLocales[locale] || [];
+    logger.info(`Loading messages for locale "${locale}".`);
+    logger.trace("Starting to load messages with runtime context.", {
+        loaderType: type,
+        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
+        locale,
+        fallbackLocales: fallbackLocales.join(", "),
+        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
+    });
+    // ---------------------------------------------------------------------------
+    // Dispatch to loader implementation
+    // ---------------------------------------------------------------------------
+    let loadedMessages;
+    if (type === "local") {
+        loadedMessages = await loadLocalMessages({
+            id: config.id,
+            locale,
+            fallbackLocales,
+            namespaces,
+            rootDir: loader.rootDir,
+            concurrency,
+            readers,
+            allowCacheWrite,
+            loggerOptions: config.logger,
+        });
+    }
+    else if (type === "remote") {
+        loadedMessages = await loadRemoteMessages({
+            locale,
+            fallbackLocales,
+            namespaces,
+            concurrency,
+            fetch,
+            url: loader.url,
+            headers: loader.headers,
+            loggerOptions: config.logger,
+        });
+    }
+    // Final sanity check
+    if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
+        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
+    }
+    return loadedMessages;
+};
+
+export { loadMessages };

package/dist/svelte-kit/src/server/translator/create-translator.js

@@ -0,0 +1,40 @@
+import { Translator } from 'intor-translator';
+import { mergeMessages } from '../../core/messages/merge-messages.js';
+
+/**
+ * Create a server-side translator snapshot.
+ *
+ * - Merges static config messages with runtime-loaded messages
+ * - Creates a Translator instance for a fixed locale
+ * - Optionally scopes the translator with a preKey
+ *
+ * The returned object is a read-only translation view
+ * and does not expose the underlying Translator instance.
+ */
+function createTranslator(params) {
+    const { config, locale, messages, preKey, handlers, plugins } = params;
+    // Merge static config messages with runtime-loaded messages
+    const finalMessages = mergeMessages(config.messages, messages, {
+        config,
+        locale,
+    });
+    const translator = new Translator({
+        locale,
+        messages: finalMessages,
+        fallbackLocales: config.fallbackLocales,
+        loadingMessage: config.translator?.loadingMessage,
+        missingMessage: config.translator?.missingMessage,
+        handlers,
+        plugins,
+    });
+    // Apply scoped view when preKey is provided
+    const scoped = preKey ? translator.scoped(preKey) : null;
+    return {
+        messages: finalMessages,
+        locale,
+        hasKey: scoped ? scoped.hasKey : translator.hasKey,
+        t: scoped ? scoped.t : translator.t,
+    };
+}
+
+export { createTranslator };

package/dist/svelte-kit/src/server/translator/init-translator.js

@@ -0,0 +1,42 @@
+import '../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
+import 'logry';
+import 'p-limit';
+import { loadMessages } from '../messages/load-messages.js';
+import 'node:path';
+import 'node:fs/promises';
+import { createTranslator } from './create-translator.js';
+
+/**
+ * Initializes a server-side translator for a specific locale.
+ *
+ * - Performs message loading during initialization.
+ * - Returns an immutable translator snapshot.
+ */
+async function initTranslator(config, locale, options) {
+    const { readers, allowCacheWrite = false, fetch, preKey, handlers, plugins, } = options;
+    const loader = resolveLoaderOptions(config, "server");
+    // Load messages
+    let messages = {};
+    if (loader) {
+        const loaded = await loadMessages({
+            config,
+            locale,
+            readers,
+            allowCacheWrite,
+            fetch,
+        });
+        messages = loaded || {};
+    }
+    // Create immutable translator snapshot
+    return createTranslator({
+        config,
+        locale,
+        messages,
+        preKey,
+        handlers,
+        plugins,
+    });
+}
+
+export { initTranslator };

package/dist/types/export/next/index.d.ts

@@ -1 +1 @@
-export { Link, usePathname, useRouter, redirect, } from "../../src/adapters/next/navigation";
+export { Link, useRouter, redirect } from "../../src/adapters/next/navigation";

package/dist/types/export/next/server/index.d.ts

@@ -1 +1 @@
-export { intor, getLocale, getPathname, getTranslator, } from "../../../src/adapters/next/server";
+export { intor, getLocale, getTranslator } from "../../../src/adapters/next/server";

package/dist/types/export/react/index.d.ts

@@ -1,2 +1,2 @@
-export { IntorProvider, type IntorProviderProps, useIntorContext, // Internal hook.
-useTranslator, Trans, useResolveNavigation, useExecuteNavigation, useIntor, getClientLocale, } from "../../src/client/react";
+export { IntorProvider, type IntorProviderProps, useIntorContext, // @internal
+useTranslator, Trans, useIntor, getClientLocale, } from "../../src/client/react";

package/dist/types/export/svelte/index.d.ts

@@ -1 +1,3 @@
-export { createIntorStore, type IntorStore, createIntor, getClientLocale, } from "../../src/client/svelte";
+export { createIntorStore, // @internal
+IntorProvider, useIntorContext, // @internal
+useTranslator, getClientLocale, } from "../../src/client/svelte";

package/dist/types/export/svelte-kit/index.d.ts

@@ -0,0 +1 @@
+export { useNavigation } from "../../src/adapters/svelte-kit/navigation";

package/dist/types/export/svelte-kit/server/index.d.ts

@@ -0,0 +1 @@
+export { createIntorHandle, intor } from "../../../src/adapters/svelte-kit/server";

package/dist/types/src/adapters/express/global.d.ts

@@ -1,17 +1,14 @@
-import type { TranslatorInstance, RoutingLocaleSource } from "../../core";
-import type { LocaleMessages, Replacement } from "intor-translator";
+import type { TranslatorInstance } from "../../core";
+import type { InboundContext } from "../../routing";
+import type { Locale, LocaleMessages, Replacement } from "intor-translator";
 /**
  * Global type augmentations for Express request
  */
 declare global {
     namespace Express {
         interface Request {
-            intor: {
-                locale: string;
-                localeSource: RoutingLocaleSource;
-                pathname: string;
-            };
-            locale: string;
+            intor: InboundContext;
+            locale: Locale;
             hasKey: TranslatorInstance<LocaleMessages, Replacement, "string">["hasKey"];
             t: TranslatorInstance<LocaleMessages, Replacement, "string">["t"];
         }

package/dist/types/src/adapters/next/navigation/index.d.ts

@@ -1,4 +1,3 @@
 export { Link } from "./link";
-export { usePathname } from "./use-pathname";
 export { useRouter } from "./use-router";
 export { redirect } from "./redirect";

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

@@ -1,4 +1,3 @@
 export { intor } from "./intor";
 export { getLocale } from "./get-locale";
-export { getPathname } from "./get-pathname";
 export { getTranslator } from "./get-translator";

package/dist/types/src/adapters/svelte-kit/navigation/index.d.ts

@@ -0,0 +1 @@
+export { useNavigation } from "./use-navigation";

package/dist/types/src/adapters/svelte-kit/navigation/use-navigation.d.ts

@@ -0,0 +1,15 @@
+import type { GenConfigKeys, GenLocale } from "../../../core";
+import { goto as svelteGoto } from "$app/navigation";
+/**
+ * Locale-aware navigation utilities for SvelteKit.
+ *
+ * Provides imperative navigation helpers that integrate
+ * Intor's locale-aware routing and side effects.
+ *
+ * @platform SvelteKit
+ */
+export declare function useNavigation<CK extends GenConfigKeys = "__default__">(): {
+    goto: (url: string, opts?: Parameters<typeof svelteGoto>[1] & {
+        locale?: GenLocale<CK>;
+    }) => Promise<void>;
+};

package/dist/types/src/adapters/svelte-kit/server/create-intor-handle.d.ts

@@ -0,0 +1,12 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { Handle } from "@sveltejs/kit";
+/**
+ * Resolves locale-aware routing for the current execution context.
+ *
+ * The resolved routing state is exposed via response headers.
+ *
+ * - Acts as the canonical routing authority within the SvelteKit request lifecycle.
+ *
+ * @platform SvelteKit
+ */
+export declare function createIntorHandle(config: IntorResolvedConfig): Handle;

package/dist/types/src/adapters/svelte-kit/server/index.d.ts

@@ -0,0 +1,2 @@
+export { createIntorHandle } from "./create-intor-handle";
+export { intor } from "./intor";

package/dist/types/src/adapters/svelte-kit/server/intor.d.ts

@@ -0,0 +1,16 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { MessagesReaders, RuntimeFetch } from "../../../core";
+import type { Locale } from "intor-translator";
+import { type GenConfigKeys } from "../../../core";
+import { type IntorValue } from "../../../server";
+/**
+ * Initializes Intor for the current execution context.
+ *
+ * - Uses the locale resolved by the SvelteKit request lifecycle.
+ * - Permits cache writes during server execution.
+ * @platform SvelteKit
+ */
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, locale: Locale, fetch: RuntimeFetch, options?: {
+    readers?: MessagesReaders;
+    allowCacheWrite?: boolean;
+}): Promise<IntorValue<CK>>;

package/dist/types/src/adapters/svelte-kit/server/utils/is-svelte-kit-ssg.d.ts

@@ -0,0 +1,8 @@
+import type { RequestEvent } from "@sveltejs/kit";
+/**
+ * Heuristic to detect static (prerender) execution in SvelteKit.
+ *
+ * This is NOT a guaranteed signal.
+ * It intentionally prefers false positives over false negatives.
+ */
+export declare function isSvelteKitSSG(event: RequestEvent<Record<string, string>, string | null>): boolean;

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

@@ -0,0 +1 @@
+export { executeNavigation } from "./shared/navigation";

package/dist/types/src/client/react/index.d.ts

@@ -1,5 +1,4 @@
 export { IntorProvider, type IntorProviderProps, useIntorContext, } from "./provider";
 export { useTranslator, Trans } from "./translator";
-export { useResolveNavigation, useExecuteNavigation } from "./navigation";
 export { useIntor } from "./helpers";
 export { getClientLocale } from "../shared/helpers";

package/dist/types/src/client/shared/navigation/execute-navigation.d.ts

@@ -0,0 +1,19 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { NavigationResult } from "../../../routing";
+interface NavigationExecutionContext {
+    config: IntorResolvedConfig;
+    currentLocale: string;
+    setLocale(locale: string): void;
+}
+/**
+ * Executes a resolved navigation result.
+ *
+ * Applies all imperative side effects required to complete navigation,
+ * including locale synchronization, cookie persistence, and full reloads.
+ *
+ * This function must be called after `resolveNavigation`.
+ */
+export declare function executeNavigation(navigationResult: NavigationResult, context: NavigationExecutionContext, e?: {
+    preventDefault(): void;
+}): void;
+export {};

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

@@ -0,0 +1 @@
+export { executeNavigation } from "./execute-navigation";

package/dist/types/src/client/svelte/index.d.ts

@@ -1,3 +1,3 @@
-export { createIntorStore, type IntorStore } from "./store";
-export { createIntor } from "./helpers";
+export { createIntorStore, IntorProvider, useIntorContext } from "./provider";
+export { useTranslator } from "./translator";
 export { getClientLocale } from "../shared/helpers";

package/dist/types/src/client/svelte/provider/create-intor-store.d.ts

@@ -0,0 +1,3 @@
+import type { IntorValue } from "./types";
+export declare const INTOR_CONTEXT_KEY: unique symbol;
+export declare function createIntorStore({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }: IntorValue): void;

package/dist/types/src/client/svelte/provider/index.d.ts

@@ -0,0 +1,3 @@
+export { createIntorStore } from "./create-intor-store";
+export { default as IntorProvider } from "./intor-provider.svelte";
+export { useIntorContext } from "./use-intor-context";

package/dist/types/src/client/svelte/provider/types.d.ts

@@ -0,0 +1,18 @@
+import type { IntorResolvedConfig } from "../../../config";
+import type { Locale, TranslateHandlers, TranslateHook, TranslatorPlugin, Translator, LocaleMessages } from "intor-translator";
+import type { Readable, Writable } from "svelte/store";
+export interface IntorValue {
+    config: IntorResolvedConfig;
+    locale: Locale;
+    messages?: Readonly<LocaleMessages>;
+    isLoading?: boolean;
+    onLocaleChange?: (newLocale: Locale) => Promise<void> | void;
+    handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
+}
+export interface IntorContextValue {
+    config: IntorResolvedConfig;
+    locale: Writable<Locale>;
+    setLocale: (locale: Locale) => void;
+    translator: Readable<Translator<unknown>>;
+}

package/dist/types/src/client/svelte/provider/use-intor-context.d.ts

@@ -0,0 +1,2 @@
+import type { IntorContextValue } from "./types";
+export declare function useIntorContext(): IntorContextValue;

package/dist/types/src/client/svelte/render/types.d.ts

@@ -1,14 +1,8 @@
-import type { Attributes } from "intor-translator";
-/**
- * A renderer for a semantic tag in a rich message.
- */
-type SvelteTagRenderer = (children: string[], attributes: Attributes) => string;
-/**
- * A mapping of semantic tag names to Svelte renderers.
- *
- * Each entry can be either:
- * - A render function that receives children and attributes
- * - A static HTML string, used as-is for the tag
- */
-export type SvelteTagRenderers = Record<string, SvelteTagRenderer | string>;
+import type { Rich } from "intor-translator";
+/** Renderer function for a semantic rich tag. */
+type SvelteTagRenderer = ((children: string[]) => string) | string;
+/** Mapping of semantic rich tags to Svelte renderers. */
+export type SvelteTagRenderers<RichSchema = Rich> = {
+    [K in keyof RichSchema]: SvelteTagRenderer;
+} & Record<string, SvelteTagRenderer>;
 export {};

package/dist/types/src/client/svelte/translator/create-t-rich.d.ts

@@ -0,0 +1,15 @@
+import type { SvelteTagRenderers } from "../render";
+import type { Replacement, Translator } from "intor-translator";
+/**
+ * Create a Svelte-specific rich translation function.
+ *
+ * This adapter bridges the core Translator with the Svelte rich
+ * message rendering flow.
+ *
+ * - Resolves translated messages via `translator.t`
+ * - Renders semantic tags using Svelte renderers
+ * - Supports optional scoped keys via `preKey`
+ *
+ * Intended for Svelte client usage only.
+ */
+export declare const createTRich: (translator: Translator, preKey?: string) => (key: string, tagRenderers?: SvelteTagRenderers, replacements?: Replacement) => string;

package/dist/types/src/client/svelte/translator/index.d.ts

@@ -0,0 +1 @@
+export { useTranslator } from "./use-translator";

package/dist/types/src/client/svelte/translator/translator-instance.d.ts

@@ -0,0 +1,20 @@
+import type { SvelteTagRenderers } from "../render";
+import type { TranslatorInstance } from "../../../core";
+import type { Readable, Writable } from "svelte/store";
+import { type Locale, type LocaleMessages, type LocalizedKey, type LocalizedReplacement, type LocalizedRich, type Replacement, type Rich, type ScopedKey } from "intor-translator";
+export type TranslatorInstanceSvelte<M extends LocaleMessages, ReplacementSchema = Replacement, RichSchema = Rich, PK extends string | undefined = undefined> = {
+    /** `messages`: The message object containing all translations. */
+    messages: Readable<M>;
+    /** Current locale in use. */
+    locale: Writable<Locale<M>>;
+    /** Indicates whether translations are currently loading. */
+    isLoading: Readable<boolean>;
+    /** Update the active locale. */
+    setLocale: (locale: Locale<M>) => void;
+    /** Check if a given key exists in the messages. */
+    hasKey: Readable<TranslatorInstance<M, ReplacementSchema, PK>["hasKey"]>;
+    /** Translate a given key into its string representation. */
+    t: Readable<TranslatorInstance<M, ReplacementSchema, PK>["t"]>;
+    /** Translate a key into an HTML string using semantic rich tags. */
+    tRich: Readable<(<K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = LocalizedRich<RichSchema, K>, RE = LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: SvelteTagRenderers<RI>, replacements?: RE | Replacement) => string)>;
+};

package/dist/types/src/client/svelte/translator/use-translator.d.ts

@@ -0,0 +1,8 @@
+import type { TranslatorInstanceSvelte } from "./translator-instance";
+import type { GenConfigKeys, GenMessages, GenReplacements, GenRich } from "../../../core";
+import type { LocalizedPreKey } from "intor-translator";
+/**
+ * Svelte utility for accessing the active Intor translator instance.
+ */
+export declare function useTranslator<CK extends GenConfigKeys = "__default__", ReplacementSchema = GenReplacements<CK>, RichSchema = GenRich<CK>>(): TranslatorInstanceSvelte<GenMessages<CK>, ReplacementSchema, RichSchema, undefined>;
+export declare function useTranslator<CK extends GenConfigKeys = "__default__", ReplacementSchema = GenReplacements<CK>, RichSchema = GenRich<CK>, PK extends string = LocalizedPreKey<GenMessages<CK>>>(preKey?: PK): TranslatorInstanceSvelte<GenMessages<CK>, ReplacementSchema, RichSchema, PK>;

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

@@ -3,4 +3,4 @@ export { IntorError, IntorErrorCode } from "./error";
 export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, resolveLoaderOptions, normalizePathname, normalizeCacheKey, normalizeLocale, normalizeQuery, } from "./utils";
 export { getLogger, clearLoggerPool } from "./logger";
 export { loadRemoteMessages, mergeMessages, isValidMessages, nestObjectFromPath, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "./messages";
-export type { INTOR_GENERATED_KEY, IfGen, GenConfigKeys, GenConfig, GenMessages, GenLocale, GenReplacements, GenRich, TranslatorInstance, RoutingLocaleSource, RoutingLocaleCarrier, LocalePathPrefix, } from "./types";
+export type { INTOR_GENERATED_KEY, IfGen, GenConfigKeys, GenConfig, GenMessages, GenLocale, GenReplacements, GenRich, TranslatorInstance, RoutingLocaleSource, RoutingLocaleCarrier, LocalePathPrefix, RuntimeFetch, } from "./types";

package/dist/types/src/core/messages/load-remote-messages/fetch-remote-resource.d.ts

@@ -1,6 +1,8 @@
+import type { RuntimeFetch } from "../../types";
 import type { RemoteHeaders, LoggerOptions } from "../../../config";
 import type { MessageObject } from "intor-translator";
 interface FetchLocaleMessagesParams {
+    fetch: RuntimeFetch;
     url: string;
     headers?: RemoteHeaders;
     signal?: AbortSignal;
@@ -17,5 +19,5 @@ interface FetchLocaleMessagesParams {
  * - Validating the returned message structure
  * - Handling abort and network errors
  */
-export declare function fetchRemoteResource({ url, headers, signal, loggerOptions, }: FetchLocaleMessagesParams): Promise<MessageObject | undefined>;
+export declare function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }: FetchLocaleMessagesParams): Promise<MessageObject | undefined>;
 export {};

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

@@ -14,4 +14,4 @@ import type { LocaleMessages } from "intor-translator";
  *
  * Network requests and response validation are delegated to lower-level utilities.
  */
-export declare const loadRemoteMessages: ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }: LoadRemoteMessagesParams) => Promise<LocaleMessages | undefined>;
+export declare const loadRemoteMessages: ({ locale, fallbackLocales, namespaces, concurrency, fetch, url: baseUrl, headers, signal, loggerOptions, }: LoadRemoteMessagesParams) => Promise<LocaleMessages | undefined>;

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

@@ -1,9 +1,11 @@
+import type { RuntimeFetch } from "../../types";
 import type { RemoteHeaders, LoggerOptions } from "../../../config";
 export interface LoadRemoteMessagesParams {
     locale: string;
     fallbackLocales?: string[];
     namespaces?: string[];
     concurrency?: number;
+    fetch: RuntimeFetch;
     url: string;
     headers?: RemoteHeaders;
     signal?: AbortSignal;

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

@@ -1,3 +1,4 @@
 export type { INTOR_GENERATED_KEY, IfGen, GenConfigKeys, GenConfig, GenMessages, GenLocale, GenReplacements, GenRich, } from "./generated";
 export type { TranslatorInstance } from "./translator-instance";
 export type { RoutingLocaleSource, RoutingLocaleCarrier, LocalePathPrefix, } from "./routing";
+export type { RuntimeFetch } from "./runtime-fetch";

package/dist/types/src/core/types/runtime-fetch.d.ts

@@ -0,0 +1 @@
+export type RuntimeFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;

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

@@ -1 +1,2 @@
 export { resolveInbound } from "./resolve-inbound";
+export type { InboundContext } from "./types";

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

@@ -1,15 +1,5 @@
+import type { ResolveInboundResult } from "./types";
 import type { IntorResolvedConfig } from "../../config";
-import type { RoutingLocaleSource } from "../../core";
-interface ResolveInboundResult {
-    /** Resolved locale */
-    locale: string;
-    /** Locale source used for resolution */
-    localeSource: RoutingLocaleSource;
-    /** Localized pathname */
-    pathname: string;
-    /** Whether redirect is required */
-    shouldRedirect: boolean;
-}
 /**
  * Resolves inbound routing state.
  *
@@ -25,4 +15,3 @@ export declare function resolveInbound(config: IntorResolvedConfig, rawPathname:
     cookie?: string;
     detected: string;
 }): Promise<ResolveInboundResult>;
-export {};

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

@@ -0,0 +1,12 @@
+import type { RoutingLocaleSource } from "../../core";
+export interface ResolveInboundResult {
+    /** Resolved locale */
+    locale: string;
+    /** Locale source used for resolution */
+    localeSource: RoutingLocaleSource;
+    /** Localized pathname */
+    pathname: string;
+    /** Whether redirect is required */
+    shouldRedirect: boolean;
+}
+export type InboundContext = Pick<ResolveInboundResult, "locale" | "pathname" | "localeSource">;

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

@@ -1,4 +1,4 @@
-export { resolveInbound } from "./inbound";
+export { resolveInbound, type InboundContext } from "./inbound";
 export { localizePathname, type LocalizedPathname } from "./pathname";
 export { getLocaleFromAcceptLanguage, getLocaleFromPathname, getLocaleFromHost, getLocaleFromQuery, } from "./locale";
 export { resolveNavigation, type NavigationResult } from "./navigation";

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

@@ -2,6 +2,8 @@ import type { IntorResolvedConfig } from "../../config";
 /**
  * Returns a canonical, locale-agnostic pathname.
  *
+ * Accepts `{locale}` as a locale placeholder segment.
+ *
  * @example
  * ```ts
  * // config.supportedLocales: ["en-US"]

package/dist/types/src/server/helpers/get-translator.d.ts

@@ -1,11 +1,12 @@
 import type { TranslatorInstanceServer } from "../translator/translator-instance";
 import type { IntorResolvedConfig } from "../../config";
-import type { GenConfigKeys, GenMessages, GenReplacements, MessagesReaders } from "../../core";
+import type { GenConfigKeys, GenMessages, GenReplacements, MessagesReaders, RuntimeFetch } from "../../core";
 import type { LocalizedPreKey, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 export interface GetTranslatorParams {
     locale: string;
     readers?: MessagesReaders;
     allowCacheWrite?: boolean;
+    fetch?: RuntimeFetch;
     handlers?: TranslateHandlers;
     plugins?: (TranslatorPlugin | TranslateHook)[];
 }

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

@@ -1,14 +1,15 @@
-import type { LocaleResolver, IntorValue } from "./types";
+import type { IntorValue } from "./types";
 import type { IntorResolvedConfig } from "../../config";
 import type { Locale } from "intor-translator";
-import { type GenConfigKeys, type MessagesReaders } from "../../core";
+import { type GenConfigKeys, type MessagesReaders, type RuntimeFetch } from "../../core";
 /**
  * Initializes Intor for the current execution context.
  *
  * Produces a server-side snapshot for SSR and
  * full-stack rendering environments.
  */
-export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, localeOrResolver: LocaleResolver | Locale, options?: {
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, locale: Locale, options?: {
     readers?: MessagesReaders;
     allowCacheWrite?: boolean;
+    fetch?: RuntimeFetch;
 }): Promise<IntorValue<CK>>;

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

@@ -1,7 +1,5 @@
 import type { IntorResolvedConfig } from "../../config";
-import type { Locale } from "intor-translator";
 import { type GenConfigKeys, type GenLocale, type GenMessages } from "../../core";
-export type LocaleResolver = (config: IntorResolvedConfig) => Locale | Promise<Locale>;
 export interface IntorValue<CK extends GenConfigKeys = "__default__"> {
     config: IntorResolvedConfig;
     locale: GenLocale<CK>;

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

@@ -13,4 +13,4 @@ import type { LocaleMessages } from "intor-translator";
  * Message traversal, parsing, fallback resolution, and caching logic
  * are delegated to the selected loader.
  */
-export declare const loadMessages: ({ config, locale, readers, allowCacheWrite, }: LoadMessagesParams) => Promise<LocaleMessages | undefined>;
+export declare const loadMessages: ({ config, locale, readers, allowCacheWrite, fetch, }: LoadMessagesParams) => Promise<LocaleMessages | undefined>;

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

@@ -1,5 +1,5 @@
 import type { IntorResolvedConfig } from "../../config";
-import type { MessagesReaders } from "../../core";
+import type { MessagesReaders, RuntimeFetch } from "../../core";
 import type { Locale } from "intor-translator";
 export type LoadMessagesParams = {
     config: IntorResolvedConfig;
@@ -10,4 +10,5 @@ export type LoadMessagesParams = {
      * write into the shared messages cache.
      */
     allowCacheWrite?: boolean;
+    fetch: RuntimeFetch;
 };