akanjs 3.1.0 → 3.1.1-rc.1

package/base/primitiveRegistry.ts

@@ -1,3 +1,6 @@
+
+
+import "dayjs/locale/ko";
 import dayjsLib, { type Dayjs } from "dayjs";
 import { CLIENT_VALUE, DEFAULT_VALUE, EXAMPLE_VALUE, PURIFIED_VALUE, SERVER_VALUE } from "./symbols";
 import type { Cls } from "./types";

package/client/cookie.ts

@@ -2,14 +2,19 @@ import { getEnv } from "akanjs/base";
 import {
   authTokenKey,
   bearerTokenOf,
+  type CookieEntry,
+  CookieJar,
+  CookieSweep,
   decodeJwtPayload,
   isOwnAuthToken,
   Logger,
   legacyAuthTokenKey,
-  readAuthToken,
+  readSessionToken,
+  retiredAuthTokenKeys,
+  SessionCookies,
 } from "akanjs/common";
 import type { Account } from "akanjs/fetch";
-import { parseCookieHeader, cookies as serverCookies, headers as serverHeaders } from "akanjs/fetch";
+import { cookieJar as serverCookieJar, headers as serverHeaders } from "akanjs/fetch";
 import { secretStorage } from "./storage";
 import { fetch } from "./useClient";
 
@@ -24,26 +29,35 @@ const isCsrClient = () => {
   return env.side === "client" && env.renderMode === "csr";
 };
 
-const cookieJarKey = "akan:cookies";
-const pageKeepsCookies = () => (globalThis as { location?: Location }).location?.protocol !== "app:";
-const readCookieJar = (): Record<string, string> => {
+const storedCookiesKey = "akan:cookies";
+const pageLocation = () => (globalThis as { location?: Location }).location;
+const pageKeepsCookies = () => pageLocation()?.protocol !== "app:";
+const readStoredCookies = (): Record<string, string> => {
   try {
-    return JSON.parse(localStorage.getItem(cookieJarKey) ?? "{}") as Record<string, string>;
+    return JSON.parse(localStorage.getItem(storedCookiesKey) ?? "{}") as Record<string, string>;
   } catch {
     return {};
   }
 };
-const writeCookieJar = (jar: Record<string, string>) => {
-  localStorage.setItem(cookieJarKey, JSON.stringify(jar));
+const writeStoredCookies = (stored: Record<string, string>) => {
+  localStorage.setItem(storedCookiesKey, JSON.stringify(stored));
 };
 
-export const cookies = (): Map<string, { name: string; value: string }> => {
-  if (getEnv().side === "server") return serverCookies();
+/** Every cookie this page or request holds, a name sent more than once included. */
+export const cookieJar = (): CookieJar => {
+  if (getEnv().side === "server") return serverCookieJar();
   if (!pageKeepsCookies())
-    return new Map(Object.entries(readCookieJar()).map(([name, value]) => [name, { name, value }]));
-  return parseCookieHeader(document.cookie);
+    return CookieJar.parse(
+      Object.entries(readStoredCookies())
+        .map(([name, value]) => `${name}=${value}`)
+        .join("; "),
+    );
+  return CookieJar.parse(document.cookie);
 };
 
+/** Names held exactly once; a duplicated name is left out. */
+export const cookies = (): Map<string, CookieEntry> => cookieJar().toMap();
+
 export const setCookie = (
   key: string,
   value: string,
@@ -51,7 +65,7 @@ export const setCookie = (
 ) => {
   if (getEnv().side === "server") return;
   if (!pageKeepsCookies()) {
-    writeCookieJar({ ...readCookieJar(), [key]: value });
+    writeStoredCookies({ ...readStoredCookies(), [key]: value });
     return;
   }
   const pathAttr = path ? `; path=${path}` : "";
@@ -60,19 +74,21 @@ export const setCookie = (
   document.cookie = `${key}=${value}${pathAttr}; SameSite=${sameSite}${secureAttr}`;
 };
 
-/** Reads through `cookies()` on both sides: a hand-rolled `split("=")` cuts base64 padding and skips the `j:` form. */
-export const getCookie = (key: string): string | undefined => cookies().get(key)?.value;
+/** `undefined` for a name held more than once, as for one never set. */
+export const getCookie = (key: string): string | undefined => cookieJar().read(key).value;
 
 export const removeCookie = (key: string, options: { path: string } = { path: "/" }) => {
   
   if (getEnv().side === "server") return;
   if (!pageKeepsCookies()) {
-    const { [key]: _removed, ...rest } = readCookieJar();
-    writeCookieJar(rest);
+    const { [key]: _removed, ...rest } = readStoredCookies();
+    writeStoredCookies(rest);
     return;
   }
   
-  document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${options.path};`;
+  const secureAttr = /^__(Host|Secure)-/.test(key) ? " Secure;" : "";
+  
+  document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${options.path};${secureAttr}`;
 };
 export const headers = (): Map<string, string> => {
   if (getEnv().side !== "server") return new Map();
@@ -95,17 +111,15 @@ const sentAuthToken = (): string | undefined => {
 };
 
 /** The auth token this app holds: on a CSR client the one `fetch` sends first, since a native shell's page keeps no
- * session cookie; then the cookie jar, under the app-scoped key or a legacy global one. */
+ * session cookie; then the app-scoped cookie, unless it is held more than once. */
 export const getAuthToken = (): string | undefined =>
-  (isCsrClient() ? sentAuthToken() : undefined) ?? readAuthToken(getCookie);
+  (isCsrClient() ? sentAuthToken() : undefined) ?? readSessionToken(cookieJar()).token;
 
 /** The auth token this app holds in client storage — the OS credential store in a native app, localStorage elsewhere. */
-export const getStoredAuthToken = async (): Promise<string | undefined> => {
-  const scoped = await secretStorage.getItem(authTokenKey());
-  if (scoped) return scoped;
-  const legacy = await secretStorage.getItem(legacyAuthTokenKey);
-  return legacy && isOwnAuthToken(legacy) ? legacy : undefined;
-};
+export const getStoredAuthToken = async (): Promise<string | undefined> =>
+  (await secretStorage.getItem(storedAuthTokenKey())) ?? undefined;
+
+const storedAuthTokenKey = () => `${legacyAuthTokenKey}:${getEnv().appName}`;
 
 /** The current JWT's account when minted for this app and environment. Reads only the two credentials the server
  * honours — the app-scoped auth cookie (a CSR client's bearer token) and `Authorization: Bearer` — so the two never
@@ -136,9 +150,9 @@ export const setAuth = ({ jwt }: SetAuthOption) => {
   fetch.setJwt(jwt);
   
   if (!isCsrClient()) setCookie(authTokenKey(), jwt);
-  void secretStorage.setItem(authTokenKey(), jwt);
+  void secretStorage.setItem(storedAuthTokenKey(), jwt);
   
-  removeCookie(legacyAuthTokenKey);
+  for (const key of retiredAuthTokenKeys()) removeCookie(key);
   void secretStorage.removeItem(legacyAuthTokenKey);
   announceAuth();
 };
@@ -146,25 +160,56 @@ export const setAuth = ({ jwt }: SetAuthOption) => {
 interface InitAuthOption {
   jwt?: string;
 }
+
+const sweepDocumentCookies = (names: string[]) => {
+  const { hostname = "", pathname = "/" } = pageLocation() ?? {};
+  
+  for (const entry of CookieSweep.setCookies({ names, host: hostname, path: pathname })) document.cookie = entry;
+};
+
+const readCookieSession = (): string | null | undefined => {
+  const first = readSessionToken(cookieJar());
+  if (!first.duplicate) return first.token;
+  SessionCookies.report([first.duplicate], pageLocation()?.host ?? "");
+  sweepDocumentCookies([first.duplicate.name]);
+  const second = readSessionToken(cookieJar());
+  return second.duplicate ? null : second.token;
+};
+
+const expireRetiredCookies = () => {
+  const jar = cookieJar();
+  for (const key of retiredAuthTokenKeys()) if (jar.has(key)) removeCookie(key);
+};
+
 export const initAuth = ({ jwt }: InitAuthOption = {}) => {
-  const stored = getAuthToken();
-  const token = jwt ?? stored;
+  expireRetiredCookies();
+  const sent = jwt ?? (isCsrClient() ? sentAuthToken() : undefined);
+  const token = sent ?? readCookieSession();
+  if (token === null) {
+    fetch.setJwt(null);
+    return;
+  }
   if (token && !isOwnAuthToken(token)) {
     
     Logger.warn("JWT ignored: it was minted for another app or environment");
-    if (token === stored) resetAuth();
+    if (!jwt) resetAuth();
     return;
   }
-  if (token) setAuth({ jwt: token });
+  if (token && sent) setAuth({ jwt: token });
+  else if (token) {
+    
+    fetch.setJwt(token);
+    announceAuth();
+  }
   
-  Logger.verbose(`JWT ${token ? "restored from cookie" : "not found in cookie"}`);
+  Logger.verbose(`JWT ${token ? "restored" : "not found"}`);
 };
 
 export const resetAuth = () => {
   fetch.setJwt(null);
   removeCookie(authTokenKey());
-  removeCookie(legacyAuthTokenKey);
-  void secretStorage.removeItem(authTokenKey());
+  for (const key of retiredAuthTokenKeys()) removeCookie(key);
+  void secretStorage.removeItem(storedAuthTokenKey());
   void secretStorage.removeItem(legacyAuthTokenKey);
   announceAuth();
 };

package/client/dictionaryAsset.ts

@@ -0,0 +1,32 @@
+import { type Dictionary, TranslatorState } from "./translatorState";
+
+interface DictionaryModule {
+  lang: string;
+  default: Dictionary;
+}
+
+export class DictionaryAsset {
+  static readonly #loads = new Map<string, Promise<DictionaryModule>>();
+  static #retrySeq = 0;
+
+  static async load(url: string | null | undefined): Promise<void> {
+    if (!url) return;
+    const loading = DictionaryAsset.#loads.get(url) ?? DictionaryAsset.#import(url);
+    DictionaryAsset.#loads.set(url, loading);
+    const { lang, default: dictionary } = await loading;
+    TranslatorState.replace(lang, dictionary);
+  }
+
+  static async #import(url: string): Promise<DictionaryModule> {
+    try {
+      return (await import(url)) as DictionaryModule;
+    } catch {
+      try {
+        return (await import(`${url}?retry=${++DictionaryAsset.#retrySeq}`)) as DictionaryModule;
+      } catch (error) {
+        DictionaryAsset.#loads.delete(url);
+        throw error;
+      }
+    }
+  }
+}

package/client/index.ts

@@ -11,6 +11,7 @@ export * from "./href";
 export * from "./locale";
 export * from "./makePageProto";
 export * from "./mcpView";
+export * from "./nativeHost";
 export * from "./resolveServerUrl";
 export * from "./route";
 export * from "./router";

package/client/makePageProto.tsx

@@ -1,5 +1,5 @@
 import { getEnv } from "akanjs/base";
-import { parseAkanI18nEnv } from "akanjs/common";
+import { parseAkanI18nEnv, RequestLocale } from "akanjs/common";
 import { untrackedHeaders, untrackedRequest } from "akanjs/fetch";
 import type { ReactNode } from "react";
 import { csrLocation } from "./csrLocation";
@@ -36,21 +36,15 @@ const getPageInfo = (): { locale: string; path: string } => {
     return { locale, path: hasLocalePrefix ? `/${rest.join("/")}` : pathname };
   }
   const h = untrackedHeaders();
-  
-  const localeHeader = h.get("x-locale");
-  const pathHeader = h.get("x-path");
-  if (localeHeader && pathHeader) return { locale: localeHeader, path: pathHeader };
   const req = untrackedRequest();
-  if (req) {
-    const urlPath = new URL(req.url).pathname;
-    const [, firstSegment = "", ...rest] = urlPath.split("/");
-    if (!localeHeader && !localeSet.has(firstSegment)) return { locale: defaultLocale, path: pathHeader ?? urlPath };
-    return {
-      locale: localeHeader ?? (firstSegment || defaultLocale),
-      path: pathHeader ?? `/${rest.join("/")}`,
-    };
-  }
-  return { locale: localeHeader ?? defaultLocale, path: pathHeader ?? "/" };
+  return RequestLocale.resolve(
+    {
+      localeHeader: h.get("x-locale"),
+      pathHeader: h.get("x-path"),
+      pathname: req ? new URL(req.url).pathname : undefined,
+    },
+    { defaultLocale, locales },
+  );
 };
 
 export interface TransMessageOption {

package/client/native.ts

@@ -1,4 +1,3 @@
-import { isNative, platform } from "../vendor/@akanjs/native/packages/core/src/index.ts";
 import { browser } from "../vendor/@akanjs/native/plugins/browser/src/index.ts";
 import { opener } from "../vendor/@akanjs/native/plugins/opener/src/index.ts";
 
@@ -50,30 +49,10 @@ export { markReady, updates, useUpdateState } from "../vendor/@akanjs/native/plu
 export type { VolumeState } from "../vendor/@akanjs/native/plugins/volume/src/index.ts";
 export { volume } from "../vendor/@akanjs/native/plugins/volume/src/index.ts";
 export { useLiveValue, usePluginEvent } from "../vendor/@akanjs/native/packages/react/src/index.ts";
+export { desktopPlatform, isNativeApp, isNativeShell, nativePlatform, openExternalUrl } from "./nativeHost";
 export { browser, opener };
 
 export const loadCamera = () => import("../vendor/@akanjs/native/plugins/camera/src/index.ts");
 export const loadContacts = () => import("../vendor/@akanjs/native/plugins/contacts/src/index.ts");
 export const loadGeolocation = () => import("../vendor/@akanjs/native/plugins/geolocation/src/index.ts");
 export const loadIap = () => import("../vendor/@akanjs/native/plugins/iap/src/index.ts");
-
-/** Inside an iOS or Android shell of the native runtime; a mobile target opened in a browser is not. */
-export const isNativeApp = () => isNative && (platform === "ios" || platform === "android");
-
-/** Inside any shell of the native runtime, desktop included. */
-export const isNativeShell = () => isNative;
-
-export const nativePlatform = () => (isNativeApp() ? (platform as "ios" | "android") : null);
-
-export const desktopPlatform = () =>
-  isNative && (platform === "macos" || platform === "windows" || platform === "linux") ? platform : null;
-
-/** http(s) in the in-app browser, anything else (mailto:, tel:) in the app the system picks. */
-export const openExternalUrl = async (url: string) => {
-  if (!isNativeApp()) {
-    window.open(url, "_blank", "noopener,noreferrer");
-    return;
-  }
-  if (/^https?:/i.test(url)) await browser.open({ url });
-  else await opener.openUrl({ url });
-};

package/client/nativeHost.ts

@@ -0,0 +1,22 @@
+import { isNative, platform } from "../vendor/@akanjs/native/packages/core/src/index.ts";
+
+/** Inside an iOS or Android shell of the native runtime; a mobile target opened in a browser is not. */
+export const isNativeApp = () => isNative && (platform === "ios" || platform === "android");
+
+/** Inside any shell of the native runtime, desktop included. */
+export const isNativeShell = () => isNative;
+
+export const nativePlatform = () => (isNativeApp() ? (platform as "ios" | "android") : null);
+
+export const desktopPlatform = () =>
+  isNative && (platform === "macos" || platform === "windows" || platform === "linux") ? platform : null;
+
+/** http(s) in the in-app browser, anything else (mailto:, tel:) in the app the system picks. */
+export const openExternalUrl = async (url: string) => {
+  if (!isNativeApp()) {
+    window.open(url, "_blank", "noopener,noreferrer");
+    return;
+  }
+  if (/^https?:/i.test(url)) await (await import("../vendor/@akanjs/native/plugins/browser/src/index.ts")).browser.open({ url });
+  else await (await import("../vendor/@akanjs/native/plugins/opener/src/index.ts")).opener.openUrl({ url });
+};

package/client/route/LayoutDefinition.ts

@@ -1,3 +1,4 @@
+import { RenderScope } from "akanjs/fetch";
 import type { ReactNode } from "react";
 import type { LayoutErrorRender, LayoutModule, LayoutNotFoundRender, PageModule } from "../csrTypes";
 import { type RouteArgsShape, RouteDefinition, type RouteKind } from "./RouteDefinition";
@@ -27,12 +28,12 @@ export class LayoutDefinition<Args extends RouteArgsShape = Record<never, never>
   }
 
   notFound(render: LayoutNotFoundRender) {
-    this.#notFound = render;
+    this.#notFound = (props) => RenderScope.run(() => render(props));
     return this;
   }
 
   error(render: LayoutErrorRender) {
-    this.#error = render;
+    this.#error = (props) => RenderScope.run(() => render(props));
     return this;
   }
 

package/client/route/RouteDefinition.ts

@@ -8,6 +8,7 @@ import {
 } from "akanjs/base";
 import { parseAkanI18nEnv } from "akanjs/common";
 import { deserialize } from "akanjs/constant";
+import { RenderScope } from "akanjs/fetch";
 import type { ReactNode } from "react";
 import type { Head, LayoutModule, PageConfig, PageModule, RouteGuardProps } from "../csrTypes";
 import { AkanNotFoundError } from "../router";
@@ -145,12 +146,15 @@ export abstract class RouteDefinition<
       ...(head === undefined
         ? {}
         : typeof head === "function"
-          ? { generateHead: async (props: RouteRenderProps) => await head(this.#argsOf(props) as never) }
+          ? {
+              generateHead: async (props: RouteRenderProps) =>
+                await RenderScope.run(() => head(this.#argsOf(props) as never)),
+            }
           : { head }),
       ...(loading
         ? {
             Loading: ((props: RouteRenderProps) =>
-              loading(this.#argsOf({ ...props, searchParams: {} }) as never)) as never,
+              RenderScope.run(() => loading(this.#argsOf({ ...props, searchParams: {} }) as never))) as never,
           }
         : {}),
     };
@@ -167,7 +171,8 @@ export abstract class RouteDefinition<
   }
 
   #guardRouteOf(guard: (args: never) => void | Promise<void>) {
-    const route = async (props: RouteGuardProps) => await guard(this.#guardArgsOf(props) as never);
+    const route = async (props: RouteGuardProps) =>
+      await RenderScope.run(() => guard(this.#guardArgsOf(props) as never));
     Object.defineProperty(route, routeArgsMarker, { value: this.args.map(({ kind, name }) => ({ kind, name })) });
     return route;
   }
@@ -178,10 +183,10 @@ export abstract class RouteDefinition<
 
     const route = async (props: RouteRenderProps) => {
       const args = this.renderArgsOf(this.#argsOf(props));
-      if (!(args instanceof Promise)) return await render(args as never);
+      if (!(args instanceof Promise)) return await RenderScope.run(() => render(args as never));
       const path = Translator.getRenderPath();
       const resolved = await args;
-      return await Translator.renderAt(path, () => render(resolved as never));
+      return await Translator.renderAt(path, () => RenderScope.run(() => render(resolved as never)));
     };
     Object.defineProperty(route, routeArgsMarker, { value: this.args.map(({ kind, name }) => ({ kind, name })) });
     this.#renderRoute = { render, argCount: this.args.length, route };

package/client/translator.ts

@@ -1,67 +1,38 @@
 import { interpolateTranslation, parseAkanI18nEnv, pathGetLoose } from "akanjs/common";
 
-export interface Dictionary {
-  [key: string]: {
-    [key: string]: unknown;
-  };
-}
-export interface AllDictionary {
-  [key: string]: Dictionary;
-}
+import { type AllDictionary, type Dictionary, TranslatorState } from "./translatorState";
 
-interface TranslatorState {
-  langDictionaryMap: Map<string, Dictionary>;
-  
-  seededDicts: WeakSet<object>;
-  replacedDicts: WeakSet<object>;
-  
-  activeLocale?: string;
-  
-  activePath?: string;
-  
-  renderPath?: string;
-}
-
-const TRANSLATOR_STATE_KEY = "__AKAN_TRANSLATOR_STATE__";
-const getTranslatorState = (): TranslatorState => {
-  const globalScope = globalThis as typeof globalThis & {
-    [TRANSLATOR_STATE_KEY]?: TranslatorState;
-  };
-  globalScope[TRANSLATOR_STATE_KEY] ??= {
-    langDictionaryMap: new Map<string, Dictionary>(),
-    seededDicts: new WeakSet<object>(),
-    replacedDicts: new WeakSet<object>(),
-  };
-  return globalScope[TRANSLATOR_STATE_KEY];
-};
+export type { AllDictionary, Dictionary } from "./translatorState";
 
 export class Translator {
-  static readonly #filledDicts = new WeakMap<AllDictionary, Map<string, Dictionary>>();
   constructor(dictionary: Record<string, Record<string, Record<string, unknown>>>) {
     Object.entries(dictionary).forEach(([lang, dict]) => {
       Translator.seed(lang, dict as Dictionary);
     });
   }
   hasDictionary(lang: string) {
-    return getTranslatorState().langDictionaryMap.has(lang);
+    return Translator.hasLocale(lang);
+  }
+  static hasLocale(lang: string) {
+    return TranslatorState.get().langDictionaryMap.has(lang);
   }
   static setActiveLocale(lang: string | undefined) {
-    if (lang) getTranslatorState().activeLocale = lang;
+    if (lang) TranslatorState.get().activeLocale = lang;
   }
   static getActiveLocale(): string | undefined {
-    return getTranslatorState().activeLocale;
+    return TranslatorState.get().activeLocale;
   }
   static setActivePath(path: string | undefined) {
-    const state = getTranslatorState();
+    const state = TranslatorState.get();
     if (path) state.activePath = path;
     else delete state.activePath;
   }
   static getActivePath(): string | undefined {
-    return getTranslatorState().activePath;
+    return TranslatorState.get().activePath;
   }
   static renderAt<T>(path: string | undefined, render: () => T): T {
     if (!path) return render();
-    const state = getTranslatorState();
+    const state = TranslatorState.get();
     const outer = state.renderPath;
     state.renderPath = path;
     try {
@@ -71,17 +42,17 @@ export class Translator {
     }
   }
   static getRenderPath(): string | undefined {
-    return getTranslatorState().renderPath;
+    return TranslatorState.get().renderPath;
   }
   static markHydrated() {
-    delete getTranslatorState().activePath;
+    delete TranslatorState.get().activePath;
   }
   static translateByLocale(lang: string, key: string, param?: Record<string, string | number>): string {
     const msg = Translator.#lookup(lang, key) ?? Translator.#lookupDefault(lang, key) ?? key;
     return interpolateTranslation(msg, param);
   }
   static #lookup(lang: string, key: string) {
-    const dictionary = getTranslatorState().langDictionaryMap.get(lang);
+    const dictionary = TranslatorState.get().langDictionaryMap.get(lang);
     if (!dictionary) return undefined;
     const node = pathGetLoose(key, dictionary, ".") as { t?: unknown } | null;
     return typeof node?.t === "string" ? node.t : undefined;
@@ -92,16 +63,10 @@ export class Translator {
     return defaultLocale === lang ? undefined : Translator.#lookup(defaultLocale, key);
   }
   
-  static withDefaultLocale(allDictionary: AllDictionary, lang: string): Dictionary | undefined {
-    const { defaultLocale } = parseAkanI18nEnv();
+  static fillFromDefault(allDictionary: AllDictionary, lang: string, defaultLocale: string): Dictionary {
     const fallback = allDictionary[defaultLocale];
-    if (lang === defaultLocale || !fallback) return allDictionary[lang];
-    const filledByLocale = Translator.#filledDicts.get(allDictionary) ?? new Map<string, Dictionary>();
-    Translator.#filledDicts.set(allDictionary, filledByLocale);
-    const filled =
-      filledByLocale.get(lang) ?? (Translator.#fillGaps(allDictionary[lang] ?? {}, fallback) as Dictionary);
-    filledByLocale.set(lang, filled);
-    return filled;
+    if (lang === defaultLocale || !fallback) return allDictionary[lang] ?? {};
+    return Translator.#fillGaps(allDictionary[lang] ?? {}, fallback) as Dictionary;
   }
   static #fillGaps(own: Record<string, unknown>, fallback: Record<string, unknown>): Record<string, unknown> {
     const filled = { ...own };
@@ -119,7 +84,7 @@ export class Translator {
   
   static seed(lang: string, dict: Dictionary | undefined) {
     if (!dict) return;
-    const state = getTranslatorState();
+    const state = TranslatorState.get();
     if (state.seededDicts.has(dict)) return;
     state.seededDicts.add(dict);
     const existingDictionary = state.langDictionaryMap.get(lang) ?? {};
@@ -130,18 +95,13 @@ export class Translator {
     state.langDictionaryMap.set(lang, existingDictionary);
   }
   static replace(lang: string, dict: Dictionary | undefined) {
-    if (!dict) return;
-    const state = getTranslatorState();
-    if (state.replacedDicts.has(dict)) return;
-    state.seededDicts.add(dict);
-    state.replacedDicts.add(dict);
-    state.langDictionaryMap.set(lang, { ...dict });
+    TranslatorState.replace(lang, dict);
   }
   translate(lang: string, key: string, param?: Record<string, string | number>): string {
     return Translator.translateByLocale(lang, key, param);
   }
   async getDictionary(lang: string) {
-    const dictionary = getTranslatorState().langDictionaryMap.get(lang);
+    const dictionary = TranslatorState.get().langDictionaryMap.get(lang);
     if (!dictionary) throw new Error(`Dictionary for language ${lang} not found`);
     return dictionary;
   }

package/client/translatorState.ts

@@ -0,0 +1,44 @@
+export interface Dictionary {
+  [key: string]: {
+    [key: string]: unknown;
+  };
+}
+export interface AllDictionary {
+  [key: string]: Dictionary;
+}
+
+interface TranslatorStateValue {
+  langDictionaryMap: Map<string, Dictionary>;
+  
+  seededDicts: WeakSet<object>;
+  
+  replacedByLang: Map<string, object>;
+  
+  activeLocale?: string;
+  
+  activePath?: string;
+  
+  renderPath?: string;
+}
+
+const translatorStateKey = "__AKAN_TRANSLATOR_STATE__";
+
+export class TranslatorState {
+  static get(): TranslatorStateValue {
+    const globalScope = globalThis as typeof globalThis & { [translatorStateKey]?: TranslatorStateValue };
+    globalScope[translatorStateKey] ??= {
+      langDictionaryMap: new Map<string, Dictionary>(),
+      seededDicts: new WeakSet<object>(),
+      replacedByLang: new Map<string, object>(),
+    };
+    return globalScope[translatorStateKey];
+  }
+  static replace(lang: string, dict: Dictionary | undefined) {
+    if (!dict) return;
+    const state = TranslatorState.get();
+    if (state.replacedByLang.get(lang) === dict) return;
+    state.seededDicts.add(dict);
+    state.replacedByLang.set(lang, dict);
+    state.langDictionaryMap.set(lang, { ...dict });
+  }
+}

package/client/types.ts

@@ -16,6 +16,7 @@ export interface ReactFontPath {
   src: string;
   weight: number | string;
   style?: ReactFontStyle;
+  preload?: boolean;
   declarations?: ReactFontDeclaration[];
 }