@mpgd/i18n 0.1.0

package/dist/paraglide/server.d.ts

@@ -0,0 +1,96 @@
+/**
+* Server middleware that handles locale-based routing and request processing.
+*
+* Configure `disableAsyncLocalStorage` when generating Paraglide with
+* `paraglideVitePlugin()` or `compile()`, not when calling
+* `paraglideMiddleware()`. Keep AsyncLocalStorage enabled by default and
+* only disable it for runtimes that lack `AsyncLocalStorage` support and
+* guarantee request isolation.
+*
+* This middleware performs several key functions:
+*
+* 1. Determines the locale for the incoming request using configured strategies
+* 2. Handles URL localization and redirects (only for document requests)
+* 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+*
+* When URL strategy is used:
+*
+* - The locale is extracted from the URL for all request types
+* - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+* - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+*
+* @see https://paraglidejs.com/middleware
+*
+* @template T - The return type of the resolve function
+*
+* @param {Request} request - The incoming request object
+* @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request. The callback receives:
+*   - `request`: A modified request with a delocalized URL when the URL strategy is used (e.g., `/fr/about` → `/about`).
+*      If your framework handles URL localization itself (e.g., TanStack Router's `rewrite` option), use the original
+*      request instead to avoid redirect loops.
+*   - `locale`: The determined locale for this request.
+* @param {{
+*   effectiveRequestUrl?: string | URL | ((request: Request) => string | URL),
+*   onRedirect?: (response: Response) => void
+* }} [options] - Options to control middleware behavior. `effectiveRequestUrl` sets the effective request URL used for route matching, URL-based locale detection, redirects, and `getUrlOrigin()`.
+* @returns {Promise<Response>}
+*
+* @example
+* ```typescript
+* // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+* export const handle = async ({ event, resolve }) => {
+*   return paraglideMiddleware(event.request, ({ request, locale }) => {
+*     // let the framework further resolve the request
+*     return resolve(request);
+*   });
+* };
+* ```
+*
+* @example
+* ```typescript
+* // Usage in a framework like Express JS or Hono
+* app.use(async (req, res, next) => {
+*   const result = await paraglideMiddleware(req, ({ request, locale }) => {
+*     // If a redirect happens this won't be called
+*     return next(request);
+*   });
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Usage with frameworks that handle URL localization/delocalization themselves
+* //
+* // Some frameworks like TanStack Router handle URL localization and delocalization
+* // themselves via their own rewrite APIs (e.g., `rewrite.input`/`rewrite.output`).
+* //
+* // When the framework handles this, the middleware's URL delocalization is not needed.
+* // Using the modified `request` from the callback would cause a redirect loop because
+* // both the middleware and the framework would attempt to delocalize the URL.
+* //
+* // Solution: Pass the original request to the handler instead of the modified one.
+* // The middleware still handles locale detection, cookies, and AsyncLocalStorage context.
+* //
+* // ❌ WRONG - causes redirect loop when framework handles URL rewriting:
+* // paraglideMiddleware(req, ({ request }) => handler.fetch(request))
+* //
+* // ✅ CORRECT - use original request when framework handles URL localization:
+* // paraglideMiddleware(req, () => handler.fetch(req))
+*
+* * *
+* export default {
+*   fetch(req: Request): Promise<Response> {
+*     // TanStack Router handles URL rewriting via deLocalizeUrl/localizeUrl
+*     // so we pass the original `req` instead of the modified `request`
+*     return paraglideMiddleware(req, () => handler.fetch(req))
+*   },
+* }
+* ```
+*/
+export function paraglideMiddleware<T>(request: Request, resolve: (args: {
+  request: Request;
+  locale: import("./runtime.js").Locale;
+}) => T | Promise<T>, options?: {
+  effectiveRequestUrl?: string | URL | ((request: Request) => string | URL);
+  onRedirect?: (response: Response) => void;
+}): Promise<Response>;

package/dist/paraglide/server.js

@@ -0,0 +1,282 @@
+/* eslint-disable */
+
+import * as runtime from "./runtime.js";
+
+/**
+ * Server middleware that handles locale-based routing and request processing.
+ *
+ * Configure `disableAsyncLocalStorage` when generating Paraglide with
+ * `paraglideVitePlugin()` or `compile()`, not when calling
+ * `paraglideMiddleware()`. Keep AsyncLocalStorage enabled by default and
+ * only disable it for runtimes that lack `AsyncLocalStorage` support and
+ * guarantee request isolation.
+ *
+ * This middleware performs several key functions:
+ *
+ * 1. Determines the locale for the incoming request using configured strategies
+ * 2. Handles URL localization and redirects (only for document requests)
+ * 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+ *
+ * When URL strategy is used:
+ *
+ * - The locale is extracted from the URL for all request types
+ * - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+ * - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+ *
+ * @see https://paraglidejs.com/middleware
+ *
+ * @template T - The return type of the resolve function
+ *
+ * @param {Request} request - The incoming request object
+ * @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request. The callback receives:
+ *   - `request`: A modified request with a delocalized URL when the URL strategy is used (e.g., `/fr/about` → `/about`).
+ *      If your framework handles URL localization itself (e.g., TanStack Router's `rewrite` option), use the original
+ *      request instead to avoid redirect loops.
+ *   - `locale`: The determined locale for this request.
+ * @param {{
+ *   effectiveRequestUrl?: string | URL | ((request: Request) => string | URL),
+ *   onRedirect?: (response: Response) => void
+ * }} [options] - Options to control middleware behavior. `effectiveRequestUrl` sets the effective request URL used for route matching, URL-based locale detection, redirects, and `getUrlOrigin()`.
+ * @returns {Promise<Response>}
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+ * export const handle = async ({ event, resolve }) => {
+ *   return paraglideMiddleware(event.request, ({ request, locale }) => {
+ *     // let the framework further resolve the request
+ *     return resolve(request);
+ *   });
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage in a framework like Express JS or Hono
+ * app.use(async (req, res, next) => {
+ *   const result = await paraglideMiddleware(req, ({ request, locale }) => {
+ *     // If a redirect happens this won't be called
+ *     return next(request);
+ *   });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Usage with frameworks that handle URL localization/delocalization themselves
+ * //
+ * // Some frameworks like TanStack Router handle URL localization and delocalization
+ * // themselves via their own rewrite APIs (e.g., `rewrite.input`/`rewrite.output`).
+ * //
+ * // When the framework handles this, the middleware's URL delocalization is not needed.
+ * // Using the modified `request` from the callback would cause a redirect loop because
+ * // both the middleware and the framework would attempt to delocalize the URL.
+ * //
+ * // Solution: Pass the original request to the handler instead of the modified one.
+ * // The middleware still handles locale detection, cookies, and AsyncLocalStorage context.
+ * //
+ * // ❌ WRONG - causes redirect loop when framework handles URL rewriting:
+ * // paraglideMiddleware(req, ({ request }) => handler.fetch(request))
+ * //
+ * // ✅ CORRECT - use original request when framework handles URL localization:
+ * // paraglideMiddleware(req, () => handler.fetch(req))
+ *
+ * * *
+ * export default {
+ *   fetch(req: Request): Promise<Response> {
+ *     // TanStack Router handles URL rewriting via deLocalizeUrl/localizeUrl
+ *     // so we pass the original `req` instead of the modified `request`
+ *     return paraglideMiddleware(req, () => handler.fetch(req))
+ *   },
+ * }
+ * ```
+ */
+export async function paraglideMiddleware(request, resolve, options) {
+    if (!runtime.disableAsyncLocalStorage && !runtime.serverAsyncLocalStorage) {
+      const { AsyncLocalStorage } = await import("async_hooks");
+      runtime.overwriteServerAsyncLocalStorage(new AsyncLocalStorage());
+    } else if (!runtime.serverAsyncLocalStorage) {
+      runtime.overwriteServerAsyncLocalStorage(createMockAsyncLocalStorage());
+    }
+    const url = resolveMiddlewareUrl(request, options?.effectiveRequestUrl);
+    const origin = url.origin;
+    if (runtime.isExcludedByRouteStrategy(url.href)) {
+        const locale = runtime.baseLocale;
+        const newRequest = cloneRequestWithFallback(request, url);
+        /** @type {Set<string>} */
+        const messageCalls = new Set();
+        return /** @type {Response} */ (await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest })));
+    }
+    const strategy = runtime.getStrategyForUrl(url.href);
+    const decision = await runtime.shouldRedirect({ request, effectiveRequestUrl: url });
+    const locale = decision.locale;
+    // if the client makes a request to a URL that doesn't match
+    // the localizedUrl, redirect the client to the localized URL
+    if (request.headers.get("Sec-Fetch-Dest") === "document" &&
+        decision.shouldRedirect &&
+        decision.redirectUrl) {
+        // Create headers object with Vary header if preferredLanguage strategy is used
+        /** @type {Record<string, string>} */
+        const headers = {};
+        if (strategy.includes("preferredLanguage")) {
+            headers["Vary"] = "Accept-Language";
+        }
+        const response = new Response(null, {
+            status: 307,
+            headers: {
+                Location: decision.redirectUrl.href,
+                ...headers,
+            },
+        });
+        options?.onRedirect?.(response);
+        return response;
+    }
+    // If the strategy includes "url", we need to de-localize the URL
+    // before passing it to the server middleware.
+    //
+    // The middleware is responsible for mapping a localized URL to the
+    // de-localized URL e.g. `/en/about` to `/about`. Otherwise,
+    // the server can't render the correct page.
+    let newRequest;
+    if (strategy.includes("url")) {
+        newRequest = cloneRequestWithFallback(request, runtime.deLocalizeUrl(url));
+    }
+    else {
+        newRequest = cloneRequestWithFallback(request, url);
+    }
+    // the message functions that have been called in this request
+    /** @type {Set<string>} */
+    const messageCalls = new Set();
+    const response = await runtime.serverAsyncLocalStorage?.run({ locale, origin, messageCalls }, () => resolve({ locale, request: newRequest }));
+    // Only modify HTML responses
+    if (runtime.experimentalMiddlewareLocaleSplitting &&
+        response.headers.get("Content-Type")?.includes("html")) {
+        const body = await response.text();
+        const messages = [];
+        // using .values() to avoid polyfilling in older projects. else the following error is thrown
+        // Type 'Set<string>' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher.
+        for (const messageCall of Array.from(messageCalls)) {
+            const [id, locale] = 
+            /** @type {[string, import("./runtime.js").Locale]} */ (messageCall.split(":"));
+            messages.push(`${id}: ${compiledBundles[id]?.[locale]}`);
+        }
+        // Prevent translated content from terminating the inline script tag.
+        const escapedMessages = messages
+            .join(",")
+            .replace(/<\/(script)/gi, "<\\/$1");
+        // Reuse the request's CSP nonce (if any) so the injected script is allowed under a strict CSP
+        const nonce = response.headers
+            .get("Content-Security-Policy")
+            ?.match(/'nonce-([\w+/=-]+)'/)?.[1];
+        const nonceAttr = nonce ? `nonce="${nonce}"` : "";
+        const script = `<script ${nonceAttr}>globalThis.__paraglide = globalThis.__paraglide ?? {}; globalThis.__paraglide.ssr = { ${escapedMessages} }</script>`;
+        // Insert the script before the closing head tag
+        const newBody = body.replace("</head>", `${script}</head>`);
+        // Create a new response with the modified body
+        // Clone all headers except Content-Length which will be set automatically
+        const newHeaders = new Headers(response.headers);
+        newHeaders.delete("Content-Length"); // Let the browser calculate the correct length
+        return new Response(newBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    return response;
+}
+/**
+ * @param {Request} request
+ * @param {string | URL | ((request: Request) => string | URL) | undefined} effectiveRequestUrl
+ * @returns {URL}
+ */
+function resolveMiddlewareUrl(request, effectiveRequestUrl) {
+    if (typeof effectiveRequestUrl === "function") {
+        return new URL(effectiveRequestUrl(request), request.url);
+    }
+    if (typeof effectiveRequestUrl === "string" || effectiveRequestUrl instanceof URL) {
+        return new URL(effectiveRequestUrl, request.url);
+    }
+    return new URL(request.url);
+}
+/**
+ * Some metaframeworks (NextJS) require a new Request object.
+ * https://github.com/opral/inlang-paraglide-js/issues/411
+ *
+ * However, some frameworks (TanStack Start 1.143+) use custom Request
+ * implementations that cannot be cloned with `new Request(request)`.
+ * https://github.com/opral/paraglide-js/issues/573
+ *
+ * Effective request URL overrides behind proxies:
+ * https://github.com/opral/paraglide-js/issues/652
+ *
+ * @param {Request} request
+ * @param {string | URL} [url]
+ * @returns {Request}
+ */
+function cloneRequestWithFallback(request, url = request.url) {
+    const targetUrl = typeof url === "string" ? url : url.href;
+    if (targetUrl === request.url) {
+        try {
+            // Clone first so building a new Request does not consume the original body stream.
+            return new Request(request.clone());
+        }
+        catch {
+            try {
+                return new Request(request);
+            }
+            catch {
+                return request;
+            }
+        }
+    }
+    try {
+        // Clone first so building a new Request does not consume the original body stream.
+        return new Request(targetUrl, request.clone());
+    }
+    catch {
+        try {
+            return new Request(targetUrl, request);
+        }
+        catch {
+            return request;
+        }
+    }
+}
+/**
+ * Creates a mock AsyncLocalStorage implementation for environments where
+ * native AsyncLocalStorage is not available or disabled.
+ *
+ * This mock implementation mimics the behavior of the native AsyncLocalStorage
+ * but doesn't require the async_hooks module. It's used as a fallback when
+ * the runtime does not expose AsyncLocalStorage or when it has been disabled.
+ *
+ * @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
+ */
+function createMockAsyncLocalStorage() {
+    /** @type {any} */
+    let currentStore = undefined;
+    return {
+        getStore() {
+            return currentStore;
+        },
+        async run(store, callback) {
+            currentStore = store;
+            try {
+                return await callback();
+            }
+            finally {
+                currentStore = undefined;
+            }
+        },
+    };
+}
+// Used in generated server.js when async local storage is disabled.
+void createMockAsyncLocalStorage;
+/**
+ * The compiled messages for the server middleware.
+ *
+ * Only populated if `enableMiddlewareOptimizations` is set to `true`.
+ *
+ * @type {Record<string, Record<import("./runtime.js").Locale, string>>}
+ */
+const compiledBundles = {};

package/dist/paraglideAdapter.d.ts

@@ -0,0 +1,86 @@
+export type Locale = 'en' | 'ko';
+
+export interface MessageOptions {
+ readonly locale?: Locale;
+}
+
+export type EmptyMessage = (
+ inputs?: Record<string, never>,
+ options?: MessageOptions,
+) => string;
+
+export type MessageFunction<TInputs extends Record<string, string | number>> = (
+ inputs: TInputs,
+ options?: MessageOptions,
+) => string;
+
+export interface MpgdMessages {
+ readonly action_interstitial_ads: EmptyMessage;
+ readonly action_leaderboard: EmptyMessage;
+ readonly action_localization: EmptyMessage;
+ readonly action_purchases: EmptyMessage;
+ readonly action_reward_ads: EmptyMessage;
+ readonly app_title: EmptyMessage;
+ readonly availability_off: EmptyMessage;
+ readonly availability_on: EmptyMessage;
+ readonly availability_unsupported: EmptyMessage;
+ readonly cap_iap: EmptyMessage;
+ readonly cap_leaderboard: EmptyMessage;
+ readonly cap_localization: EmptyMessage;
+ readonly cap_rewarded_ads: EmptyMessage;
+ readonly cap_save: EmptyMessage;
+ readonly effective_config_summary: MessageFunction<{
+  readonly products: number;
+  readonly ads: number;
+  readonly storage: string;
+ }>;
+ readonly feature_target_disabled: MessageFunction<{ readonly feature: string }>;
+ readonly feature_unavailable: MessageFunction<{ readonly feature: string }>;
+ readonly feature_unsupported: MessageFunction<{ readonly feature: string }>;
+ readonly leaderboard_action: EmptyMessage;
+ readonly leaderboard_action_unavailable: EmptyMessage;
+ readonly leaderboard_opened: EmptyMessage;
+ readonly leaderboard_unavailable: EmptyMessage;
+ readonly loading_player: EmptyMessage;
+ readonly mock_only: EmptyMessage;
+ readonly opening_purchase: EmptyMessage;
+ readonly player: MessageFunction<{ readonly name: string }>;
+ readonly play_again: EmptyMessage;
+ readonly preparing_demo: EmptyMessage;
+ readonly purchase_action: EmptyMessage;
+ readonly purchase_completed: EmptyMessage;
+ readonly purchase_status: MessageFunction<{ readonly status: string }>;
+ readonly purchase_unavailable: EmptyMessage;
+ readonly reward_ad_action: EmptyMessage;
+ readonly reward_ad_unavailable: EmptyMessage;
+ readonly reward_granted: EmptyMessage;
+ readonly reward_unavailable: MessageFunction<{ readonly status: string }>;
+ readonly save_summary: MessageFunction<{
+  readonly bestScore: number;
+  readonly coins: number;
+ }>;
+ readonly saved: EmptyMessage;
+ readonly saved_and_submitted: EmptyMessage;
+ readonly saving_result: EmptyMessage;
+ readonly score: MessageFunction<{ readonly score: number }>;
+ readonly sdk_summary: MessageFunction<{ readonly features: string }>;
+ readonly showing_rewarded_ad: EmptyMessage;
+ readonly status_cleared: EmptyMessage;
+ readonly status_try_again: EmptyMessage;
+ readonly tap_to_start: EmptyMessage;
+ readonly target: MessageFunction<{ readonly target: string }>;
+ readonly target_availability_summary: MessageFunction<{
+  readonly target: string;
+  readonly summary: string;
+ }>;
+ readonly target_config_unavailable: EmptyMessage;
+ readonly target_feature_iap: EmptyMessage;
+ readonly target_feature_interstitial_ads: EmptyMessage;
+ readonly target_feature_leaderboard: EmptyMessage;
+ readonly target_feature_localization: EmptyMessage;
+ readonly target_feature_rewarded_ads: EmptyMessage;
+}
+
+export const m: MpgdMessages;
+export const baseLocale: Locale;
+export const locales: readonly Locale[];

package/dist/paraglideAdapter.js

@@ -0,0 +1,2 @@
+export { m } from './paraglide/messages.js';
+export { baseLocale, locales } from './paraglide/runtime.js';

package/messages/en.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://inlang.com/schema/inlang-message-format",
+  "action_localization": "Localization",
+  "action_interstitial_ads": "Interstitial ads",
+  "action_leaderboard": "Leaderboard",
+  "action_purchases": "Purchases",
+  "action_reward_ads": "Reward ads",
+  "app_title": "MPGD Kit",
+  "availability_off": "off",
+  "availability_on": "on",
+  "availability_unsupported": "n/a",
+  "cap_localization": "localization",
+  "cap_iap": "iap",
+  "cap_leaderboard": "leaderboard",
+  "cap_rewarded_ads": "rewarded ads",
+  "cap_save": "save",
+  "effective_config_summary": "Products {products}, ads {ads}, storage {storage}",
+  "feature_target_disabled": "{feature} disabled for this target.",
+  "feature_unavailable": "{feature} unavailable.",
+  "feature_unsupported": "{feature} unsupported on this target.",
+  "leaderboard_action": "Open leaderboard",
+  "leaderboard_action_unavailable": "Leaderboard unavailable",
+  "leaderboard_opened": "Leaderboard opened.",
+  "leaderboard_unavailable": "Leaderboard unavailable.",
+  "loading_player": "Loading player...",
+  "mock_only": "mock only",
+  "opening_purchase": "Opening mock purchase...",
+  "player": "Player: {name}",
+  "play_again": "Play again",
+  "preparing_demo": "Preparing SDK demo...",
+  "purchase_action": "Buy 100 coins",
+  "purchase_completed": "Purchase completed.",
+  "purchase_status": "Purchase {status}.",
+  "purchase_unavailable": "Purchase unavailable",
+  "reward_ad_action": "Reward ad +10 coins",
+  "reward_ad_unavailable": "Reward ad unavailable",
+  "reward_granted": "Reward granted.",
+  "reward_unavailable": "Reward unavailable: {status}",
+  "save_summary": "Best {bestScore} Coins {coins}",
+  "saved": "Saved.",
+  "saved_and_submitted": "Saved and submitted.",
+  "saving_result": "Saving result...",
+  "score": "Score {score}",
+  "sdk_summary": "SDK: {features}",
+  "showing_rewarded_ad": "Showing rewarded ad...",
+  "status_cleared": "Cleared",
+  "status_try_again": "Try Again",
+  "tap_to_start": "Tap or press Enter",
+  "target": "Target: {target}",
+  "target_availability_summary": "Target {target}: {summary}",
+  "target_config_unavailable": "Target config: unavailable",
+  "target_feature_iap": "IAP",
+  "target_feature_interstitial_ads": "Inter",
+  "target_feature_leaderboard": "Board",
+  "target_feature_localization": "Localization",
+  "target_feature_rewarded_ads": "Reward"
+}

package/messages/ko.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://inlang.com/schema/inlang-message-format",
+  "action_localization": "다국어",
+  "action_interstitial_ads": "전면광고",
+  "action_leaderboard": "랭킹",
+  "action_purchases": "구매",
+  "action_reward_ads": "보상광고",
+  "app_title": "MPGD 키트",
+  "availability_off": "꺼짐",
+  "availability_on": "켜짐",
+  "availability_unsupported": "미지원",
+  "cap_localization": "다국어",
+  "cap_iap": "결제",
+  "cap_leaderboard": "랭킹",
+  "cap_rewarded_ads": "보상광고",
+  "cap_save": "저장",
+  "effective_config_summary": "상품 {products}, 광고 {ads}, 저장소 {storage}",
+  "feature_target_disabled": "{feature} 타깃 비활성.",
+  "feature_unavailable": "{feature} 사용 불가.",
+  "feature_unsupported": "{feature} 이 타깃에서 미지원.",
+  "leaderboard_action": "랭킹 열기",
+  "leaderboard_action_unavailable": "랭킹 사용 불가",
+  "leaderboard_opened": "랭킹 열림.",
+  "leaderboard_unavailable": "랭킹 사용 불가.",
+  "loading_player": "플레이어 불러오는 중...",
+  "mock_only": "목업 전용",
+  "opening_purchase": "목업 구매 여는 중...",
+  "player": "플레이어: {name}",
+  "play_again": "다시 플레이",
+  "preparing_demo": "SDK 데모 준비 중...",
+  "purchase_action": "100 코인 구매",
+  "purchase_completed": "구매 완료.",
+  "purchase_status": "구매 {status}.",
+  "purchase_unavailable": "구매 사용 불가",
+  "reward_ad_action": "보상광고 +10 코인",
+  "reward_ad_unavailable": "보상광고 사용 불가",
+  "reward_granted": "보상 지급 완료.",
+  "reward_unavailable": "보상 사용 불가: {status}",
+  "save_summary": "최고 {bestScore} 코인 {coins}",
+  "saved": "저장됨.",
+  "saved_and_submitted": "저장 및 랭킹 제출 완료.",
+  "saving_result": "결과 저장 중...",
+  "score": "점수 {score}",
+  "sdk_summary": "SDK: {features}",
+  "showing_rewarded_ad": "보상광고 표시 중...",
+  "status_cleared": "클리어",
+  "status_try_again": "다시 도전",
+  "tap_to_start": "탭하거나 Enter",
+  "target": "타깃: {target}",
+  "target_availability_summary": "타깃 {target}: {summary}",
+  "target_config_unavailable": "타깃 설정: 없음",
+  "target_feature_iap": "결제",
+  "target_feature_interstitial_ads": "전면광고",
+  "target_feature_leaderboard": "랭킹",
+  "target_feature_localization": "다국어",
+  "target_feature_rewarded_ads": "보상광고"
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@mpgd/i18n",
+  "version": "0.1.0",
+  "description": "Paraglide-backed message catalog for mpgd demos and target-aware UI.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjlk/mpgd-kit.git",
+    "directory": "packages/i18n"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/mpgd-kit/issues"
+  },
+  "homepage": "https://github.com/imjlk/mpgd-kit#readme",
+  "keywords": [
+    "mpgd",
+    "phaser",
+    "vite",
+    "typescript",
+    "capacitor",
+    "apps-in-toss",
+    "game-development",
+    "game-distribution"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./messages": {
+      "types": "./dist/paraglide/messages.d.ts",
+      "default": "./dist/paraglide/messages.js"
+    },
+    "./runtime": {
+      "types": "./dist/paraglide/runtime.d.ts",
+      "default": "./dist/paraglide/runtime.js"
+    }
+  },
+  "files": [
+    "dist",
+    "messages",
+    "project.inlang"
+  ],
+  "dependencies": {
+    "@mpgd/platform": "0.1.0"
+  },
+  "devDependencies": {
+    "@inlang/paraglide-js": "2.20.2",
+    "@inlang/plugin-message-format": "4.4.0",
+    "@types/node": "^24.0.0",
+    "ttsc": "0.16.9",
+    "typescript": "5.9.3"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "paraglide:build": "paraglide-js compile --project ./project.inlang --outdir ./src/paraglide --emit-ts-declarations",
+    "check": "pnpm paraglide:build && ttsc --noEmit",
+    "lint": "pnpm check",
+    "format": "ttsc format",
+    "fix": "ttsc fix",
+    "test": "pnpm paraglide:build && cd ../.. && pnpm exec ttsx --no-plugins --project tsconfig.graph.json packages/i18n/test/i18n-smoke.ts"
+  }
+}

package/project.inlang/settings.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://inlang.com/schema/project-settings",
+  "baseLocale": "en",
+  "locales": ["en", "ko"],
+  "modules": ["./node_modules/@inlang/plugin-message-format/dist/index.js"],
+  "plugin.inlang.messageFormat": {
+    "pathPattern": "./messages/{locale}.json",
+    "sort": "asc"
+  }
+}