@edgekits/astro-i18n 0.1.7 → 0.2.0

package/src/components/LanguageSwitcher.astro

@@ -1,6 +1,6 @@
 ---
 import { I18N_CONFIG } from '../config'
-import { SUPPORTED_LOCALES, LANGUAGES, LANG_COOKIE_NAME } from '../constants'
+import { DEFAULT_LOCALE, SUPPORTED_LOCALES, LANGUAGES, LANG_COOKIE_NAME } from '../constants'
 import type { Locale } from '../constants'
 
 interface Props {
@@ -24,81 +24,87 @@ interface Props {
 
 const { flag: Flag, triggerIcon: TriggerIcon, activeIcon: ActiveIcon, classes = {}, texts } = Astro.props
 const { uiLocale: currentLang } = Astro.locals
+// One configured locale: nothing to switch to, so nothing renders.
+const hasChoice = SUPPORTED_LOCALES.length > 1
 ---
 
-<language-switcher
-  data-current-lang={currentLang}
-  data-cookie-name={LANG_COOKIE_NAME}
-  data-cookie-max-age={I18N_CONFIG.cookie.maxAge}
-  data-open="false"
->
-  <div class={classes.root}>
-    <button
-      type="button"
-      data-ls-trigger
-      class={classes.trigger}
-      aria-haspopup="true"
-      aria-expanded="false"
-      aria-label={texts?.trigger ?? 'Switch language'}
+{
+  hasChoice && (
+    <language-switcher
+      data-current-lang={currentLang}
+      data-cookie-name={LANG_COOKIE_NAME}
+      data-cookie-max-age={I18N_CONFIG.cookie.maxAge}
+      data-routing={I18N_CONFIG.routing ?? 'prefix-except-default'}
+      data-default-locale={DEFAULT_LOCALE}
+      data-open="false"
     >
-      {
-        TriggerIcon ? (
-          <TriggerIcon class={classes.triggerIcon} stroke-width="1" />
-        ) : (
-          <svg
-            class={classes.triggerIcon}
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="1"
-            aria-hidden="true"
-          >
-            <circle cx="12" cy="12" r="9" />
-            <ellipse cx="12" cy="12" rx="4" ry="9" />
-            <path d="M3 12h18" />
-          </svg>
-        )
-      }
-    </button>
-
-    <div data-ls-dropdown class={classes.dropdown} role="menu" hidden>
-      {
-        SUPPORTED_LOCALES.map((lang) => {
-          const locale = lang as Locale
-          const isActive = locale === currentLang
-          const label = LANGUAGES[locale]
-          const flagCode = label.countryCode
-
-          return (
-            <button
-              type="button"
-              class:list={[classes.item, isActive && classes.itemActive]}
-              data-ls-item
-              data-lang={locale}
-              data-active={isActive ? 'true' : undefined}
-              role="menuitem"
-              disabled={isActive}
+      <div class={classes.root}>
+        <button
+          type="button"
+          data-ls-trigger
+          class={classes.trigger}
+          aria-haspopup="true"
+          aria-expanded="false"
+          aria-label={texts?.trigger ?? 'Switch language'}
+        >
+          {TriggerIcon ? (
+            <TriggerIcon class={classes.triggerIcon} stroke-width="1" />
+          ) : (
+            <svg
+              class={classes.triggerIcon}
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="1"
+              aria-hidden="true"
             >
-              {/* The label is the language's own name: `lang` lets a screen reader say it in that language. */}
-              <span class={classes.itemLabel} lang={locale}>
-                {Flag && flagCode && <Flag code={flagCode} size={16} />}
-                {label.name}
-              </span>
-              {isActive &&
-                (ActiveIcon ? (
-                  <ActiveIcon class={classes.activeIcon} />
-                ) : (
-                  <svg class={classes.activeIcon} viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
-                    <circle cx="12" cy="12" r="3" />
-                  </svg>
-                ))}
-            </button>
-          )
-        })
-      }
-    </div>
-  </div>
-</language-switcher>
+              <circle cx="12" cy="12" r="9" />
+              <ellipse cx="12" cy="12" rx="4" ry="9" />
+              <path d="M3 12h18" />
+            </svg>
+          )}
+        </button>
+
+        <div data-ls-dropdown class={classes.dropdown} role="menu" hidden>
+          {SUPPORTED_LOCALES.map((lang) => {
+            const locale = lang as Locale
+            const isActive = locale === currentLang
+            const label = LANGUAGES[locale]
+            const flagCode = label.countryCode
+
+            // The label is the language's own name: `lang` lets a screen reader say it in that
+            // language. (A comment here, not among the button's children: there it splits the
+            // whitespace run, and compressHTML keeps two spaces before the label.)
+            return (
+              <button
+                type="button"
+                class:list={[classes.item, isActive && classes.itemActive]}
+                data-ls-item
+                data-lang={locale}
+                data-active={isActive ? 'true' : undefined}
+                role="menuitem"
+                disabled={isActive}
+              >
+                <span class={classes.itemLabel} lang={locale}>
+                  {Flag && flagCode && <Flag code={flagCode} size={16} />}
+                  {label.name}
+                </span>
+                {isActive &&
+                  (ActiveIcon ? (
+                    <ActiveIcon class={classes.activeIcon} />
+                  ) : (
+                    <svg class={classes.activeIcon} viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
+                      <circle cx="12" cy="12" r="3" />
+                    </svg>
+                  ))}
+              </button>
+            )
+          })}
+        </div>
+      </div>
+    </language-switcher>
+  )
+}
 
 <script>
   // Config arrives as data attributes on the element: a client script in the engine
@@ -156,19 +162,16 @@ const { uiLocale: currentLang } = Astro.locals
       this.dropdown.hidden ? this.open() : this.close()
     }
 
-    // Isolated logic for getting language from URL
-    private getLangFromUrl(pathname: string): string | undefined {
-      const segments = pathname.split('/')
-      return segments[1] || undefined
-    }
-
-    // Isolated logic for substituting language in URLs
-    private replaceLocaleInPath(pathname: string, currentLang: string, targetLang: string): string {
-      const segments = pathname.split('/')
-      if (segments[1] === currentLang) {
-        segments[1] = targetLang
-      }
-      return segments.join('/')
+    // The core's `localizedPath`, inlined (a client script imports types only): the page's
+    // path in `targetLang`. The URL carries the current locale's prefix exactly when it has
+    // one (every locale in 'prefix', all but the default in 'prefix-except-default'), so
+    // `data-current-lang` is the only segment to strip.
+    private localizedPath(pathname: string, targetLang: string): string {
+      const { currentLang, routing, defaultLocale } = this.dataset
+      const segments = pathname.split('/').filter(Boolean)
+      if (segments[0] === currentLang) segments.shift()
+      const rest = segments.length > 0 ? `${segments.join('/')}/` : ''
+      return routing !== 'prefix' && targetLang === defaultLocale ? `/${rest}` : `/${targetLang}/${rest}`
     }
 
     private onSelect = (event: Event) => {
@@ -179,11 +182,6 @@ const { uiLocale: currentLang } = Astro.locals
       const lang = button.dataset.lang as Locale | undefined
       if (!lang) return
 
-      const pathname = window.location.pathname
-      const currentLang = this.getLangFromUrl(pathname)
-
-      if (!currentLang) return
-
       const { cookieName, cookieMaxAge } = this.dataset
 
       // Persist the EXPLICIT language choice client-side. The i18n middleware
@@ -193,7 +191,7 @@ const { uiLocale: currentLang } = Astro.locals
       // either side (cookie-storage.ts): the server validates it, never trusts it.
       document.cookie = `${cookieName}=${lang}; path=/; max-age=${cookieMaxAge}; SameSite=Lax; Secure`
 
-      window.location.href = this.replaceLocaleInPath(pathname, currentLang, lang)
+      window.location.href = this.localizedPath(window.location.pathname, lang)
     }
 
     private onDocumentClick = (event: MouseEvent) => {

package/src/config.entry.ts

@@ -1,38 +1,7 @@
 // The `./config` entry: Node-safe. It imports nothing from workerd and no virtual module,
 // so a project's pure modules (unit tests under Node, `src/content.config.ts` evaluated by
-// `astro sync`) can derive the locale constants from the config file directly.
-// `test/node-safe-entries.test.ts` loads it under plain Node to keep it that way.
-import { defineI18nConfig, type I18nConfig, type I18nLanguage, type LocaleOf } from './types'
-
-export { defineI18nConfig }
-export type { I18nBindings, I18nConfig, I18nLanguage, I18nLocales, Locale, LocaleOf } from './types'
-
-export type LocalesOf<C extends I18nConfig> = {
-  DEFAULT_LOCALE: LocaleOf<C>
-  SUPPORTED_LOCALES: [LocaleOf<C>, ...LocaleOf<C>[]]
-  LANGUAGES: Record<LocaleOf<C>, I18nLanguage>
-}
-
-/**
- * The locale constants of a config: the one derivation, shared by the runtime
- * (`constants.ts`, over the virtual config) and by project code (over its own
- * `edgekits-i18n.config.ts`, typed by its own keys without the `I18nLocales` augmentation).
- *
- * `defaultLocale` must be one of `languages` at the type level, and is validated at run time.
- */
-export function localesOf<const C extends I18nConfig>(
-  config: C & {
-    defaultLocale: LocaleOf<C>
-    countryToLocale?: Record<string, LocaleOf<C>>
-    markdownLocale?: LocaleOf<C>
-  },
-): LocalesOf<C> {
-  defineI18nConfig<C>(config)
-
-  return {
-    DEFAULT_LOCALE: config.defaultLocale,
-    // Object.keys widens to string[]; the keys are the config's own `languages` keys.
-    SUPPORTED_LOCALES: Object.keys(config.languages) as [LocaleOf<C>, ...LocaleOf<C>[]],
-    LANGUAGES: config.languages as Record<LocaleOf<C>, I18nLanguage>,
-  }
-}
+// `astro sync`) can derive the locale constants from the config file directly. The helpers
+// are the core's (`@edgekits/i18n-core`). `test/node-safe-entries.test.ts` loads it under
+// plain Node to keep it that way.
+export { defineI18nConfig, localesOf } from './types'
+export type { I18nBindings, I18nConfig, I18nLanguage, I18nLocales, Locale, LocaleOf, LocalesOf } from './types'

package/src/constants.ts

@@ -6,9 +6,11 @@ export type { Locale }
 
 export type Language = I18nLanguage
 
-// Languages are configured in the project's edgekits-i18n.config.ts; the derivation is
-// `localesOf` (config.entry.ts), shared with project code. Inside the package the config
-// is not literal, so its keys are narrowed to the augmented `Locale` here.
+// Languages are configured in the project's edgekits-i18n.config.ts; the derivation is the
+// core's `localesOf`, shared with project code and with `createI18n` (instance.ts). Taken
+// from the config, not the instance, so the components that need only these constants
+// reach neither `cloudflare:workers` nor the generated modules. Inside the package the
+// config is not literal, so its keys are narrowed to the augmented `Locale` here.
 const LOCALES = localesOf(I18N_CONFIG)
 
 export const LANGUAGES = LOCALES.LANGUAGES as Record<Locale, Language>

package/src/cookie-storage.ts

@@ -1,24 +1,22 @@
 import { type AstroCookies } from 'astro'
+import type { CookieJar } from '@edgekits/i18n-core'
 
-import { I18N_CONFIG } from './config'
+import { i18n } from './instance'
 import { LocaleSchema } from './schema'
 import type { Locale } from './constants'
 import { LANG_COOKIE_NAME } from './constants'
 
-// The lang cookie is a preference, not a secret, and it has two writers: the
-// LanguageSwitcher's client script (`document.cookie`) and the middleware's URL-wins
-// sync. Hence `httpOnly: false`: an httpOnly copy set here could never be overwritten
-// by the switcher again, and a stale value would disable it for good. The server only
-// reads the value through LocaleSchema, never trusts it. `?.`: plain Node (the tests)
-// has no `import.meta.env`.
+// The core's lang-cookie helpers (cookie.ts there: why the cookie is not httpOnly) over
+// Astro's cookies. `?.`: plain Node (the tests) has no `import.meta.env`.
+function jar(cookies: AstroCookies): CookieJar {
+  return {
+    get: (name) => cookies.get(name)?.value,
+    set: (name, value, options) => cookies.set(name, value, options),
+  }
+}
+
 export function setCookieLang(cookies: AstroCookies, locale: Locale) {
-  cookies.set(LANG_COOKIE_NAME, locale, {
-    path: '/',
-    httpOnly: false,
-    secure: import.meta.env?.PROD === true,
-    sameSite: 'lax',
-    maxAge: I18N_CONFIG.cookie.maxAge,
-  })
+  i18n.setCookieLang(jar(cookies), locale, { secure: import.meta.env?.PROD === true })
 }
 
 export type CookieLang = {
@@ -29,19 +27,15 @@ export type CookieLang = {
 }
 
 export function readCookieLang(cookies: AstroCookies): CookieLang {
-  const entry = cookies.get(LANG_COOKIE_NAME)
-  if (!entry) return { present: false, locale: null }
-
-  const result = LocaleSchema.safeParse(entry.value)
-  if (result.success) return { present: true, locale: result.data }
-
-  if (import.meta.env?.PROD !== true) {
-    console.warn(`Invalid cookie "${LANG_COOKIE_NAME}"`, result.error.issues)
-  }
-
-  return { present: true, locale: null }
+  return i18n.readCookieLang(jar(cookies), { onInvalid: warnInvalidCookie })
 }
 
 export function getCookieLang(cookies: AstroCookies): Locale | null {
   return readCookieLang(cookies).locale
 }
+
+function warnInvalidCookie(value: string): void {
+  if (import.meta.env?.PROD !== true) {
+    console.warn(`Invalid cookie "${LANG_COOKIE_NAME}"`, LocaleSchema.safeParse(value).error?.issues)
+  }
+}

package/src/fetcher.ts

@@ -1,305 +1,4 @@
-import { env, waitUntil } from 'cloudflare:workers'
-import * as fallbacksModule from 'virtual:@edgekits/astro-i18n/fallbacks'
+// The core's fetcher, bound to this project's config and Worker bindings (instance.ts).
+import { i18n } from './instance'
 
-import { assembleNamespace } from './assemble'
-import { buildTranslationKvKey, buildTranslationCacheRequest } from './translations-keys'
-import { parseBooleanFlag } from './parse-boolean'
-import type { Locale } from './constants'
-import type { Namespace, PickSchema } from './schema'
-import type { I18nBindings } from './types'
-
-// The bindings this module reads, typed by the package rather than the project's Env.
-const i18nEnv = env as unknown as I18nBindings
-
-// Optional fallbacks: the project's fallbacks.generated.ts if generated, otherwise an
-// empty stub module (no FALLBACK_* exports), served by the integration's Vite plugin.
-const FALLBACKS: Record<string, unknown> = fallbacksModule
-
-const KV_JSON_OPTIONS = { type: 'json' as const }
-
-/**
- * Fetch translations from KV for a given locale and list of namespaces.
- *
- * Cache strategy — per-namespace static cache keys:
- *
- * Each namespace is cached individually under a static (non-versioned) URL:
- *   https://<I18N_CONFIG.keyPrefix>/<encodeURIComponent(i18n:<locale>:<ns>)>
- *
- * Cache invalidation is handled explicitly by the Cloudflare Purge API
- * in `edgekits-i18n migrate` — only namespaces whose content actually changed
- * are purged, leaving untouched namespaces warm in the cache.
- *
- * Hot path (all namespaces cached):
- *   Parallel cache.match() for each namespace → all HIT → merge each with
- *   FALLBACK_* → return immediately. Zero KV reads.
- *
- * Partial or full cache miss:
- *   Missing namespaces collected → single KV getAll() batch →
- *   merge with FALLBACK_* → individual cache.put() per namespace → return.
- *
- * Every namespace — cached or freshly read — is assembled through
- * assembleNamespace(), so a cache HIT is merged with FALLBACK_* exactly like a
- * miss. An entry cached before a schema addition therefore degrades to
- * default-locale text for the keys it predates instead of yielding `undefined`
- * (ADR-0014).
- *
- * KV unavailable:
- *   Falls back to FALLBACK_* compiled dictionaries (always available).
- *   If none were generated, returns empty objects per namespace — no crash.
- */
-export async function fetchTranslations<N extends Namespace>(
-  locale: Locale,
-  namespaces: readonly N[],
-): Promise<PickSchema<N>> {
-  const useCache = isCacheEnabled()
-
-  if (!useCache) {
-    debug('i18n cache DISABLED, using KV only', { locale, namespaces })
-    return fetchAllFromKV(locale, namespaces)
-  }
-
-  const { cache } = getEdgeCache()
-
-  if (!cache) {
-    // `caches.default` absent (e.g. an untrusted Workers for Platforms namespace): read KV
-    // directly. The package does not use `caches.open()`.
-    debug('i18n caches.default absent, reading KV directly', {
-      locale,
-      namespaces,
-    })
-    return fetchAllFromKV(locale, namespaces)
-  }
-
-  // ---------------------------------------------------------------------------
-  // 1. Check Cache API in parallel for each namespace individually
-  // ---------------------------------------------------------------------------
-
-  const cacheResults = await Promise.all(
-    namespaces.map(async (ns) => {
-      const cacheRequest = buildTranslationCacheRequest(locale, ns)
-      try {
-        const cached = await cache.match(cacheRequest)
-        if (cached) {
-          return { ns, data: await cached.json(), hit: true }
-        }
-      } catch (error) {
-        debug(`i18n cache READ error for ${ns}`, error)
-      }
-      return { ns, data: null, hit: false }
-    }),
-  )
-
-  // ---------------------------------------------------------------------------
-  // 2. Separate hits from misses
-  // ---------------------------------------------------------------------------
-
-  const finalData: Partial<PickSchema<N>> = {}
-  const missingNamespaces: N[] = []
-
-  for (const { ns, data, hit } of cacheResults) {
-    if (hit) {
-      // Cached entries are merged with FALLBACK_* too. A namespace cached before
-      // a schema addition is missing the newer keys; without this merge it would
-      // reach pages as-is and any read of a new key would throw (ADR-0014).
-      ;(finalData as any)[ns] = assembleNamespace(data, getFallback(ns))
-    } else {
-      missingNamespaces.push(ns)
-    }
-  }
-
-  // All namespaces were in cache — return immediately, zero KV reads
-  if (missingNamespaces.length === 0) {
-    debug('i18n cache FULL HIT', { locale, namespaces })
-    return finalData as PickSchema<N>
-  }
-
-  debug('i18n cache PARTIAL/FULL MISS', {
-    locale,
-    hit: namespaces.length - missingNamespaces.length,
-    miss: missingNamespaces.length,
-  })
-
-  // ---------------------------------------------------------------------------
-  // 3. Batch KV read for missing namespaces only
-  // ---------------------------------------------------------------------------
-
-  const missingKvKeys = missingNamespaces.map((ns) => buildTranslationKvKey(locale, ns))
-
-  let kvResults = new Map<string, unknown | null>()
-  let kvFailed = false
-
-  try {
-    kvResults = (await i18nEnv.TRANSLATIONS.get(missingKvKeys, KV_JSON_OPTIONS)) as Map<string, unknown | null>
-
-    debug('i18n KV batch OK', { locale, missingNamespaces })
-  } catch (error) {
-    kvFailed = true
-    debug('i18n KV ERROR, using FALLBACK_* for missing namespaces', error)
-  }
-
-  // ---------------------------------------------------------------------------
-  // 4. Assemble missing namespaces + schedule individual cache writes
-  // ---------------------------------------------------------------------------
-
-  const putPromises: Promise<void>[] = []
-
-  for (let i = 0; i < missingNamespaces.length; i++) {
-    const ns = missingNamespaces[i] as N
-    const kvKey = missingKvKeys[i] as string
-
-    // Use KV value if available, otherwise empty object (fallback will fill it)
-    const kvValue = kvFailed ? {} : ((kvResults.get(kvKey) as object) ?? {})
-
-    // Merge with FALLBACK_* compiled dictionary if present
-    const fallback = getFallback(ns)
-
-    const nsData = assembleNamespace(kvValue, fallback)
-
-    if (kvFailed && !fallback) {
-      debug(`i18n namespace "${ns}" unavailable: KV failed and no fallback`)
-    }
-
-    ;(finalData as any)[ns] = nsData
-
-    // Cache the resolved namespace individually with a long TTL.
-    // Invalidation is handled explicitly via Cloudflare Purge API —
-    // no TTL-based expiry needed here.
-    const cacheRequest = buildTranslationCacheRequest(locale, ns)
-    const response = new Response(JSON.stringify(nsData), {
-      headers: {
-        'Content-Type': 'application/json; charset=utf-8',
-        'Cache-Control': 'public, s-maxage=31536000, immutable',
-      },
-    })
-
-    putPromises.push(
-      cache.put(cacheRequest, response.clone()).catch((error: unknown) => {
-        const errorMsg = error instanceof Error ? error.message : String(error)
-        debug(`i18n cache WRITE error for ${ns}`, errorMsg)
-      }),
-    )
-  }
-
-  // ---------------------------------------------------------------------------
-  // 5. Schedule cache writes as background tasks
-  // ---------------------------------------------------------------------------
-
-  if (putPromises.length > 0) {
-    // Top-level waitUntil (cloudflare:workers): same semantics as
-    // ctx.waitUntil, no need to plumb an ExecutionContext through callers.
-    // putPromises only exist when the Cache API is available, so this never
-    // runs in plain `astro dev`.
-    waitUntil(Promise.all(putPromises))
-
-    debug('i18n cache PUT scheduled', { locale, missingNamespaces })
-  }
-
-  return finalData as PickSchema<N>
-}
-
-// ---------------------------------------------------------------------------
-// KV helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Fetch all requested namespaces directly from KV, bypassing the cache.
- * Used when caching is disabled or the Cache API is unavailable.
- */
-async function fetchAllFromKV<N extends Namespace>(locale: Locale, namespaces: readonly N[]): Promise<PickSchema<N>> {
-  const keys = namespaces.map((ns) => buildTranslationKvKey(locale, ns))
-
-  let kvResults = new Map<string, unknown | null>()
-  let kvFailed = false
-
-  try {
-    kvResults = (await i18nEnv.TRANSLATIONS.get(keys, KV_JSON_OPTIONS)) as Map<string, unknown | null>
-  } catch (error) {
-    kvFailed = true
-    debug('i18n KV ERROR (cache bypassed), using FALLBACK_* for all namespaces', error)
-  }
-
-  if (kvFailed) {
-    return buildFallbackOnly(namespaces)
-  }
-
-  const data: Partial<PickSchema<N>> = {}
-
-  for (let i = 0; i < namespaces.length; i++) {
-    const ns = namespaces[i]
-    const kvValue = kvResults.get(keys[i] as string) as object | null
-    ;(data as any)[ns] = assembleNamespace(kvValue, getFallback(ns as N))
-  }
-
-  return data as PickSchema<N>
-}
-
-/**
- * Look up the compiled FALLBACK_* dictionary for a namespace, if one was generated.
- */
-function getFallback(ns: Namespace): unknown {
-  return FALLBACKS[`FALLBACK_${String(ns).toUpperCase()}`]
-}
-
-/**
- * Build a payload using only FALLBACK_* compiled dictionaries.
- * Used when KV is completely unavailable.
- */
-function buildFallbackOnly<N extends Namespace>(namespaces: readonly N[]): PickSchema<N> {
-  const data: Partial<PickSchema<N>> = {}
-
-  for (const ns of namespaces) {
-    ;(data as any)[ns] = getFallback(ns) ?? {}
-  }
-
-  return data as PickSchema<N>
-}
-
-// ---------------------------------------------------------------------------
-// Runtime helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Narrow the global `caches` to the minimal shape this module needs.
- * (waitUntil comes straight from 'cloudflare:workers' — no ctx plumbing.)
- */
-function getEdgeCache(): {
-  cache: { match: any; put: any } | null
-} {
-  const cacheStorage = caches as { default?: { match: any; put: any } }
-
-  return {
-    cache: cacheStorage?.default ?? null,
-  }
-}
-
-/**
- * Determine whether edge caching is enabled.
- *
- * Wrangler var:
- *   I18N_CACHE = "on" | "off" | "true" | "false" | "1" | "0"
- *
- * After adding the variable:
- *   - Update wrangler.jsonc / wrangler.toml or .dev.vars
- *   - Run: wrangler types (if the project generates its Env)
- */
-function isCacheEnabled(): boolean {
-  return parseBooleanFlag(i18nEnv.I18N_CACHE, /* defaultValue */ true)
-}
-
-/**
- * Debug logger controlled by a Wrangler variable.
- *
- * Wrangler var:
- *   DEBUG_I18N = "on" | "off" | "true" | "false" | "1" | "0"
- *
- * After adding the variable:
- *   - Update wrangler.jsonc / wrangler.toml or .dev.vars
- *   - Run: wrangler types (if the project generates its Env)
- */
-function debug(...args: unknown[]): void {
-  const enabled = parseBooleanFlag(i18nEnv.DEBUG_I18N, /* defaultValue */ false)
-  if (!enabled) return
-
-  // eslint-disable-next-line no-console
-  console.log(...args)
-}
+export const { fetchTranslations } = i18n