@lionrapid/core 0.1.0

package/dist/browser/lionrapid.iife.dev.js

@@ -0,0 +1,4809 @@
+"use strict";
+var LionRapid = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    CacheManager: () => CacheManager,
+    CacheStorageRepository: () => CacheStorageRepository,
+    Colors: () => Colors,
+    ContentValidator: () => ContentValidator,
+    DefaultStyleMapper: () => DefaultStyleMapper,
+    EventEmitter: () => EventEmitter,
+    HTMLSerializer: () => HTMLSerializer,
+    HandlerChain: () => HandlerChain,
+    LionRapidBuilder: () => LionRapidBuilder,
+    LionRapidCore: () => LionRapidCore,
+    LocalStorageRepository: () => LocalStorageRepository,
+    LogLevel: () => LogLevel,
+    Logger: () => Logger,
+    MarkupParser: () => MarkupParser,
+    MemoryRepository: () => MemoryRepository,
+    MissingTranslationQueue: () => MissingTranslationQueue,
+    NetworkError: () => NetworkError,
+    NetworkRepository: () => NetworkRepository,
+    ServerError: () => ServerError,
+    TranslationError: () => TranslationError,
+    TranslationLockedError: () => TranslationLockedError,
+    TranslationNotFoundError: () => TranslationNotFoundError,
+    VERSION: () => VERSION,
+    createPackageLogger: () => createPackageLogger,
+    isClientError: () => isClientError,
+    isRetryableError: () => isRetryableError,
+    isTranslationError: () => isTranslationError,
+    logger: () => logger,
+    measure: () => measure,
+    parseKeyPath: () => parseKeyPath,
+    prepareTranslationRequest: () => prepareTranslationRequest,
+    resolveNestedKey: () => resolveNestedKey
+  });
+
+  // src/config/logger.config.ts
+  var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+    LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+    LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+    LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+    LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+    LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+    return LogLevel2;
+  })(LogLevel || {});
+
+  // src/utils/logger.ts
+  var IS_PRODUCTION = false;
+  var IS_DEVELOPMENT = true;
+  var IS_CI = false;
+  var LIONRAPID_DEV = true;
+  var PERFORMANCE_TRACKING = true;
+  var LOG_LEVEL_ENV = "DEBUG";
+  var Colors = {
+    // Reset
+    RESET: "\x1B[0m",
+    // Foreground colors
+    BLACK: "\x1B[30m",
+    RED: "\x1B[31m",
+    GREEN: "\x1B[32m",
+    YELLOW: "\x1B[33m",
+    BLUE: "\x1B[34m",
+    MAGENTA: "\x1B[35m",
+    CYAN: "\x1B[36m",
+    WHITE: "\x1B[37m",
+    ORANGE: "\x1B[38;5;208m",
+    // Bright foreground colors
+    BRIGHT_BLACK: "\x1B[90m",
+    BRIGHT_RED: "\x1B[91m",
+    BRIGHT_GREEN: "\x1B[92m",
+    BRIGHT_YELLOW: "\x1B[93m",
+    BRIGHT_BLUE: "\x1B[94m",
+    BRIGHT_MAGENTA: "\x1B[95m",
+    BRIGHT_CYAN: "\x1B[96m",
+    BRIGHT_WHITE: "\x1B[97m",
+    // Styles
+    BOLD: "\x1B[1m",
+    DIM: "\x1B[2m",
+    UNDERLINE: "\x1B[4m"
+  };
+  var DevelopmentLogger = class _DevelopmentLogger {
+    constructor(config = {}) {
+      __publicField(this, "config");
+      this.config = {
+        level: this.getLogLevelFromEnv(),
+        enabled: this.shouldEnableLogging(),
+        prefix: `${config.packageEmoji || "\u{1F4E6}"} ${config.packageName || "LionRapid"}`,
+        showLineNumbers: LIONRAPID_DEV && !IS_CI,
+        useColors: this.shouldUseColors(),
+        ...config
+      };
+    }
+    configure(config) {
+      this.config = { ...this.config, ...config };
+    }
+    debug(message, data) {
+      if (!this.config.enabled || this.config.level > 0 /* DEBUG */) return;
+      this.log(0 /* DEBUG */, message, data);
+    }
+    info(message, data) {
+      if (this.config.level > 1 /* INFO */) return;
+      this.log(1 /* INFO */, message, data);
+    }
+    warn(message, data) {
+      this.log(2 /* WARN */, message, data);
+    }
+    error(message, data) {
+      this.log(3 /* ERROR */, message, data);
+    }
+    time(label) {
+      if (!PERFORMANCE_TRACKING || IS_PRODUCTION) return () => {
+      };
+      const start = IS_DEVELOPMENT ? performance.now() : 0;
+      return () => {
+        if (IS_DEVELOPMENT) {
+          const duration = performance.now() - start;
+          this.debug(`\u23F1\uFE0F ${label}: ${duration.toFixed(2)}ms`, { duration });
+        }
+      };
+    }
+    log(level, message, data) {
+      if (!this.config.enabled || level < this.config.level) return;
+      const levelName = LogLevel[level];
+      const levelEmoji = this.getLevelEmoji(level);
+      const callSite = this.config.showLineNumbers ? this.getCallSite() : null;
+      const logMessage = this.buildColoredMessage(
+        level,
+        levelEmoji,
+        levelName,
+        message,
+        callSite,
+        data
+      );
+      switch (level) {
+        case 3 /* ERROR */:
+          console.error(logMessage);
+          break;
+        case 2 /* WARN */:
+          console.warn(logMessage);
+          break;
+        case 1 /* INFO */:
+          console.info(logMessage);
+          break;
+        default:
+          console.log(logMessage);
+      }
+    }
+    buildColoredMessage(level, emoji, levelName, message, callSite, data) {
+      if (!this.config.useColors) {
+        const locationInfo2 = callSite ? ` (${callSite.fileName}:${callSite.lineNumber})` : "";
+        let logMessage = `${this.config.prefix} ${emoji} ${levelName} ${message}${locationInfo2}`;
+        if (data !== void 0) {
+          logMessage += ` ${JSON.stringify(data)}`;
+        }
+        return logMessage;
+      }
+      const levelColor = this.getLevelColor(level);
+      const reset = Colors.RESET;
+      const coloredPrefix = `${Colors.BOLD}${Colors.ORANGE}${this.config.prefix}${reset}`;
+      const coloredEmoji = emoji;
+      const coloredLevel = `${levelColor}${Colors.BOLD}${levelName}${reset}`;
+      const coloredMessage = `${levelColor}${message}${reset}`;
+      const locationInfo = callSite ? `${Colors.DIM}${Colors.BRIGHT_BLACK} (${callSite.fileName}:${callSite.lineNumber})${reset}` : "";
+      const dataInfo = data !== void 0 ? `${Colors.DIM}${Colors.CYAN} ${JSON.stringify(data)}${reset}` : "";
+      return `${coloredPrefix} ${coloredEmoji} ${coloredLevel} ${coloredMessage}${locationInfo}${dataInfo}`;
+    }
+    getLevelColor(level) {
+      switch (level) {
+        case 0 /* DEBUG */:
+          return Colors.BRIGHT_GREEN;
+        case 1 /* INFO */:
+          return Colors.BRIGHT_CYAN;
+        case 2 /* WARN */:
+          return Colors.BRIGHT_YELLOW;
+        case 3 /* ERROR */:
+          return Colors.BRIGHT_RED;
+        default:
+          return Colors.BRIGHT_BLACK;
+      }
+    }
+    getLevelEmoji(level) {
+      switch (level) {
+        case 0 /* DEBUG */:
+          return "\u{1F50D}";
+        case 1 /* INFO */:
+          return "\u2139\uFE0F";
+        case 2 /* WARN */:
+          return "\u26A0\uFE0F";
+        case 3 /* ERROR */:
+          return "\u274C";
+        default:
+          return "\u{1F4DD}";
+      }
+    }
+    getCallSite() {
+      try {
+        const stack = new Error().stack;
+        if (!stack) return null;
+        const lines = stack.split("\n");
+        for (let i = 3; i < lines.length; i++) {
+          const line = lines[i];
+          if (line && !line.includes("logger.ts") && !line.includes("Logger")) {
+            return this.parseStackLine(line);
+          }
+        }
+      } catch {
+      }
+      return null;
+    }
+    parseStackLine(line) {
+      let match = line.match(/at\s+(.+?)\s+\((.+):(\d+):(\d+)\)/);
+      if (match) {
+        return {
+          functionName: match[1],
+          fileName: this.extractFileName(match[2]),
+          lineNumber: parseInt(match[3], 10)
+        };
+      }
+      match = line.match(/at\s+(.+):(\d+):(\d+)/);
+      if (match) {
+        return {
+          fileName: this.extractFileName(match[1]),
+          lineNumber: parseInt(match[2], 10)
+        };
+      }
+      return null;
+    }
+    extractFileName(filePath) {
+      const parts = filePath.split("/");
+      return parts[parts.length - 1] || filePath;
+    }
+    colorize(text, color) {
+      if (!this.config.useColors) return text;
+      return `${Colors[color]}${text}${Colors.RESET}`;
+    }
+    getColors() {
+      return Colors;
+    }
+    createPackageLogger(packageName, packageEmoji) {
+      return new _DevelopmentLogger({
+        ...this.config,
+        packageName,
+        packageEmoji: packageEmoji || "\u{1F4E6}"
+      });
+    }
+    getLogLevelFromEnv() {
+      switch (LOG_LEVEL_ENV.toUpperCase()) {
+        case "DEBUG":
+          return 0 /* DEBUG */;
+        case "INFO":
+          return 1 /* INFO */;
+        case "WARN":
+          return 2 /* WARN */;
+        case "ERROR":
+          return 3 /* ERROR */;
+        case "NONE":
+          return 4 /* NONE */;
+        default:
+          return 0 /* DEBUG */;
+      }
+    }
+    shouldEnableLogging() {
+      if (LOG_LEVEL_ENV === "NONE") return false;
+      return true;
+    }
+    shouldUseColors() {
+      if (IS_CI) return false;
+      if (typeof window !== "undefined") {
+        return true;
+      }
+      if (typeof process !== "undefined" && void 0) {
+        return false;
+      }
+      return IS_DEVELOPMENT;
+    }
+  };
+  var noop = () => {
+  };
+  var noopWithReturn = () => () => {
+  };
+  var logger = IS_PRODUCTION ? {
+    configure: noop,
+    debug: noop,
+    // ← This eliminates the call completely
+    info: noop,
+    // ← This eliminates the call completely
+    warn: (message, data) => {
+      console.warn(`\u{1F981} LionRapid Core \u26A0\uFE0F ${message}`, data || "");
+    },
+    error: (message, data) => {
+      console.error(`\u{1F981} LionRapid Core \u274C ${message}`, data || "");
+    },
+    time: noopWithReturn,
+    colorize: (text) => text,
+    getColors: () => Colors,
+    createPackageLogger: (packageName, packageEmoji) => ({
+      configure: noop,
+      debug: noop,
+      // ← Package logger debug also eliminated
+      info: noop,
+      // ← Package logger info also eliminated
+      warn: (message, data) => {
+        const prefix = `${packageEmoji || "\u{1F4E6}"} ${packageName}`;
+        console.warn(`${prefix} \u26A0\uFE0F ${message}`, data || "");
+      },
+      error: (message, data) => {
+        const prefix = `${packageEmoji || "\u{1F4E6}"} ${packageName}`;
+        console.error(`${prefix} \u274C ${message}`, data || "");
+      },
+      time: noopWithReturn,
+      colorize: (text) => text,
+      getColors: () => Colors,
+      createPackageLogger: noop
+    })
+  } : new DevelopmentLogger({
+    packageName: "LionRapid Core",
+    packageEmoji: "\u{1F981}"
+  });
+  var Logger = IS_PRODUCTION ? function Logger2() {
+    return logger;
+  } : DevelopmentLogger;
+  var createPackageLogger = (config) => {
+    if (IS_PRODUCTION) {
+      const prefix = `${config.packageEmoji || "\u{1F4E6}"} ${config.packageName || "LionRapid"}`;
+      return {
+        configure: noop,
+        debug: noop,
+        // ← All debug calls eliminated
+        info: noop,
+        // ← All info calls eliminated
+        warn: (message, data) => {
+          console.warn(`${prefix} \u26A0\uFE0F ${message}`, data || "");
+        },
+        error: (message, data) => {
+          console.error(`${prefix} \u274C ${message}`, data || "");
+        },
+        time: noopWithReturn,
+        colorize: (text) => text,
+        getColors: () => Colors,
+        createPackageLogger: noop
+      };
+    }
+    return new DevelopmentLogger(config);
+  };
+  var measure = (name) => {
+    if (IS_PRODUCTION) {
+      return {
+        start: noop,
+        end: noop,
+        elapsed: () => 0
+      };
+    }
+    let startTime;
+    return {
+      start: () => {
+        if (IS_DEVELOPMENT) {
+          startTime = performance.now();
+          logger.debug(`\u23F1\uFE0F ${name} - started`);
+        }
+      },
+      end: () => {
+        if (IS_DEVELOPMENT) {
+          const duration = performance.now() - startTime;
+          logger.debug(`\u23F1\uFE0F ${name} - completed in ${duration.toFixed(2)}ms`);
+          return duration;
+        }
+        return 0;
+      },
+      elapsed: () => IS_DEVELOPMENT ? performance.now() - startTime : 0
+    };
+  };
+
+  // src/base/event-emitter.ts
+  var EventEmitter = class {
+    constructor() {
+      // ✅ Properly typed event listeners without `any`
+      __publicField(this, "eventListeners", /* @__PURE__ */ new Map());
+      __publicField(this, "debugMode", true);
+    }
+    /**
+     * Subscribe to events (PUBLIC API) - Fully type-safe
+     */
+    on(event, listener) {
+      if (!this.eventListeners.has(event)) {
+        this.eventListeners.set(event, /* @__PURE__ */ new Set());
+      }
+      const listeners = this.eventListeners.get(event);
+      listeners.add(listener);
+    }
+    /**
+     * Unsubscribe from events (PUBLIC API) - Fully type-safe
+     */
+    off(event, listener) {
+      const listeners = this.eventListeners.get(event);
+      if (listeners) {
+        listeners.delete(listener);
+      }
+    }
+    /**
+     * ✅ Type-safe emit with proper generic constraint
+     */
+    emit(event, envelope) {
+      const listeners = this.eventListeners.get(event);
+      if (listeners) {
+        listeners.forEach((listener) => {
+          try {
+            listener(envelope);
+          } catch (error) {
+            console.error(`Error in event listener for ${String(event)}:`, error);
+          }
+        });
+      }
+    }
+    hasListeners(event) {
+      return this.eventListeners.has(event) && this.eventListeners.get(event).size > 0;
+    }
+    clearEvents() {
+      this.eventListeners.clear();
+    }
+    /**
+     * ✅ Create base context once per request
+     */
+    createContext(requestId, trace, extra) {
+      return {
+        requestId,
+        timestamp: performance.now(),
+        trace,
+        ...extra
+      };
+    }
+    /**
+     * ✅ Type-safe event emission helper
+     */
+    emitEvent(event, payload, requestId, trace) {
+      this.emit(event, {
+        context: this.createContext(requestId, trace),
+        payload
+      });
+    }
+    /**
+     * ✅ Translation event builder with proper typing
+     */
+    translation(request, handler) {
+      const baseTrace = ["translation"];
+      const handlerTrace = handler ? [...baseTrace, handler] : baseTrace;
+      return {
+        request: () => {
+          this.emit("translation:request", {
+            context: this.createContext(request.id, [...baseTrace, "request"]),
+            payload: { key: request.cleanKey }
+          });
+        },
+        success: (value) => {
+          this.emit("translation:success", {
+            context: this.createContext(request.id, [...handlerTrace, "success"]),
+            payload: { key: request.cleanKey, value }
+          });
+        },
+        fallback: (value) => {
+          this.emit("translation:fallback", {
+            context: this.createContext(request.id, [...baseTrace, "fallback"]),
+            payload: { key: request.cleanKey, value }
+          });
+        },
+        missing: (fallbackValue, locale, namespace) => {
+          this.emit("translation:missing", {
+            context: this.createContext(request.id, [...baseTrace, "missing"]),
+            payload: {
+              key: request.cleanKey,
+              fallbackValue,
+              locale,
+              namespace
+            }
+          });
+        },
+        notFound: (fallbackValue, locale, namespace) => {
+          this.emit("translation:not-found", {
+            context: this.createContext(request.id, [...baseTrace, "not-found"]),
+            payload: {
+              key: request.cleanKey,
+              fallbackValue,
+              locale,
+              namespace,
+              status: 404
+            }
+          });
+        },
+        locked: (fallbackValue, locale, namespace) => {
+          this.emit("translation:locked", {
+            context: this.createContext(request.id, [...baseTrace, "locked"]),
+            payload: {
+              key: request.cleanKey,
+              fallbackValue,
+              locale,
+              namespace,
+              status: 423
+            }
+          });
+        }
+      };
+    }
+    /**
+     * ✅ Repository event builder with better typing
+     */
+    repo(request, source) {
+      const baseTrace = ["repo", source];
+      return {
+        getStart: () => {
+          if (typeof request === "string") return;
+          this.emit("repo:get:start", {
+            context: this.createContext(request.id, [
+              ...baseTrace,
+              "get",
+              "start"
+            ]),
+            payload: { key: request.cleanKey, source }
+          });
+        },
+        getSuccess: (value) => {
+          if (typeof request === "string") return;
+          this.emit("repo:get:success", {
+            context: this.createContext(request.id, [
+              ...baseTrace,
+              "get",
+              "success"
+            ]),
+            payload: { key: request.cleanKey, value, source }
+          });
+        },
+        getMiss: () => {
+          if (typeof request === "string") return;
+          this.emit("repo:get:miss", {
+            context: this.createContext(request.id, [
+              ...baseTrace,
+              "get",
+              "miss"
+            ]),
+            payload: { key: request.cleanKey, source }
+          });
+        },
+        setStart: (value) => {
+          if (typeof request === "string") return;
+          this.emit("repo:set:start", {
+            context: this.createContext(request.id, [
+              ...baseTrace,
+              "set",
+              "start"
+            ]),
+            payload: { key: request.cleanKey, value, source }
+          });
+        },
+        setSuccess: (value) => {
+          const id = typeof request === "string" ? "system" : request.id;
+          const key = typeof request === "string" ? request : request.cleanKey;
+          this.emit("repo:set:success", {
+            context: this.createContext(id, [...baseTrace, "set", "success"]),
+            payload: { key, value, source }
+          });
+        },
+        error: (error) => {
+          if (typeof request === "string") return;
+          this.emit("repo:error", {
+            context: this.createContext(request.id, [...baseTrace, "error"]),
+            payload: { key: request.cleanKey, source, error }
+          });
+        }
+      };
+    }
+    /**
+     * ✅ Network event builder
+     */
+    network(request, method) {
+      const key = typeof request === "string" ? request : request.cleanKey;
+      const requestId = typeof request === "string" ? "network" : request.id;
+      const baseTrace = ["network", method || "request"];
+      return {
+        start: () => {
+          this.emit("network:request:start", {
+            context: this.createContext(requestId, [...baseTrace, "start"]),
+            payload: { key }
+          });
+        },
+        success: (value) => {
+          this.emit("network:request:success", {
+            context: this.createContext(requestId, [...baseTrace, "success"]),
+            payload: { key, value, method: method || "GET" }
+          });
+        },
+        error: (error, status) => {
+          this.emit("network:request:error", {
+            context: this.createContext(requestId, [...baseTrace, "error"]),
+            payload: {
+              key,
+              method: method || "GET",
+              error,
+              ...status && { status }
+            }
+          });
+        },
+        retry: (attempt, delayMs, reason) => {
+          this.emit("network:retry", {
+            context: this.createContext(requestId, [...baseTrace, "retry"]),
+            payload: { key, attempt, delayMs, ...reason && { reason } }
+          });
+        }
+      };
+    }
+    /**
+     * ✅ Builder event builder
+     */
+    builder() {
+      const baseTrace = ["builder"];
+      const systemId = `build-${Date.now()}`;
+      return {
+        use: (type) => {
+          this.emit("builder:use", {
+            context: this.createContext(systemId, [...baseTrace, "use"]),
+            payload: { type }
+          });
+        },
+        buildStart: (locale, namespace) => {
+          this.emit("builder:build:start", {
+            context: this.createContext(systemId, [
+              ...baseTrace,
+              "build",
+              "start"
+            ]),
+            payload: { locale, namespace }
+          });
+        },
+        buildDone: (repositories, plugins) => {
+          this.emit("builder:build:done", {
+            context: this.createContext(systemId, [
+              ...baseTrace,
+              "build",
+              "done"
+            ]),
+            payload: { repositories, plugins }
+          });
+        }
+      };
+    }
+    /**
+     * ✅ Language change event builder
+     */
+    language(oldLocale, newLocale) {
+      const requestId = `lang-change-${Date.now()}`;
+      const baseTrace = ["language", "change"];
+      return {
+        start: () => {
+          this.emit("language:change:start", {
+            context: this.createContext(requestId, [...baseTrace, "start"]),
+            payload: { oldLocale, newLocale }
+          });
+        },
+        complete: () => {
+          this.emit("language:change:success", {
+            context: this.createContext(requestId, [...baseTrace, "complete"]),
+            payload: { oldLocale, newLocale }
+          });
+        },
+        error: (error) => {
+          this.emit("language:change:error", {
+            context: this.createContext(requestId, [...baseTrace, "error"]),
+            payload: { oldLocale, newLocale, error }
+          });
+        }
+      };
+    }
+    /**
+     * ✅ Cache operations (debug only)
+     */
+    cache(operation, reason, stats) {
+      if (!this.debugMode) return { start: () => {
+      }, complete: () => {
+      } };
+      return {
+        start: () => {
+          logger.debug(`\u{1F9F9} Cache ${operation} starting: ${reason}`);
+        },
+        complete: () => {
+          logger.debug(
+            `\u2705 Cache ${operation} complete: ${stats?.clearedCount || 0} entries`
+          );
+        }
+      };
+    }
+  };
+
+  // src/handlers/handler-chain.ts
+  var HandlerChain = class {
+    constructor(eventEmitter) {
+      __publicField(this, "asyncHandlers", []);
+      __publicField(this, "syncHandlers", []);
+      __publicField(this, "bus");
+      this.bus = eventEmitter;
+    }
+    addSyncHandler(handler) {
+      if (!handler.enabled) return;
+      this.syncHandlers.push(handler);
+      this.sortHandlersIfNeeded(this.syncHandlers);
+      logger.debug(`Sync handler added: ${handler.name}`);
+    }
+    handleSync(request) {
+      for (const handler of this.syncHandlers) {
+        try {
+          const result = handler.lookup(request);
+          if (result !== null && result.value) {
+            logger.debug(`Sync hit: ${handler.name} (${result.duration}ms)`);
+            return result;
+          }
+        } catch (error) {
+          logger.warn(`Sync lookup failed in ${handler.name}:`, error);
+          const repoBus = this.bus.repo(request, handler.name);
+          repoBus.error(error);
+          continue;
+        }
+      }
+      return null;
+    }
+    saveToMemoryHandlers(request, result, _sourceHandler) {
+      const memoryHandlers = this.syncHandlers;
+      if (memoryHandlers.length === 0) return;
+      logger.debug(`Saving to ${memoryHandlers.length} memory handlers`);
+      memoryHandlers.forEach((handler) => {
+        try {
+          handler.save(request, result);
+          logger.debug(`Saved to memory: ${handler.name}`);
+        } catch (error) {
+          logger.warn(`Failed to save to memory ${handler.name}:`, error);
+          const repoBus = this.bus.repo(request, handler.name);
+          repoBus.error(error);
+        }
+      });
+    }
+    saveNamespaceToMemoryHandlers(translations, context) {
+      const memoryHandlers = this.syncHandlers.filter(
+        (h) => h.type === "memory" && h.saveNamespace
+      );
+      if (memoryHandlers.length === 0) return;
+      logger.debug(
+        `Saving namespace to ${memoryHandlers.length} memory handlers`
+      );
+      memoryHandlers.forEach((handler) => {
+        try {
+          handler.saveNamespace(translations, context);
+          logger.debug(`Namespace saved to memory: ${handler.name}`, {
+            locale: context.locale,
+            namespace: context.namespace
+          });
+        } catch (error) {
+          logger.warn(
+            `Failed to save namespace to memory ${handler.name}:`,
+            error
+          );
+          const repoBus = this.bus.repo(
+            `${context.locale}:${context.namespace}`,
+            handler.name
+          );
+          repoBus.error(error);
+        }
+      });
+    }
+    addAsyncHandler(handler) {
+      if (!handler.enabled) return;
+      this.asyncHandlers.push(handler);
+      this.sortHandlersIfNeeded(this.asyncHandlers);
+      logger.debug(`Async handler added: ${handler.name}`);
+    }
+    async handleAsync(request) {
+      for (const handler of this.asyncHandlers) {
+        try {
+          logger.debug(`Trying handler: ${handler.name}`);
+          const result = await handler.lookup(request);
+          if (result.value && result.status === 200) {
+            logger.debug(`Async hit: ${handler.name} (${result.duration}ms)`);
+            if (result.namespaceLoaded) {
+              logger.debug(
+                `Saving loaded namespace: ${result.namespaceLoaded.locale}:${result.namespaceLoaded.namespace}`
+              );
+              await this.saveNamespaceToHandlers(result.namespaceLoaded.data, {
+                locale: result.namespaceLoaded.locale,
+                namespace: result.namespaceLoaded.namespace
+              });
+              return result;
+            }
+            await this.saveToStorageHandlers(request, result, handler);
+            this.saveToMemoryHandlers(request, result, handler);
+            return result;
+          }
+          logger.debug(
+            `Handler ${handler.name} returned fallback (status: ${result.status})`
+          );
+        } catch (error) {
+          logger.warn(`Handler ${handler.name} failed:`, error);
+          const repoBus = this.bus.repo(request, handler.name);
+          repoBus.error(error);
+          continue;
+        }
+      }
+      logger.debug(`No async handlers found translation for ${request.cleanKey}`);
+      return null;
+    }
+    /**
+     * Save translation to all storage handlers that come before the source handler
+     */
+    async saveToStorageHandlers(request, result, sourceHandler) {
+      const sourceIndex = this.asyncHandlers.indexOf(sourceHandler);
+      const storageHandlers = this.asyncHandlers.slice(0, sourceIndex).filter((h) => h.type === "storage");
+      if (storageHandlers.length === 0) return;
+      logger.debug(`Saving to ${storageHandlers.length} storage handlers`);
+      const savePromises = storageHandlers.map(async (handler) => {
+        try {
+          await handler.save(request, result);
+          logger.debug(`Saved to storage: ${handler.name}`);
+        } catch (error) {
+          logger.warn(`Failed to save to storage ${handler.name}:`, error);
+          const repoBus = this.bus.repo(request, handler.name);
+          repoBus.error(error);
+        }
+      });
+      await Promise.allSettled(savePromises);
+    }
+    async saveNamespaceToStorageHandlers(translations, context) {
+      const storageHandlers = this.asyncHandlers.filter(
+        (h) => h.type === "storage" && h.saveNamespace
+      );
+      if (storageHandlers.length === 0) return;
+      logger.debug(
+        `Saving namespace to ${storageHandlers.length} storage handlers`
+      );
+      const savePromises = storageHandlers.map(async (handler) => {
+        try {
+          await handler.saveNamespace(translations, context);
+          logger.debug(`Namespace saved to storage: ${handler.name}`, {
+            locale: context.locale,
+            namespace: context.namespace
+          });
+        } catch (error) {
+          logger.warn(
+            `Failed to save namespace to storage ${handler.name}:`,
+            error
+          );
+          const repoBus = this.bus.repo(
+            `${context.locale}:${context.namespace}`,
+            handler.name
+          );
+          repoBus.error(error);
+        }
+      });
+      await Promise.allSettled(savePromises);
+    }
+    async saveNamespaceToHandlers(translations, context) {
+      this.saveNamespaceToMemoryHandlers(translations, context);
+      await this.saveNamespaceToStorageHandlers(translations, context);
+    }
+    getSyncHandlers() {
+      return [...this.syncHandlers];
+    }
+    getAsyncHandlers() {
+      return [...this.asyncHandlers];
+    }
+    /**
+     * Get chain info for debugging
+     */
+    getChainInfo() {
+      return {
+        length: this.syncHandlers.length + this.asyncHandlers.length,
+        handlers: [
+          ...this.syncHandlers.map((h) => ({
+            name: h.name,
+            priority: h.priority,
+            type: h.type,
+            enabled: h.enabled
+          })),
+          ...this.asyncHandlers.map((h) => ({
+            name: h.name,
+            priority: h.priority,
+            type: h.type,
+            enabled: h.enabled
+          }))
+        ]
+      };
+    }
+    /**
+     * Check if any handler has cached data
+     */
+    isCached(request) {
+      return this.syncHandlers.some((h) => h.isCached?.(request) === true) || this.asyncHandlers.some((h) => h.isCached?.(request) === true);
+    }
+    /**
+     * Get combined cache entries
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getEntries() {
+      const entries = {};
+      const allHandlers = [...this.syncHandlers, ...this.asyncHandlers];
+      for (const handler of allHandlers) {
+        if (handler.getEntries) {
+          entries[handler.name] = handler.getEntries();
+        }
+      }
+      return entries;
+    }
+    /**
+     * Destroy all handlers
+     */
+    async destroy() {
+      const allHandlers = [...this.syncHandlers, ...this.asyncHandlers];
+      const destroyPromises = allHandlers.map(async (handler) => {
+        try {
+          await handler.destroy?.();
+          logger.debug(`Handler destroyed: ${handler.name}`);
+        } catch (error) {
+          logger.warn(`Failed to destroy handler: ${handler.name}`, error);
+        }
+      });
+      await Promise.allSettled(destroyPromises);
+      this.syncHandlers = [];
+      this.asyncHandlers = [];
+    }
+    sortHandlersIfNeeded(handlers) {
+      const hasExplicitPriorities = handlers.some((h) => h.priority > 0);
+      if (hasExplicitPriorities) {
+        handlers.sort((a, b) => {
+          const priorityA = a.priority || Number.MAX_SAFE_INTEGER;
+          const priorityB = b.priority || Number.MAX_SAFE_INTEGER;
+          return priorityA - priorityB;
+        });
+      }
+    }
+    async loadNamespace(locale, namespace) {
+      for (const handler of this.asyncHandlers) {
+        if (handler.type !== "network") continue;
+        try {
+          logger.debug(
+            `Trying to load namespace: ${locale}:${namespace} from ${handler.name}`
+          );
+          const result = await handler.loadNamespace?.(locale, namespace);
+          if (result && result.data && result.status === 200) {
+            logger.debug(
+              `Loaded namespace: ${locale}:${namespace} from ${handler.name}`
+            );
+            await this.saveNamespaceToStorageHandlers(result.data, {
+              namespace,
+              locale
+            });
+            this.saveNamespaceToMemoryHandlers(result.data, {
+              namespace,
+              locale
+            });
+            return result.data;
+          }
+        } catch (error) {
+          logger.warn(
+            `Failed to load namespace: ${locale}:${namespace} from ${handler.name}`,
+            error
+          );
+          const repoBus = this.bus.repo(`${locale}:${namespace}`, handler.name);
+          repoBus.error(error);
+          continue;
+        }
+      }
+      logger.debug(`No handlers found namespace: ${locale}:${namespace}`);
+      return null;
+    }
+    clearCache() {
+      const allHandlers = [...this.syncHandlers, ...this.asyncHandlers];
+      for (const handler of allHandlers) {
+        try {
+          handler.destroy?.();
+          logger.debug(`Cache cleared for handler: ${handler.name}`);
+        } catch (error) {
+          logger.warn(
+            `Failed to clear cache for handler: ${handler.name}`,
+            error
+          );
+        }
+      }
+      logger.debug("Cache cleared for all handlers");
+    }
+    /**
+     * Clear cache entries for a specific namespace
+     */
+    clearNamespace(locale, namespace) {
+      for (const handler of this.syncHandlers) {
+        try {
+          handler.clearNamespace?.(locale, namespace);
+        } catch (error) {
+          logger.warn(
+            `Failed to clear namespace for handler: ${handler.name}`,
+            error
+          );
+        }
+      }
+      logger.debug(`Cleared namespace: ${locale}:${namespace}`);
+    }
+    /**
+     * Set a value directly in the cache (for optimistic updates)
+     * Bypasses the normal handler flow to directly set values in memory handlers
+     * Stores as ContentUnit (text + styles) for consistency
+     *
+     * @param key - Full cache key (e.g., 'en:app:welcome')
+     * @param value - Translation value
+     * @param styles - Optional styles for indexed tags
+     */
+    setCache(key, value, styles) {
+      for (const handler of this.syncHandlers) {
+        if (handler.type === "memory" && handler.setCache) {
+          try {
+            handler.setCache(key, value, styles);
+          } catch (error) {
+            logger.warn(`Failed to set cache in handler: ${handler.name}`, error);
+          }
+        }
+      }
+      logger.debug(`Cache set: ${key}`);
+    }
+    /**
+     * Get namespace data from cache for ContentUnit style lookup
+     *
+     * Used by t() to retrieve styles for indexed tags at render time.
+     *
+     * @param namespaceCacheKey - Cache key in format @locale:namespace
+     * @returns Parsed namespace data or null if not found
+     */
+    getNamespaceData(namespaceCacheKey) {
+      for (const handler of this.syncHandlers) {
+        if (handler.type === "memory") {
+          try {
+            const entries = handler.getEntries?.();
+            if (entries && entries[namespaceCacheKey]) {
+              const data = entries[namespaceCacheKey];
+              if (typeof data === "string") {
+                return JSON.parse(data);
+              }
+              return data;
+            }
+          } catch (error) {
+            logger.debug(`Error getting namespace data from ${handler.name}:`, error);
+          }
+        }
+      }
+      return null;
+    }
+  };
+
+  // src/utils/namespace-utils.ts
+  function parseNamespaceKey(key) {
+    const colonIndex = key.indexOf(":");
+    if (colonIndex > 0 && colonIndex < key.length - 1) {
+      const namespace = key.substring(0, colonIndex);
+      const cleanKey = key.substring(colonIndex + 1);
+      return {
+        originalKey: key,
+        namespace,
+        cleanKey,
+        hasExplicitNamespace: true
+      };
+    }
+    return {
+      originalKey: key,
+      cleanKey: key,
+      hasExplicitNamespace: false
+    };
+  }
+
+  // src/utils/context-utils.ts
+  function createTranslationContext(parsedKey, currentLocale, defaultNamespace, fallbackLocale) {
+    const effectiveNamespace = parsedKey.hasExplicitNamespace ? parsedKey.namespace : defaultNamespace;
+    return {
+      locale: currentLocale,
+      namespace: effectiveNamespace,
+      fallbackLocale: fallbackLocale || currentLocale
+    };
+  }
+
+  // src/utils/translation-value-utils.ts
+  function resolveNestedKey(namespace, keyPath) {
+    if (!namespace || !keyPath) {
+      return void 0;
+    }
+    if (!keyPath.includes(".") && !keyPath.includes("[")) {
+      return namespace[keyPath];
+    }
+    try {
+      const keys = parseKeyPath(keyPath);
+      let current = namespace;
+      for (const key of keys) {
+        if (current === null || current === void 0) {
+          logger.debug(
+            `\u{1F50D} Nested key resolution stopped at null/undefined for: ${keyPath}`
+          );
+          return void 0;
+        }
+        if (typeof key === "number") {
+          if (!Array.isArray(current)) {
+            logger.debug(
+              `\u{1F50D} Expected array for index ${key} in path: ${keyPath}`
+            );
+            return void 0;
+          }
+          current = current[key];
+        } else {
+          if (typeof current !== "object") {
+            logger.debug(
+              `\u{1F50D} Expected object for key '${key}' in path: ${keyPath}`
+            );
+            return void 0;
+          }
+          current = current[key];
+        }
+      }
+      logger.debug(
+        `\u{1F50D} Nested key resolved: ${keyPath} \u2192 ${typeof current === "object" ? "[Object]" : current}`
+      );
+      return current;
+    } catch (error) {
+      logger.debug(`\u{1F50D} Nested key resolution error for '${keyPath}':`, error);
+      return void 0;
+    }
+  }
+  function parseKeyPath(keyPath) {
+    const keys = [];
+    let currentKey = "";
+    let inBrackets = false;
+    for (let i = 0; i < keyPath.length; i++) {
+      const char = keyPath[i];
+      if (char === "." && !inBrackets) {
+        if (currentKey) {
+          keys.push(currentKey);
+          currentKey = "";
+        }
+      } else if (char === "[") {
+        if (currentKey) {
+          keys.push(currentKey);
+          currentKey = "";
+        }
+        inBrackets = true;
+      } else if (char === "]" && inBrackets) {
+        if (currentKey) {
+          const index = parseInt(currentKey, 10);
+          if (!isNaN(index)) {
+            keys.push(index);
+          } else {
+            keys.push(currentKey);
+          }
+          currentKey = "";
+        }
+        inBrackets = false;
+      } else {
+        currentKey += char;
+      }
+    }
+    if (currentKey) {
+      keys.push(currentKey);
+    }
+    return keys;
+  }
+  function createIndividualCacheKey(locale, namespace, key) {
+    const parts = [locale];
+    if (namespace) {
+      parts.push(namespace);
+    }
+    parts.push(key);
+    return parts.join(":");
+  }
+  function createNamespaceCacheKey(locale, namespace) {
+    return `@${locale}:${namespace}`;
+  }
+  function flattenTranslations(translations, prefix = "", locale, namespace) {
+    const flattened = {};
+    for (const [key, value] of Object.entries(translations)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      const cacheKey = createIndividualCacheKey(locale, namespace, fullKey);
+      if (typeof value === "object" && value !== null && "text" in value && "styles" in value) {
+        flattened[cacheKey] = JSON.stringify(value);
+      } else if (typeof value === "object" && value !== null) {
+        Object.assign(
+          flattened,
+          flattenTranslations(value, fullKey, locale, namespace)
+        );
+      } else {
+        flattened[cacheKey] = JSON.stringify({ text: String(value), styles: {} });
+      }
+    }
+    return flattened;
+  }
+
+  // src/utils/translation-flow.ts
+  function prepareTranslationRequest(key, currentLocale, defaultValueOrParams, paramsOrDefaultValue, defaultNamespace, fallbackLocale) {
+    const startTime = performance.now();
+    const { defaultValue, params } = parseTranslationParams(
+      defaultValueOrParams,
+      paramsOrDefaultValue
+    );
+    const parsedKey = parseNamespaceKey(key);
+    const context = createTranslationContext(
+      parsedKey,
+      currentLocale,
+      defaultNamespace,
+      fallbackLocale
+    );
+    const individualCacheKey = createIndividualCacheKey(
+      context.locale,
+      context.namespace,
+      parsedKey.cleanKey
+    );
+    const namespaceCacheKey = context.namespace ? createNamespaceCacheKey(context.locale, context.namespace) : void 0;
+    const id = `${individualCacheKey}-${startTime}`;
+    return {
+      id,
+      // Unique request ID
+      originalKey: key,
+      originalParams: defaultValueOrParams,
+      originalDefaultValue: paramsOrDefaultValue,
+      cleanKey: parsedKey.cleanKey,
+      hasExplicitNamespace: parsedKey.hasExplicitNamespace,
+      parsedParams: params,
+      parsedDefaultValue: defaultValue,
+      locale: currentLocale,
+      namespace: context.namespace,
+      // ✅ Use effective namespace (explicit or default)
+      fallbackLocale,
+      individualCacheKey,
+      // ✅ Ready-to-use cache key
+      namespaceCacheKey,
+      // ✅ Ready-to-use namespace key
+      startTime
+    };
+  }
+  function parseTranslationParams(secondParam, thirdParam) {
+    let defaultValue;
+    let params;
+    if (typeof secondParam === "object" && typeof thirdParam === "object" && true) {
+      console.warn(
+        "[LionRapid] Warning: Both secondParam and thirdParam are objects. Expected pattern: t(key, params, defaultValue) or t(key, defaultValue, params). Second object will be ignored as it cannot be a defaultValue."
+      );
+    }
+    if (typeof secondParam === "string") {
+      defaultValue = secondParam;
+      if (typeof thirdParam === "object") {
+        params = thirdParam;
+      }
+    } else if (typeof secondParam === "object") {
+      params = secondParam;
+      if (typeof thirdParam === "string") {
+        defaultValue = thirdParam;
+      }
+    }
+    return { defaultValue, params };
+  }
+
+  // src/handlers/sync-storage-handler.ts
+  var SyncHandler = class {
+    constructor(eventEmitter, repository) {
+      __publicField(this, "name");
+      __publicField(this, "version", "1.0.0");
+      __publicField(this, "priority");
+      __publicField(this, "type", "memory");
+      __publicField(this, "enabled");
+      __publicField(this, "ttlMap", /* @__PURE__ */ new Map());
+      __publicField(this, "ttl");
+      __publicField(this, "repository");
+      __publicField(this, "bus");
+      this.bus = eventEmitter;
+      this.repository = repository;
+      this.name = repository.name;
+      const config = repository.getConfig();
+      this.enabled = config.enabled ?? true;
+      this.priority = config.priority ?? 0;
+      this.ttl = config.options?.ttl ?? 30 * 60 * 1e3;
+    }
+    getSourceType() {
+      return "memory";
+    }
+    /**
+     * Simple lookup implementation
+     * Returns ContentUnit with both text and styles
+     */
+    lookup(request) {
+      const startTime = Date.now();
+      logger.debug(`Sync lookup: ${request.cleanKey}`);
+      const repoBus = this.bus.repo(request, this.name);
+      repoBus.getStart();
+      const directResult = this.tryDirectLookup(request);
+      if (directResult !== null) {
+        logger.debug(`Cache hit: ${request.cleanKey}`);
+        repoBus.getSuccess(directResult.text);
+        return this.createResult(directResult, "memory", 200, startTime, true);
+      }
+      if (request.cleanKey.includes(".") && request.namespace) {
+        const namespaceResult = this.tryNamespaceLookup(request);
+        if (namespaceResult !== null) {
+          logger.debug(`Namespace hit: ${request.cleanKey}`);
+          repoBus.getSuccess(namespaceResult.text);
+          return this.createResult(
+            namespaceResult,
+            "memory",
+            200,
+            startTime,
+            true
+          );
+        }
+      }
+      logger.debug(`Cache miss: ${request.cleanKey}`);
+      repoBus.getMiss();
+      return this.createResult(
+        { text: request.parsedDefaultValue || request.cleanKey, styles: {} },
+        "fallback",
+        404,
+        startTime
+      );
+    }
+    /**
+     * Simple save implementation
+     * Stores ContentUnit (text + styles) as JSON
+     */
+    save(request, result) {
+      if (!result.value) return;
+      const repoBus = this.bus.repo(request, this.name);
+      const contentUnit = {
+        text: result.value,
+        styles: result.styles || {}
+      };
+      this.setWithTTL(request.individualCacheKey, JSON.stringify(contentUnit));
+      logger.debug(`Saved to cache: ${request.cleanKey}`);
+      repoBus.setSuccess(result.value);
+    }
+    /**
+     * Namespace saving implementation
+     */
+    saveNamespace(translations, context) {
+      if (!context.namespace) return;
+      const repoBus = this.bus.repo(
+        context.locale + ":" + context.namespace,
+        this.name
+      );
+      const namespaceCacheKey = createNamespaceCacheKey(
+        context.locale,
+        context.namespace
+      );
+      this.setWithTTL(namespaceCacheKey, JSON.stringify(translations));
+      const flattened = flattenTranslations(
+        translations,
+        "",
+        context.locale,
+        context.namespace
+      );
+      for (const [flatKey, flatValue] of Object.entries(flattened)) {
+        this.setWithTTL(flatKey, flatValue);
+      }
+      repoBus.setSuccess(JSON.stringify(translations));
+    }
+    /**
+     * ✅ Strategy 1: Direct cache lookup using unified pattern
+     * Returns parsed ContentUnit (text + styles) or null
+     */
+    tryDirectLookup(request) {
+      if (this.checkAndExpireTTL(request.individualCacheKey)) {
+        return null;
+      }
+      const cachedValue = this.repository.get(request.individualCacheKey);
+      if (!cachedValue) return null;
+      this.refreshTTL(request.individualCacheKey);
+      try {
+        const parsed = JSON.parse(cachedValue);
+        if (typeof parsed === "object" && "text" in parsed) {
+          return {
+            text: String(parsed.text),
+            styles: parsed.styles || {}
+          };
+        }
+        return { text: cachedValue, styles: {} };
+      } catch {
+        return { text: cachedValue, styles: {} };
+      }
+    }
+    /**
+     * ✅ Strategy 2: Namespace lookup using unified pattern
+     * Returns parsed ContentUnit (text + styles) or null
+     */
+    tryNamespaceLookup(request) {
+      if (!request.namespace) return null;
+      const namespaceCacheKey = createNamespaceCacheKey(
+        request.locale,
+        request.namespace
+      );
+      if (this.checkAndExpireTTL(namespaceCacheKey)) {
+        return null;
+      }
+      const namespaceData = this.repository.get(namespaceCacheKey);
+      if (!namespaceData) return null;
+      this.refreshTTL(namespaceCacheKey);
+      try {
+        const translations = JSON.parse(namespaceData);
+        const value = resolveNestedKey(translations, request.cleanKey);
+        if (value !== null && value !== void 0) {
+          let contentUnit;
+          if (typeof value === "object" && value !== null && "text" in value) {
+            contentUnit = {
+              text: String(value.text),
+              styles: value.styles || {}
+            };
+          } else {
+            contentUnit = { text: String(value), styles: {} };
+          }
+          this.setWithTTL(request.individualCacheKey, JSON.stringify(contentUnit));
+          logger.debug(`Cached from namespace: ${request.cleanKey}`);
+          return contentUnit;
+        }
+      } catch (error) {
+        logger.debug(
+          `Invalid JSON in namespace cache: ${namespaceCacheKey}`,
+          error
+        );
+        this.repository.remove(namespaceCacheKey);
+        this.ttlMap.delete(namespaceCacheKey);
+      }
+      return null;
+    }
+    /**
+     * Helper to create consistent TranslationResult objects
+     * Now includes styles from ContentUnit
+     */
+    createResult(contentUnit, source, status, startTime, cached) {
+      return {
+        value: contentUnit.text,
+        styles: contentUnit.styles,
+        source,
+        status,
+        duration: Date.now() - startTime,
+        ...cached !== void 0 && { cached }
+      };
+    }
+    /**
+     * Check TTL and expire if needed
+     * Returns true if expired, false if still valid
+     */
+    checkAndExpireTTL(cacheKey) {
+      const timestamp = this.ttlMap.get(cacheKey);
+      if (timestamp && Date.now() - timestamp > this.ttl) {
+        this.repository.remove(cacheKey);
+        this.ttlMap.delete(cacheKey);
+        logger.debug(`TTL expired: ${cacheKey}`);
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Set value in repository and update TTL
+     */
+    setWithTTL(cacheKey, value) {
+      this.repository.set(cacheKey, value);
+      this.ttlMap.set(cacheKey, Date.now());
+    }
+    /**
+     * Refresh TTL on access
+     */
+    refreshTTL(cacheKey) {
+      this.ttlMap.set(cacheKey, Date.now());
+    }
+    /**
+     * Get TTL information for debugging
+     */
+    getTTLInfo() {
+      const ttlInfo = {};
+      const now = Date.now();
+      for (const [key, timestamp] of this.ttlMap.entries()) {
+        const age = now - timestamp;
+        const remaining = Math.max(0, this.ttl - age);
+        ttlInfo[key] = { timestamp, age, remaining };
+      }
+      return ttlInfo;
+    }
+    getEntries() {
+      if (this.repository.getEntries !== void 0) {
+        return this.repository.getEntries();
+      }
+    }
+    /**
+     * Clear all entries for a specific namespace
+     * Removes namespace cache entry, individual keys, and TTL entries
+     */
+    clearNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const keyPrefix = `${locale}:${namespace}:`;
+      this.repository.remove(namespaceCacheKey);
+      this.ttlMap.delete(namespaceCacheKey);
+      const entries = this.repository.getEntries?.();
+      if (entries) {
+        for (const key of Object.keys(entries)) {
+          if (key.startsWith(keyPrefix)) {
+            this.repository.remove(key);
+            this.ttlMap.delete(key);
+          }
+        }
+      }
+      logger.debug(`Cleared namespace: ${locale}:${namespace}`);
+    }
+    destroy() {
+      this.repository.clear();
+      this.ttlMap.clear();
+    }
+    /**
+     * Direct cache set (for optimistic updates)
+     * Bypasses event emission for direct cache manipulation
+     * Stores as ContentUnit JSON (text + styles)
+     */
+    setCache(key, value, styles) {
+      const contentUnit = {
+        text: value,
+        styles: styles || {}
+      };
+      this.setWithTTL(key, JSON.stringify(contentUnit));
+      logger.debug(`Direct cache set: ${key}`);
+    }
+  };
+
+  // src/handlers/async-storage-handler.ts
+  var AsyncHandler = class {
+    constructor(eventEmitter, repository) {
+      __publicField(this, "name");
+      __publicField(this, "version", "1.0.0");
+      __publicField(this, "priority");
+      __publicField(this, "type", "storage");
+      __publicField(this, "enabled");
+      __publicField(this, "ttlMap", /* @__PURE__ */ new Map());
+      __publicField(this, "ttl");
+      __publicField(this, "repository");
+      __publicField(this, "bus");
+      this.bus = eventEmitter;
+      this.repository = repository;
+      this.name = repository.name;
+      const config = repository.getConfig();
+      this.enabled = config.enabled ?? true;
+      this.priority = config.priority ?? 0;
+      this.ttl = config.options?.ttl ?? 30 * 60 * 1e3;
+    }
+    getSourceType() {
+      return "memory";
+    }
+    /**
+     * Simple lookup implementation
+     * Returns ContentUnit with both text and styles
+     */
+    async lookup(request) {
+      const startTime = Date.now();
+      logger.debug(`Async lookup: ${request.cleanKey}`);
+      const repoBus = this.bus.repo(request, this.name);
+      const directResult = await this.tryDirectLookup(request);
+      if (directResult !== null) {
+        logger.debug(`Cache hit: ${request.cleanKey}`);
+        repoBus.getSuccess(directResult.text);
+        return this.createResult(directResult, "storage", 200, startTime, true);
+      }
+      if (request.cleanKey.includes(".") && request.namespace) {
+        const namespaceResult = await this.tryNamespaceLookup(request);
+        if (namespaceResult !== null) {
+          logger.debug(`Namespace hit: ${request.cleanKey}`);
+          repoBus.getSuccess(namespaceResult.text);
+          return this.createResult(
+            namespaceResult,
+            "storage",
+            200,
+            startTime,
+            true
+          );
+        }
+      }
+      logger.debug(`Cache miss: ${request.cleanKey}`);
+      repoBus.getMiss();
+      return this.createResult(
+        { text: request.parsedDefaultValue || request.cleanKey, styles: {} },
+        "fallback",
+        404,
+        startTime
+      );
+    }
+    /**
+     * Simple save implementation
+     * Stores ContentUnit (text + styles) as JSON
+     */
+    async save(request, result) {
+      if (!result.value) return;
+      const repoBus = this.bus.repo(request, this.name);
+      const contentUnit = {
+        text: result.value,
+        styles: result.styles || {}
+      };
+      await this.setWithTTL(request.individualCacheKey, JSON.stringify(contentUnit));
+      logger.debug(`Saved to cache: ${request.cleanKey}`);
+      repoBus.setSuccess(result.value);
+    }
+    /**
+     * Namespace saving implementation
+     */
+    async saveNamespace(translations, context) {
+      if (!context.namespace) return;
+      const repoBus = this.bus.repo(
+        context.locale + ":" + context.namespace,
+        this.name
+      );
+      const keyCount = Object.keys(translations).length;
+      logger.debug(
+        `Saving namespace: ${context.locale}:${context.namespace} (${keyCount} keys)`
+      );
+      const namespaceCacheKey = createNamespaceCacheKey(
+        context.locale,
+        context.namespace
+      );
+      await this.setWithTTL(namespaceCacheKey, JSON.stringify(translations));
+      const flattened = flattenTranslations(
+        translations,
+        "",
+        context.locale,
+        context.namespace
+      );
+      let savedCount = 0;
+      for (const [flatKey, flatValue] of Object.entries(flattened)) {
+        await this.setWithTTL(flatKey, flatValue);
+        savedCount++;
+      }
+      logger.debug(`Saved: ${savedCount} keys + namespace blob`);
+      repoBus.setSuccess(JSON.stringify(translations));
+    }
+    /**
+     * ✅ Strategy 1: Direct cache lookup using unified pattern
+     * Returns parsed ContentUnit (text + styles) or null
+     */
+    async tryDirectLookup(request) {
+      if (await this.checkAndExpireTTL(request.individualCacheKey)) {
+        return null;
+      }
+      const cachedValue = await this.repository.get(request.individualCacheKey);
+      if (!cachedValue) return null;
+      this.refreshTTL(request.individualCacheKey);
+      try {
+        const parsed = JSON.parse(cachedValue);
+        if (typeof parsed === "object" && "text" in parsed) {
+          return {
+            text: String(parsed.text),
+            styles: parsed.styles || {}
+          };
+        }
+        return { text: cachedValue, styles: {} };
+      } catch {
+        return { text: cachedValue, styles: {} };
+      }
+    }
+    /**
+     * ✅ Strategy 2: Namespace lookup using unified pattern
+     * Returns parsed ContentUnit (text + styles) or null
+     */
+    async tryNamespaceLookup(request) {
+      if (!request.namespace) return null;
+      const namespaceCacheKey = createNamespaceCacheKey(
+        request.locale,
+        request.namespace
+      );
+      if (await this.checkAndExpireTTL(namespaceCacheKey)) {
+        return null;
+      }
+      const namespaceData = await this.repository.get(namespaceCacheKey);
+      if (!namespaceData) return null;
+      this.refreshTTL(namespaceCacheKey);
+      try {
+        const translations = JSON.parse(namespaceData);
+        const value = resolveNestedKey(translations, request.cleanKey);
+        if (value !== null && value !== void 0) {
+          let contentUnit;
+          if (typeof value === "object" && value !== null && "text" in value) {
+            contentUnit = {
+              text: String(value.text),
+              styles: value.styles || {}
+            };
+          } else {
+            contentUnit = { text: String(value), styles: {} };
+          }
+          await this.setWithTTL(request.individualCacheKey, JSON.stringify(contentUnit));
+          logger.debug(`Cached from namespace: ${request.cleanKey}`);
+          return contentUnit;
+        }
+      } catch (error) {
+        logger.debug(
+          `Invalid JSON in namespace cache: ${namespaceCacheKey}`,
+          error
+        );
+        await this.repository.remove(namespaceCacheKey);
+        this.ttlMap.delete(namespaceCacheKey);
+      }
+      return null;
+    }
+    /**
+     * Helper to create consistent TranslationResult objects
+     * Now includes styles from ContentUnit
+     */
+    createResult(contentUnit, source, status, startTime, cached) {
+      return {
+        value: contentUnit.text,
+        styles: contentUnit.styles,
+        source,
+        status,
+        duration: Date.now() - startTime,
+        ...cached !== void 0 && { cached }
+      };
+    }
+    /**
+     * Check TTL and expire if needed (async version)
+     * Returns true if expired, false if still valid
+     */
+    async checkAndExpireTTL(cacheKey) {
+      const timestamp = this.ttlMap.get(cacheKey);
+      if (timestamp && Date.now() - timestamp > this.ttl) {
+        await this.repository.remove(cacheKey);
+        this.ttlMap.delete(cacheKey);
+        logger.debug(`TTL expired: ${cacheKey}`);
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Set value in repository and update TTL (async version)
+     */
+    async setWithTTL(cacheKey, value) {
+      await this.repository.set(cacheKey, value);
+      this.ttlMap.set(cacheKey, Date.now());
+    }
+    /**
+     * Refresh TTL on access
+     */
+    refreshTTL(cacheKey) {
+      this.ttlMap.set(cacheKey, Date.now());
+    }
+    /**
+     * Get TTL information for debugging
+     */
+    getTTLInfo() {
+      const ttlInfo = {};
+      const now = Date.now();
+      for (const [key, timestamp] of this.ttlMap.entries()) {
+        const age = now - timestamp;
+        const remaining = Math.max(0, this.ttl - age);
+        ttlInfo[key] = { timestamp, age, remaining };
+      }
+      return ttlInfo;
+    }
+    async destroy() {
+      await this.repository.clear();
+      this.ttlMap.clear();
+    }
+    getEntries() {
+      if (this.repository.getEntries !== void 0) {
+        return this.repository.getEntries();
+      }
+    }
+  };
+
+  // src/errors/translation-errors.ts
+  var TranslationError = class extends Error {
+    constructor(key, status, message) {
+      super(message);
+      this.key = key;
+      this.status = status;
+      this.name = this.constructor.name;
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      }
+    }
+  };
+  var TranslationNotFoundError = class extends TranslationError {
+    constructor(key) {
+      super(key, 404, `Translation not found: ${key}`);
+    }
+  };
+  var TranslationLockedError = class extends TranslationError {
+    constructor(key, retryAfter) {
+      super(key, 423, `Translation locked: ${key}`);
+      this.retryAfter = retryAfter;
+    }
+  };
+  var ServerError = class extends TranslationError {
+    constructor(key, status) {
+      super(key, status, `Server error ${status}: ${key}`);
+    }
+  };
+  var NetworkError = class extends Error {
+    constructor(message, cause) {
+      super(message);
+      this.cause = cause;
+      this.name = "NetworkError";
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      }
+    }
+  };
+  function isTranslationError(error) {
+    return error instanceof TranslationError;
+  }
+  function isRetryableError(error) {
+    return error instanceof ServerError || error instanceof NetworkError;
+  }
+  function isClientError(error) {
+    return error instanceof TranslationNotFoundError || error instanceof TranslationLockedError;
+  }
+
+  // src/handlers/network-handler.ts
+  var NetworkHandler = class {
+    constructor(eventEmitter, repository) {
+      __publicField(this, "repository");
+      __publicField(this, "name");
+      __publicField(this, "priority");
+      __publicField(this, "version", "1.0.0");
+      __publicField(this, "type", "network");
+      __publicField(this, "enabled");
+      __publicField(this, "bus");
+      __publicField(this, "retryCount");
+      __publicField(this, "retryDelay");
+      this.bus = eventEmitter;
+      this.repository = repository;
+      this.name = repository.name;
+      const config = repository.getConfig();
+      this.enabled = config.enabled ?? false;
+      this.priority = config.priority ?? 0;
+      this.retryCount = config.options?.retries ?? 3;
+      this.retryDelay = config.options?.retryDelay ?? 1e3;
+    }
+    initialize() {
+      return Promise.resolve();
+    }
+    getSourceType() {
+      return "network";
+    }
+    /**
+     * ✅ Lookup translation with full error handling
+     * Strategy: Key first, namespace as fallback
+     * Returns TranslationResult with status, source, duration, styles, and optional error
+     */
+    async lookup(request) {
+      const startTime = Date.now();
+      const fallbackValue = request.parsedDefaultValue || request.cleanKey;
+      if (!this.enabled) {
+        return this.createTranslationResult(
+          fallbackValue,
+          "fallback",
+          0,
+          startTime
+        );
+      }
+      const networkBus = this.bus.network(request, this.name);
+      networkBus.start();
+      logger.debug(`Network lookup: ${request.cleanKey}`);
+      try {
+        const contentUnit = await this.lookupContentUnitWithRetry(
+          request.individualCacheKey
+        );
+        logger.debug(`Network hit: ${request.cleanKey}`);
+        networkBus.success(contentUnit.text);
+        return this.createTranslationResult(
+          contentUnit.text,
+          "network",
+          200,
+          startTime,
+          void 0,
+          false,
+          void 0,
+          contentUnit.styles
+        );
+      } catch (error) {
+        if (error instanceof TranslationNotFoundError && request.namespace) {
+          logger.debug(
+            `Individual key not found, trying namespace: ${request.cleanKey}`
+          );
+          return this.lookupFromNamespace(request, fallbackValue, startTime, networkBus);
+        }
+        if (error instanceof TranslationLockedError) {
+          logger.debug(`Translation locked (423): ${request.cleanKey}`);
+          return this.handleTranslationLocked(
+            request,
+            fallbackValue,
+            error,
+            startTime,
+            networkBus
+          );
+        }
+        logger.debug(`Network error: ${request.cleanKey}`, error);
+        networkBus.error(error);
+        return this.createTranslationResult(
+          fallbackValue,
+          "fallback",
+          0,
+          startTime,
+          error
+        );
+      }
+    }
+    /**
+     * Strategy 2: Namespace fallback when individual key not found
+     */
+    async lookupFromNamespace(request, fallbackValue, startTime, networkBus) {
+      try {
+        const namespaceResult = await this.loadNamespace(
+          request.locale,
+          request.namespace
+        );
+        if (namespaceResult && namespaceResult.data) {
+          const nestedValue = resolveNestedKey(
+            namespaceResult.data,
+            request.cleanKey
+          );
+          if (nestedValue !== void 0 && nestedValue !== null) {
+            let resolvedValue;
+            let styles = {};
+            if (typeof nestedValue === "object" && nestedValue !== null && "text" in nestedValue) {
+              const contentUnit = nestedValue;
+              resolvedValue = String(contentUnit.text);
+              styles = contentUnit.styles || {};
+            } else {
+              resolvedValue = String(nestedValue);
+            }
+            logger.debug(`Network namespace hit: ${request.cleanKey}, hasStyles=${Object.keys(styles).length > 0}`);
+            networkBus.success(resolvedValue);
+            return this.createTranslationResult(
+              resolvedValue,
+              "network",
+              200,
+              startTime,
+              void 0,
+              false,
+              {
+                locale: request.locale,
+                namespace: request.namespace,
+                data: namespaceResult.data
+              },
+              styles
+            );
+          }
+        }
+        const error = new TranslationNotFoundError(request.cleanKey);
+        return this.handleTranslationNotFound(
+          request,
+          fallbackValue,
+          error,
+          startTime
+        );
+      } catch (nsError) {
+        logger.debug(`Namespace load failed: ${request.cleanKey}`, nsError);
+        if (nsError instanceof TranslationNotFoundError) {
+          return this.handleTranslationNotFound(
+            request,
+            fallbackValue,
+            nsError,
+            startTime
+          );
+        }
+        if (nsError instanceof TranslationLockedError) {
+          return this.handleTranslationLocked(
+            request,
+            fallbackValue,
+            nsError,
+            startTime,
+            networkBus
+          );
+        }
+        networkBus.error(nsError);
+        return this.createTranslationResult(
+          fallbackValue,
+          "fallback",
+          0,
+          startTime,
+          nsError
+        );
+      }
+    }
+    /**
+     * ✅ Load entire namespace (used for preloading)
+     * Returns NamespaceResult with status and error information
+     */
+    async loadNamespace(locale, namespace) {
+      const startTime = Date.now();
+      if (!this.enabled) {
+        return this.createNamespaceResult(null, "fallback", 0, startTime);
+      }
+      try {
+        const data = await this.loadNamespaceWithRetry(locale, namespace);
+        if (data === null) {
+          logger.debug(`Network namespace not modified: ${locale}:${namespace}`);
+          return this.createNamespaceResult(null, "network", 304, startTime);
+        }
+        logger.debug(`Network namespace loaded: ${locale}:${namespace}`);
+        return this.createNamespaceResult(data, "network", 200, startTime);
+      } catch (error) {
+        if (error instanceof TranslationLockedError) {
+          logger.debug(`Namespace locked (423): ${locale}:${namespace}`);
+          return this.createNamespaceResult(
+            null,
+            "fallback",
+            423,
+            startTime,
+            error
+          );
+        }
+        if (error instanceof TranslationNotFoundError) {
+          logger.debug(`Network namespace not found: ${locale}:${namespace}`);
+          return this.createNamespaceResult(
+            null,
+            "fallback",
+            404,
+            startTime,
+            error
+          );
+        }
+        logger.debug(`Network namespace error: ${locale}:${namespace}`, error);
+        return this.createNamespaceResult(
+          null,
+          "fallback",
+          0,
+          startTime,
+          error
+        );
+      }
+    }
+    /**
+     * ✅ Namespace lookup with retry logic
+     * Throws custom errors (TranslationNotFoundError, TranslationLockedError, etc.)
+     */
+    async loadNamespaceWithRetry(locale, namespace) {
+      return this.withRetry(
+        () => this.repository.getNamespace(locale, namespace),
+        `${locale}:${namespace}`,
+        "namespace request"
+      );
+    }
+    /**
+     * Simple save implementation (API usually doesn't save)
+     */
+    async save(request, result) {
+      void request;
+      void result;
+    }
+    /**
+     * ✅ Lookup with retry logic for individual keys
+     * Throws custom errors (TranslationNotFoundError, TranslationLockedError, etc.)
+     */
+    async lookupWithRetry(cacheKey) {
+      return this.withRetry(
+        () => this.repository.get(cacheKey),
+        cacheKey,
+        "network request"
+      );
+    }
+    /**
+     * ✅ Lookup ContentUnit with retry logic for individual keys
+     * Returns full ContentUnit with text and styles
+     * Throws custom errors (TranslationNotFoundError, TranslationLockedError, etc.)
+     */
+    async lookupContentUnitWithRetry(cacheKey) {
+      const repo = this.repository;
+      if (typeof repo.getContentUnit !== "function") {
+        const text = await this.lookupWithRetry(cacheKey);
+        return { text, styles: {} };
+      }
+      return this.withRetry(
+        () => repo.getContentUnit(cacheKey),
+        cacheKey,
+        "network content unit request"
+      );
+    }
+    /**
+     * Delay utility for retries
+     */
+    delay(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    calculateBackoff(attempt) {
+      const baseDelay = this.retryDelay;
+      const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+      const maxDelay = 1e4;
+      const jitter = Math.random() * 0.1 * exponentialDelay;
+      return Math.min(exponentialDelay + jitter, maxDelay);
+    }
+    /**
+     * Generic retry wrapper for repository operations
+     * Handles retryable errors with exponential backoff
+     */
+    async withRetry(operation, contextKey, contextDescription, attempt = 1) {
+      const networkBus = this.bus.network(contextKey, "withRetry");
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt <= this.retryCount && isRetryableError(error)) {
+          const delay = this.calculateBackoff(attempt);
+          networkBus.retry(attempt, delay, error.message);
+          await this.delay(delay);
+          logger.debug(
+            `Retrying ${contextDescription} (${attempt}/${this.retryCount}) after ${delay}ms`
+          );
+          return this.withRetry(
+            operation,
+            contextKey,
+            contextDescription,
+            attempt + 1
+          );
+        }
+        throw error;
+      }
+    }
+    /**
+     * Handle translation not found (after namespace fallback also failed)
+     */
+    handleTranslationNotFound(request, fallbackValue, error, startTime) {
+      logger.debug(`Network namespace miss: ${request.cleanKey}`);
+      const translateBus = this.bus.translation(request);
+      translateBus.notFound(
+        fallbackValue,
+        request.locale,
+        request.namespace || "default"
+      );
+      return this.createTranslationResult(
+        fallbackValue,
+        "fallback",
+        404,
+        startTime,
+        error
+      );
+    }
+    /**
+     * Handle TranslationLockedError for translation lookups
+     */
+    handleTranslationLocked(request, fallbackValue, error, startTime, networkBus) {
+      const translateBus = this.bus.translation(request);
+      translateBus.locked(
+        fallbackValue,
+        request.locale,
+        request.namespace || "default"
+      );
+      networkBus.error(error, 423);
+      return this.createTranslationResult(
+        fallbackValue,
+        "fallback",
+        423,
+        startTime,
+        error
+      );
+    }
+    /**
+     * Helper to create consistent TranslationResult objects
+     */
+    createTranslationResult(value, source, status, startTime, error, cached, namespaceLoaded, styles) {
+      return {
+        value,
+        source,
+        status,
+        duration: Date.now() - startTime,
+        ...error && { error },
+        ...cached !== void 0 && { cached },
+        ...namespaceLoaded && { namespaceLoaded },
+        ...styles && Object.keys(styles).length > 0 && { styles }
+      };
+    }
+    /**
+     * Helper to create consistent NamespaceResult objects
+     */
+    createNamespaceResult(data, source, status, startTime, error) {
+      return {
+        data,
+        source,
+        status,
+        duration: Date.now() - startTime,
+        ...error && { error }
+      };
+    }
+    getPreload() {
+      const config = this.repository.getConfig();
+      return config.options?.preloadNamespaces || [];
+    }
+  };
+
+  // src/content/style-mapper/DefaultStyleMapper.ts
+  var DefaultStyleMapper = class {
+    constructor() {
+      /**
+       * Element → Style mapping
+       * Maps HTML element names to their style property
+       */
+      __publicField(this, "elementToStyles", {
+        b: "bold",
+        strong: "bold",
+        i: "italic",
+        em: "italic",
+        u: "underline",
+        s: "strikethrough",
+        del: "strikethrough",
+        strike: "strikethrough",
+        code: "code",
+        mark: "highlight",
+        sub: "subscript",
+        sup: "superscript"
+      });
+      /**
+       * Style → Element mapping (reverse)
+       * Uses simple, familiar elements for developer convenience
+       * Also accepts element names directly (strong, em, etc.)
+       */
+      __publicField(this, "styleToElement", {
+        // Semantic style names → simple elements
+        bold: "b",
+        italic: "i",
+        underline: "u",
+        strikethrough: "s",
+        code: "code",
+        highlight: "mark",
+        subscript: "sub",
+        superscript: "sup",
+        // Element names (for servers that store styles as element names)
+        strong: "b",
+        b: "b",
+        em: "i",
+        i: "i",
+        u: "u",
+        s: "s",
+        del: "s",
+        strike: "s",
+        mark: "mark",
+        sub: "sub",
+        sup: "sup"
+      });
+    }
+    /**
+     * Convert HTML element to style properties
+     *
+     * @param element - Tag name (e.g., "b", "a", "strong")
+     * @param attrs - Element attributes (e.g., { href: "/url" })
+     * @returns Array of style strings
+     */
+    mapElementToStyles(element, attrs) {
+      const styles = [];
+      const tag = element.toLowerCase();
+      const mappedStyle = this.elementToStyles[tag];
+      if (mappedStyle) {
+        styles.push(mappedStyle);
+      }
+      if (tag === "a" && attrs.href) {
+        styles.push(`hyperlink:${attrs.href}`);
+      }
+      return styles;
+    }
+    /**
+     * Convert style properties to HTML element
+     *
+     * Priority order:
+     * 1. Hyperlink (becomes wrapper element with href)
+     * 2. First recognized style property
+     * 3. Fallback to span
+     *
+     * @param styles - Array of style strings
+     * @returns Element info for serialization
+     */
+    mapStylesToElement(styles) {
+      for (const style of styles) {
+        if (style.startsWith("hyperlink:")) {
+          return {
+            element: "a",
+            attrs: { href: style.slice("hyperlink:".length) }
+          };
+        }
+      }
+      for (const style of styles) {
+        const element = this.styleToElement[style];
+        if (element) {
+          return {
+            element,
+            attrs: {}
+          };
+        }
+      }
+      return { element: "span", attrs: {} };
+    }
+  };
+
+  // src/content/parser/MarkupParser.ts
+  var MarkupParser = class {
+    constructor(options = {}) {
+      __publicField(this, "styleMapper");
+      this.styleMapper = options.styleMapper ?? new DefaultStyleMapper();
+    }
+    /**
+     * Parse HTML string into ContentUnit
+     *
+     * Handles two input formats:
+     * 1. HTML tags: `<b>text</b>` → converts to indexed `<1>text</1>` with styles
+     * 2. Already indexed: `<1>text</1>` → passes through as-is (from server)
+     *
+     * @param input - HTML string with inline elements or already indexed
+     * @returns ContentUnit with indexed tags and styles
+     */
+    parse(input) {
+      const hasIndexedTags = /<\/?[0-9]+>/.test(input);
+      if (hasIndexedTags) {
+        return {
+          text: input,
+          styles: {}
+          // Empty - styles determined by children
+        };
+      }
+      const styles = {};
+      let tagIndex = 0;
+      const tagStack = [];
+      let result = "";
+      let pos = 0;
+      while (pos < input.length) {
+        const tagMatch = this.matchTag(input, pos);
+        if (!tagMatch) {
+          result += input.slice(pos);
+          break;
+        }
+        result += input.slice(pos, tagMatch.startIndex);
+        if (tagMatch.isClosing) {
+          const matchingOpen = this.findMatchingOpenTag(
+            tagStack,
+            tagMatch.tag.toLowerCase()
+          );
+          if (matchingOpen !== null) {
+            result += `</${matchingOpen}>`;
+            const stackIndex = tagStack.findIndex(
+              (t) => t.index === matchingOpen
+            );
+            if (stackIndex !== -1) {
+              tagStack.splice(stackIndex, 1);
+            }
+          } else {
+            result += input.slice(tagMatch.startIndex, tagMatch.endIndex);
+          }
+        } else if (tagMatch.isSelfClosing) {
+          tagIndex++;
+          const styleList = this.styleMapper.mapElementToStyles(
+            tagMatch.tag,
+            tagMatch.attrs
+          );
+          if (styleList.length > 0) {
+            styles[String(tagIndex)] = styleList;
+            result += `<${tagIndex}/>`;
+          }
+        } else {
+          const styleList = this.styleMapper.mapElementToStyles(
+            tagMatch.tag,
+            tagMatch.attrs
+          );
+          if (styleList.length > 0) {
+            tagIndex++;
+            styles[String(tagIndex)] = styleList;
+            result += `<${tagIndex}>`;
+            tagStack.push({ tag: tagMatch.tag.toLowerCase(), index: tagIndex });
+          } else {
+            const closingIndex = this.findClosingTagIndex(
+              input,
+              tagMatch.endIndex,
+              tagMatch.tag
+            );
+            if (closingIndex !== -1) {
+              const innerContent = input.slice(tagMatch.endIndex, closingIndex);
+              const innerUnit = this.parse(innerContent);
+              const baseIndex = tagIndex;
+              for (const [key, value] of Object.entries(innerUnit.styles)) {
+                const adjustedKey = String(baseIndex + parseInt(key, 10));
+                styles[adjustedKey] = value;
+              }
+              result += innerUnit.text.replace(/<(\/?)\d+>/g, (match, slash) => {
+                const num = parseInt(match.replace(/[</>]/g, ""), 10);
+                return `<${slash}${baseIndex + num}>`;
+              });
+              const closingMatch = this.matchTag(input, closingIndex);
+              pos = closingMatch ? closingMatch.endIndex : closingIndex;
+              const maxInnerIndex = Object.keys(innerUnit.styles).length > 0 ? Math.max(...Object.keys(innerUnit.styles).map(Number)) : 0;
+              tagIndex = baseIndex + maxInnerIndex;
+              continue;
+            }
+          }
+        }
+        pos = tagMatch.endIndex;
+      }
+      while (tagStack.length > 0) {
+        const unclosed = tagStack.pop();
+        result += `</${unclosed.index}>`;
+      }
+      return {
+        text: result,
+        styles
+      };
+    }
+    /**
+     * Match an HTML tag at the given position
+     */
+    matchTag(input, startPos) {
+      const tagStart = input.indexOf("<", startPos);
+      if (tagStart === -1) return null;
+      const tagPattern = /^<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:\s+[a-zA-Z][a-zA-Z0-9-]*(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*)\s*(\/?)>/;
+      const remaining = input.slice(tagStart);
+      const match = remaining.match(tagPattern);
+      if (!match) {
+        if (tagStart + 1 < input.length) {
+          return this.matchTag(input, tagStart + 1);
+        }
+        return null;
+      }
+      const [fullMatch, closingSlash, tagName, attrsString, selfClosingSlash] = match;
+      return {
+        tag: tagName,
+        attrs: this.parseAttributes(attrsString),
+        isClosing: closingSlash === "/",
+        isSelfClosing: selfClosingSlash === "/",
+        startIndex: tagStart,
+        endIndex: tagStart + fullMatch.length
+      };
+    }
+    /**
+     * Parse HTML attributes string into key-value pairs
+     */
+    parseAttributes(attrsString) {
+      const attrs = {};
+      if (!attrsString.trim()) return attrs;
+      const attrPattern = /([a-zA-Z][a-zA-Z0-9-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]*)))?/g;
+      let match;
+      while ((match = attrPattern.exec(attrsString)) !== null) {
+        const [, name, doubleQuoted, singleQuoted, unquoted] = match;
+        const value = doubleQuoted ?? singleQuoted ?? unquoted ?? "";
+        attrs[name.toLowerCase()] = value;
+      }
+      return attrs;
+    }
+    /**
+     * Find matching opening tag in the stack
+     */
+    findMatchingOpenTag(stack, tagName) {
+      for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].tag === tagName) {
+          return stack[i].index;
+        }
+      }
+      return null;
+    }
+    /**
+     * Find the closing tag index for a given opening tag
+     */
+    findClosingTagIndex(input, startPos, tagName) {
+      const lowerTag = tagName.toLowerCase();
+      let depth = 1;
+      let pos = startPos;
+      while (pos < input.length && depth > 0) {
+        const tagMatch = this.matchTag(input, pos);
+        if (!tagMatch) break;
+        if (tagMatch.tag.toLowerCase() === lowerTag) {
+          if (tagMatch.isClosing) {
+            depth--;
+            if (depth === 0) {
+              return tagMatch.startIndex;
+            }
+          } else if (!tagMatch.isSelfClosing) {
+            depth++;
+          }
+        }
+        pos = tagMatch.endIndex;
+      }
+      return -1;
+    }
+  };
+
+  // src/content/serializer/HTMLSerializer.ts
+  var HTMLSerializer = class {
+    constructor(options = {}) {
+      __publicField(this, "styleMapper");
+      this.styleMapper = options.styleMapper ?? new DefaultStyleMapper();
+    }
+    /**
+     * Serialize ContentUnit to HTML string
+     *
+     * @param unit - ContentUnit with indexed tags and styles
+     * @returns HTML string with semantic elements
+     */
+    serialize(unit) {
+      const { text, styles } = unit;
+      const tagPattern = /<(\/?)?(\d+)(\/)?>/g;
+      let result = "";
+      let lastIndex = 0;
+      let match;
+      while ((match = tagPattern.exec(text)) !== null) {
+        result += text.slice(lastIndex, match.index);
+        const [fullMatch, closingSlash, indexStr, selfClosingSlash] = match;
+        const tagIndex = indexStr;
+        const styleList = styles[tagIndex] || [];
+        if (closingSlash) {
+          const mapping = this.styleMapper.mapStylesToElement(styleList);
+          result += `</${mapping.element}>`;
+        } else if (selfClosingSlash) {
+          const mapping = this.styleMapper.mapStylesToElement(styleList);
+          const attrs = this.formatAttributes(mapping.attrs);
+          result += `<${mapping.element}${attrs} />`;
+        } else {
+          const mapping = this.styleMapper.mapStylesToElement(styleList);
+          const attrs = this.formatAttributes(mapping.attrs);
+          result += `<${mapping.element}${attrs}>`;
+        }
+        lastIndex = match.index + fullMatch.length;
+      }
+      result += text.slice(lastIndex);
+      return result;
+    }
+    /**
+     * Format attributes object into HTML attribute string
+     */
+    formatAttributes(attrs) {
+      const entries = Object.entries(attrs);
+      if (entries.length === 0) return "";
+      return " " + entries.map(([key, value]) => `${key}="${this.escapeAttributeValue(value)}"`).join(" ");
+    }
+    /**
+     * Escape special characters in attribute values
+     */
+    escapeAttributeValue(value) {
+      return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    }
+  };
+
+  // src/cache/CacheManager.ts
+  var CacheManager = class {
+    constructor(handlerChain, bus, getCurrentLocale, loadNamespaces) {
+      __publicField(this, "handlerChain");
+      __publicField(this, "bus");
+      __publicField(this, "currentLocale");
+      __publicField(this, "loadNamespaces");
+      this.handlerChain = handlerChain;
+      this.bus = bus;
+      this.currentLocale = getCurrentLocale;
+      this.loadNamespaces = loadNamespaces;
+    }
+    /**
+     * Get a cached translation entry
+     *
+     * @param key - Full cache key (e.g., 'en:app:welcome')
+     * @returns Cache entry with value and styles, or null if not found
+     */
+    get(key) {
+      const entries = this.handlerChain.getEntries();
+      for (const handlerName in entries) {
+        const handlerEntries = entries[handlerName];
+        if (handlerEntries && typeof handlerEntries === "object") {
+          if (key in handlerEntries) {
+            const rawValue = handlerEntries[key];
+            try {
+              if (typeof rawValue === "string") {
+                const parsed = JSON.parse(rawValue);
+                if (typeof parsed === "object" && "text" in parsed) {
+                  return {
+                    value: String(parsed.text),
+                    styles: parsed.styles || void 0
+                  };
+                }
+                return { value: rawValue, styles: void 0 };
+              }
+              return {
+                value: JSON.stringify(rawValue),
+                styles: void 0
+              };
+            } catch {
+              return {
+                value: typeof rawValue === "string" ? rawValue : JSON.stringify(rawValue),
+                styles: void 0
+              };
+            }
+          }
+        }
+      }
+      return null;
+    }
+    /**
+     * Set a cache entry (for optimistic updates)
+     *
+     * @param key - Full cache key (e.g., 'en:app:welcome')
+     * @param value - Translation value
+     * @param styles - Optional styles for indexed tags
+     */
+    set(key, value, styles) {
+      const [locale, namespace, ...keyParts] = key.split(":");
+      const translationKey = keyParts.join(":");
+      if (!locale || !namespace || !translationKey) {
+        throw new Error(
+          `Invalid cache key format: "${key}". Expected format: "locale:namespace:key"`
+        );
+      }
+      this.handlerChain.setCache(key, value, styles);
+      this.bus.emit("cache:set", {
+        payload: {
+          key,
+          value,
+          styles,
+          optimistic: true
+        }
+      });
+    }
+    /**
+     * Check if a key exists in cache
+     *
+     * @param key - Full cache key (e.g., 'en:app:welcome')
+     * @returns true if key is cached
+     */
+    has(key) {
+      return this.get(key) !== null;
+    }
+    /**
+     * Invalidate cache entries and optionally refetch
+     *
+     * Like TanStack Query's invalidateQueries, this clears matching cache entries
+     * and triggers background refetch by default.
+     *
+     * @param options - Filter options for invalidation
+     *
+     * @example
+     * ```typescript
+     * // Invalidate all
+     * await cache.invalidate();
+     *
+     * // Invalidate by namespace
+     * await cache.invalidate({ namespace: 'app' });
+     *
+     * // Invalidate by locale
+     * await cache.invalidate({ locale: 'es' });
+     *
+     * // Invalidate specific key
+     * await cache.invalidate({ key: 'en:app:welcome' });
+     *
+     * // Invalidate with predicate
+     * await cache.invalidate({ predicate: (k) => k.includes('common:') });
+     *
+     * // Invalidate without refetch
+     * await cache.invalidate({ namespace: 'app', refetch: false });
+     * ```
+     */
+    async invalidate(options = {}) {
+      const { namespace, locale, key, predicate, refetch = true } = options;
+      const currentLocale = this.currentLocale();
+      let keysCleared = 0;
+      if (key) {
+        const [keyLocale, keyNamespace] = key.split(":");
+        if (keyLocale && keyNamespace) {
+          this.handlerChain.clearNamespace(keyLocale, keyNamespace);
+          keysCleared = 1;
+        }
+      } else if (namespace && locale) {
+        this.handlerChain.clearNamespace(locale, namespace);
+        keysCleared = this.countClearedKeys(locale, namespace);
+      } else if (namespace) {
+        this.handlerChain.clearNamespace(currentLocale, namespace);
+        keysCleared = this.countClearedKeys(currentLocale, namespace);
+      } else if (locale) {
+        const entries = this.handlerChain.getEntries();
+        const namespacesToClear = /* @__PURE__ */ new Set();
+        for (const handlerName in entries) {
+          const handlerEntries = entries[handlerName];
+          if (handlerEntries && typeof handlerEntries === "object") {
+            for (const entryKey of Object.keys(handlerEntries)) {
+              if (entryKey.startsWith(`${locale}:`) || entryKey.startsWith(`@${locale}:`)) {
+                const parts = entryKey.replace("@", "").split(":");
+                if (parts[1]) {
+                  namespacesToClear.add(parts[1]);
+                }
+              }
+            }
+          }
+        }
+        for (const ns of namespacesToClear) {
+          this.handlerChain.clearNamespace(locale, ns);
+          keysCleared++;
+        }
+      } else if (predicate) {
+        const entries = this.handlerChain.getEntries();
+        const toClear = /* @__PURE__ */ new Map();
+        for (const handlerName in entries) {
+          const handlerEntries = entries[handlerName];
+          if (handlerEntries && typeof handlerEntries === "object") {
+            for (const entryKey of Object.keys(handlerEntries)) {
+              if (predicate(entryKey)) {
+                const parts = entryKey.replace("@", "").split(":");
+                const entryLocale = parts[0];
+                const entryNs = parts[1];
+                if (entryLocale && entryNs) {
+                  if (!toClear.has(entryLocale)) {
+                    toClear.set(entryLocale, /* @__PURE__ */ new Set());
+                  }
+                  toClear.get(entryLocale).add(entryNs);
+                  keysCleared++;
+                }
+              }
+            }
+          }
+        }
+        for (const [loc, namespaces] of toClear) {
+          for (const ns of namespaces) {
+            this.handlerChain.clearNamespace(loc, ns);
+          }
+        }
+      } else {
+        this.handlerChain.clearCache();
+        keysCleared = -1;
+      }
+      this.bus.emit("cache:invalidate", {
+        payload: {
+          filter: options,
+          keysCleared,
+          refetch
+        }
+      });
+      if (refetch) {
+        await this.refetchAfterInvalidate(options);
+      }
+    }
+    /**
+     * Count keys that would be cleared (for event reporting)
+     */
+    countClearedKeys(locale, namespace) {
+      const entries = this.handlerChain.getEntries();
+      let count = 0;
+      const prefix = `${locale}:${namespace}:`;
+      const namespaceKey = `@${locale}:${namespace}`;
+      for (const handlerName in entries) {
+        const handlerEntries = entries[handlerName];
+        if (handlerEntries && typeof handlerEntries === "object") {
+          for (const key of Object.keys(handlerEntries)) {
+            if (key.startsWith(prefix) || key === namespaceKey) {
+              count++;
+            }
+          }
+        }
+      }
+      return count;
+    }
+    /**
+     * Refetch data after invalidation
+     */
+    async refetchAfterInvalidate(options) {
+      const { namespace, locale, key } = options;
+      const currentLocale = this.currentLocale();
+      if (key) {
+        const [keyLocale, keyNamespace] = key.split(":");
+        if (keyLocale && keyNamespace) {
+          await this.loadNamespaces(keyLocale, [keyNamespace]);
+        }
+      } else if (namespace) {
+        await this.loadNamespaces(locale || currentLocale, [namespace]);
+      } else if (locale) {
+      }
+    }
+  };
+
+  // src/lionRapid.ts
+  var INDEXED_TAG_REGEX = /<\/?[0-9]+>/;
+  var HTML_TAG_REGEX = /<[a-z][a-z0-9]*(?:\s+[^>]*)?\/?>/i;
+  var LionRapidCore = class {
+    constructor(eventEmitter, handlerChain, defaultLocale = "en", fallbackLocale = "en", defaultNamespace) {
+      __publicField(this, "handlerChain");
+      __publicField(this, "currentLocale");
+      __publicField(this, "fallbackLocale");
+      __publicField(this, "defaultNamespace");
+      __publicField(this, "pendingTranslations", /* @__PURE__ */ new Map());
+      __publicField(this, "bus");
+      __publicField(this, "plugins", /* @__PURE__ */ new Map());
+      // 🔥 EMBEDDED: Core integration maps
+      __publicField(this, "formatters", /* @__PURE__ */ new Map());
+      __publicField(this, "processors", /* @__PURE__ */ new Map());
+      // 📡 EVENT-DRIVEN: Just track for cleanup
+      __publicField(this, "eventPlugins", /* @__PURE__ */ new Set());
+      // 📦 CONTENT: Parser and serializer for ContentUnit processing
+      __publicField(this, "markupParser", new MarkupParser());
+      __publicField(this, "htmlSerializer", new HTMLSerializer());
+      // 🔄 CACHE: TanStack Query-inspired cache management
+      __publicField(this, "cache");
+      this.bus = eventEmitter;
+      this.handlerChain = handlerChain;
+      this.currentLocale = defaultLocale;
+      this.fallbackLocale = fallbackLocale;
+      this.defaultNamespace = defaultNamespace;
+      this.cache = new CacheManager(
+        this.handlerChain,
+        this.bus,
+        () => this.currentLocale,
+        (locale, namespaces) => this.loadNamespaces(locale, namespaces)
+      );
+    }
+    /**
+     * ✅ Register plugin (called by builder)
+     */
+    registerPlugin(plugin) {
+      this.plugins.set(plugin.name, plugin);
+      if (this.isEmbeddedPlugin(plugin)) {
+        this.integrateEmbeddedPlugin(plugin);
+      }
+      if (this.isEventPlugin(plugin)) {
+        this.eventPlugins.add(plugin);
+      }
+    }
+    /**
+     * 🔥 EMBEDDED: Integrate plugin functionality into core
+     */
+    integrateEmbeddedPlugin(plugin) {
+      if (plugin.getFormatters) {
+        const pluginFormatters = plugin.getFormatters();
+        Object.entries(pluginFormatters).forEach(([name, formatter]) => {
+          this.formatters.set(name, formatter);
+          logger.debug(`Embedded formatter: ${name} from ${plugin.name}`);
+        });
+      }
+      if (plugin.getProcessors) {
+        const pluginProcessors = plugin.getProcessors();
+        Object.entries(pluginProcessors).forEach(([name, processor]) => {
+          this.processors.set(name, processor);
+          logger.debug(`Embedded processor: ${name} from ${plugin.name}`);
+        });
+      }
+    }
+    /**
+     * 📦 TRANSLATION API - Returns PLAIN TEXT
+     *
+     * Strips indexed tags and returns safe plain text output.
+     * For HTML output with styles, use tHtml() instead.
+     *
+     * @param key - Translation key
+     * @param params - Optional interpolation parameters
+     * @param defaultValue - Optional default value
+     * @returns Plain text string (safe, no XSS risk)
+     *
+     * @example
+     * ```typescript
+     * t('welcome')                    // → "Hello World"
+     * t('greeting', { name: 'John' }) // → "Hello John"
+     * t('missing', 'Default text')   // → "Default text" (if key missing)
+     * ```
+     */
+    t(key, ...args) {
+      const [firstArg, secondArg] = args;
+      const request = prepareTranslationRequest(
+        key,
+        this.currentLocale,
+        firstArg,
+        secondArg,
+        this.defaultNamespace,
+        this.fallbackLocale
+      );
+      logger.debug(`Translation requested: ${request.cleanKey}`);
+      const translateBus = this.bus.translation(request);
+      translateBus.request();
+      const syncResult = this.handlerChain.handleSync(request);
+      if (syncResult && syncResult.status === 200) {
+        const result = this.processValue(syncResult.value, request);
+        logger.debug(
+          `Translation found: ${request.cleanKey} from ${syncResult.source} (${syncResult.duration}ms)`
+        );
+        translateBus.success(result);
+        return result;
+      }
+      this.triggerBackgroundLoad(request);
+      const fallbackValue = request.parsedDefaultValue || request.cleanKey;
+      const fallbackResult = this.processValue(fallbackValue, request);
+      logger.debug(`Translation fallback: ${request.cleanKey}`);
+      translateBus.fallback(fallbackResult);
+      return fallbackResult;
+    }
+    /**
+     * 📦 HTML TRANSLATION API
+     * Returns translation as HTML string with styles applied.
+     *
+     * Use for innerHTML, dangerouslySetInnerHTML, or server-side rendering.
+     * For React components, prefer using <Trans> instead.
+     *
+     * @param key - Translation key
+     * @param params - Optional interpolation parameters
+     * @param defaultValue - Optional default value (can contain HTML)
+     * @returns HTML string with styles applied
+     *
+     * @example
+     * ```typescript
+     * // Vanilla JS
+     * element.innerHTML = i18n.tHtml('welcome');
+     * // → "Hello <b>World</b>"
+     *
+     * // React (use sparingly)
+     * <span dangerouslySetInnerHTML={{ __html: tHtml('welcome') }} />
+     * ```
+     */
+    tHtml(key, ...args) {
+      const [firstArg, secondArg] = args;
+      const request = prepareTranslationRequest(
+        key,
+        this.currentLocale,
+        firstArg,
+        secondArg,
+        this.defaultNamespace,
+        this.fallbackLocale
+      );
+      logger.debug(`HTML translation requested: ${request.cleanKey}`);
+      const translateBus = this.bus.translation(request);
+      translateBus.request();
+      const syncResult = this.handlerChain.handleSync(request);
+      if (syncResult && syncResult.status === 200) {
+        const result = this.processValueAsHtml(syncResult.value, request, syncResult.styles);
+        logger.debug(
+          `HTML translation found: ${request.cleanKey} from ${syncResult.source}`
+        );
+        translateBus.success(result);
+        return result;
+      }
+      this.triggerBackgroundLoad(request);
+      const fallbackValue = request.parsedDefaultValue || request.cleanKey;
+      const fallbackResult = this.processValueAsHtml(fallbackValue, request);
+      logger.debug(`HTML translation fallback: ${request.cleanKey}`);
+      translateBus.fallback(fallbackResult);
+      return fallbackResult;
+    }
+    /**
+     * 📦 Process value as HTML (for tHtml)
+     *
+     * Converts indexed tags to HTML using styles from result or namespace cache.
+     *
+     * @internal
+     */
+    processValueAsHtml(value, request, resultStyles) {
+      const processedText = this.processTranslationValue(value, request);
+      if (this.containsIndexedTags(processedText)) {
+        const styles = resultStyles || this.getStylesFromNamespace(request);
+        const unit = {
+          text: processedText,
+          styles
+        };
+        return this.htmlSerializer.serialize(unit);
+      }
+      if (this.containsHtml(processedText)) {
+        const unit = this.markupParser.parse(processedText);
+        return this.htmlSerializer.serialize(unit);
+      }
+      return processedText;
+    }
+    /**
+     * 📦 Process a value through ContentUnit or ICU pipeline
+     *
+     * Processing priority:
+     * 1. Indexed tags (<1>...</1>) from server ContentUnit → convert to HTML at render time
+     * 2. HTML tags (from defaultValue or legacy) → MarkupParser → ContentUnit → HTML
+     * 3. Plain text → standard ICU processing
+     *
+     * @internal
+     */
+    processValue(value, request) {
+      if (this.containsIndexedTags(value)) {
+        return this.processIndexedValue(value, request);
+      }
+      if (this.containsHtml(value)) {
+        return this.processHtmlValue(value, request);
+      }
+      return this.processTranslationValue(value, request);
+    }
+    /**
+     * 📦 Check if a string contains indexed tags
+     *
+     * Used for auto-detection of server ContentUnit format.
+     *
+     * @param value - String to check
+     * @returns true if indexed tags are detected
+     */
+    containsIndexedTags(value) {
+      return INDEXED_TAG_REGEX.test(value);
+    }
+    /**
+     * 📦 Process indexed value - returns PLAIN TEXT
+     *
+     * Strips indexed tags (<1>text</1>) → "text"
+     * For HTML output, use tHtml() instead.
+     *
+     * @internal
+     */
+    processIndexedValue(value, request) {
+      const processedText = this.processTranslationValue(value, request);
+      return processedText.replace(/<\/?[0-9]+>/g, "");
+    }
+    /**
+     * 📦 Get styles for a translation key from namespace cache (fallback)
+     *
+     * Used when styles are not available in the result (e.g., for fallback values).
+     * Looks up the full ContentUnit from the namespace cache to get styles.
+     *
+     * @internal
+     */
+    getStylesFromNamespace(request) {
+      if (!request.namespace) {
+        return {};
+      }
+      try {
+        const namespaceCacheKey = createNamespaceCacheKey(
+          request.locale,
+          request.namespace
+        );
+        const namespaceData = this.handlerChain.getNamespaceData(namespaceCacheKey);
+        if (!namespaceData) {
+          return {};
+        }
+        const resolved = resolveNestedKey(namespaceData, request.cleanKey);
+        if (resolved && typeof resolved === "object" && "styles" in resolved) {
+          const contentUnit = resolved;
+          return contentUnit.styles;
+        }
+        return {};
+      } catch (error) {
+        logger.debug(`Error getting styles for key ${request.cleanKey}:`, error);
+        return {};
+      }
+    }
+    /**
+     * 📦 Process HTML value - returns PLAIN TEXT
+     *
+     * Parses HTML to ContentUnit, processes ICU, strips indexed tags.
+     * For HTML output, use tHtml() instead.
+     *
+     * @internal
+     */
+    processHtmlValue(value, request) {
+      try {
+        const unit = this.markupParser.parse(value);
+        const processedText = this.processTranslationValue(unit.text, request);
+        return processedText.replace(/<\/?[0-9]+>/g, "");
+      } catch (error) {
+        logger.warn(`ContentUnit processing failed for "${value}":`, error);
+        return this.processTranslationValue(value, request);
+      }
+    }
+    /**
+     * Implementation (handles both overloads)
+     */
+    processTranslationValue(value, paramsOrRequest, locale, key) {
+      let params;
+      let resolvedLocale;
+      let resolvedKey;
+      if (paramsOrRequest && "cleanKey" in paramsOrRequest) {
+        const request = paramsOrRequest;
+        params = request.parsedParams;
+        resolvedLocale = request.locale;
+        resolvedKey = request.cleanKey;
+      } else {
+        params = paramsOrRequest;
+        resolvedLocale = locale || this.currentLocale;
+        resolvedKey = key;
+      }
+      let processedValue = value;
+      try {
+        processedValue = this.applyStructuralFormatters(
+          processedValue,
+          params,
+          resolvedKey
+        );
+        if (this.formatters.has("interpolate")) {
+          const interpolateFormatter = this.formatters.get("interpolate");
+          processedValue = interpolateFormatter(
+            processedValue,
+            params,
+            resolvedLocale,
+            resolvedKey
+          );
+        }
+        if (this.processors.size > 0) {
+          for (const [name, processor] of this.processors.entries()) {
+            try {
+              processedValue = processor(processedValue, params, resolvedKey);
+            } catch (error) {
+              logger.warn(`Processor ${name} failed:`, error);
+            }
+          }
+        }
+        return processedValue;
+      } catch (error) {
+        logger.warn(`Translation processing failed for "${value}":`, error);
+        return value;
+      }
+    }
+    /**
+     * 📦 CONTENT UNIT API
+     * Returns translation as ContentUnit for JSX rendering (Trans component)
+     *
+     * This is the preferred method for components that need to render
+     * styled content with JSX interpolation.
+     *
+     * @param key - Translation key
+     * @param params - Optional interpolation parameters
+     * @param defaultValue - Optional default value (can contain HTML)
+     * @returns ContentUnit with indexed tags and styles
+     *
+     * @example
+     * ```typescript
+     * const unit = i18n.getContentUnit('terms', {}, 'Read our <b>Terms</b>.');
+     * // → { text: "Read our <1>Terms</1>.", styles: {"1": ["bold"]} }
+     * ```
+     */
+    getContentUnit(key, params, defaultValue) {
+      const request = prepareTranslationRequest(
+        key,
+        this.currentLocale,
+        params,
+        defaultValue,
+        this.defaultNamespace,
+        this.fallbackLocale
+      );
+      const syncResult = this.handlerChain.handleSync(request);
+      const rawValue = syncResult && syncResult.status === 200 ? syncResult.value : request.parsedDefaultValue || request.cleanKey;
+      if (!syncResult || syncResult.status !== 200) {
+        this.triggerBackgroundLoad(request);
+      }
+      return this.markupParser.parse(rawValue);
+    }
+    /**
+     * 📦 Process ContentUnit text through ICU formatters
+     *
+     * Used by JSX serializers to process individual text segments.
+     *
+     * @param text - Text segment (may contain ICU expressions like {name})
+     * @param params - Interpolation parameters
+     * @returns Processed text with ICU expressions resolved
+     */
+    processContentText(text, params) {
+      return this.processTranslationValue(text, params, this.currentLocale);
+    }
+    /**
+     * 📦 Check if a string contains HTML tags
+     *
+     * Used for auto-detection of HTML in default values.
+     *
+     * @param value - String to check
+     * @returns true if HTML tags are detected
+     */
+    containsHtml(value) {
+      return HTML_TAG_REGEX.test(value);
+    }
+    /**
+     * ✅ Handle structured formatters (plural, context) - embedded in core
+     */
+    applyStructuralFormatters(value, params, translationKey) {
+      const translationData = value;
+      const hasCount = (p) => typeof p?.count === "number";
+      const hasContext = (p) => typeof p?.context === "string";
+      if (this.formatters.has("plural") && hasCount(params)) {
+        const pluralFormatter = this.formatters.get("plural");
+        try {
+          const pluralResult = pluralFormatter(
+            translationData,
+            params,
+            this.currentLocale,
+            translationKey
+          );
+          if (pluralResult !== String(translationData)) {
+            return pluralResult;
+          }
+        } catch (error) {
+          logger.warn("Plural formatting failed:", error);
+        }
+      }
+      if (this.formatters.has("context") && hasContext(params)) {
+        const contextFormatter = this.formatters.get("context");
+        try {
+          const contextResult = contextFormatter(
+            translationData,
+            params,
+            this.currentLocale,
+            translationKey
+          );
+          if (contextResult !== String(translationData)) {
+            return contextResult;
+          }
+        } catch (error) {
+          logger.warn("Context formatting failed:", error);
+        }
+      }
+      return String(translationData);
+    }
+    /**
+     * Trigger background load via handler chain
+     */
+    triggerBackgroundLoad(request) {
+      logger.debug(`Background load: ${request.cleanKey}`);
+      const cacheKey = request.individualCacheKey;
+      if (!this.pendingTranslations.has(cacheKey)) {
+        const promise = this.handlerChain.handleAsync(request).then((result) => {
+          if (result && result.value) {
+            logger.debug(`Cached: ${request.cleanKey} = "${result.value}"`);
+          } else {
+            logger.debug(`Not found: ${request.cleanKey}`);
+          }
+        }).catch((error) => {
+          logger.warn(`Background load failed: ${request.cleanKey}`, error);
+        });
+        this.pendingTranslations.set(cacheKey, promise);
+        promise.finally(() => this.pendingTranslations.delete(cacheKey));
+      }
+    }
+    /**
+     * Get the current locale
+     */
+    getCurrentLocale() {
+      return this.currentLocale;
+    }
+    /**
+     * Set default namespace (useful for scoped translations)
+     */
+    setDefaultNamespace(namespace) {
+      this.defaultNamespace = namespace;
+    }
+    /**
+     * Get current default namespace
+     */
+    getDefaultNamespace() {
+      return this.defaultNamespace;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getEntries() {
+      return this.handlerChain.getEntries();
+    }
+    isCached(key) {
+      const request = prepareTranslationRequest(
+        key,
+        this.currentLocale,
+        void 0,
+        void 0,
+        this.defaultNamespace,
+        this.fallbackLocale
+      );
+      return this.handlerChain.isCached(request);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getHandlerChainInfo() {
+      return this.handlerChain.getChainInfo();
+    }
+    /**
+     * ✅ Smart language change with selective cache clearing
+     */
+    async changeLanguage(newLocale, options) {
+      const oldLocale = this.currentLocale;
+      if (oldLocale === newLocale) {
+        logger.debug(`Language already set to ${newLocale}`);
+        return;
+      }
+      const clear = options?.clear || false;
+      const languageBus = this.bus.language(oldLocale, newLocale);
+      try {
+        logger.info(`Language change: ${oldLocale} \u2192 ${newLocale}`);
+        logger.debug("Language change options", {
+          clear,
+          preloadNamespaces: options?.preloadNamespaces
+        });
+        languageBus.start();
+        this.currentLocale = newLocale;
+        if (clear) {
+          await this.clearCache();
+          this.clearOldLocalePendingTranslations(oldLocale);
+        }
+        if (options?.preloadNamespaces?.length) {
+          await this.loadNamespaces(newLocale, options.preloadNamespaces);
+        }
+        languageBus.complete();
+        logger.info(`Language changed: ${newLocale}`);
+      } catch (error) {
+        logger.error("Language change failed:", error);
+        languageBus.error(error);
+        throw error;
+      }
+    }
+    async clearCache() {
+      this.handlerChain.clearCache();
+      logger.debug(`Cache cleared for locale: ${this.currentLocale}`);
+    }
+    clearOldLocalePendingTranslations(oldLocale) {
+      let clearedCount = 0;
+      for (const key of this.pendingTranslations.keys()) {
+        if (key.includes(`${oldLocale}:`)) {
+          this.pendingTranslations.delete(key);
+          clearedCount++;
+        }
+      }
+      if (clearedCount > 0) {
+        logger.debug(
+          `Cleared ${clearedCount} pending translations for ${oldLocale}`
+        );
+      }
+    }
+    async loadNamespaces(locale, namespaces) {
+      logger.debug(`Preloading ${namespaces.length} namespaces for ${locale}`);
+      const preloadPromises = namespaces.map(async (namespace) => {
+        try {
+          await this.handlerChain.loadNamespace?.(locale, namespace);
+          logger.debug(`Preloaded: ${locale}:${namespace}`);
+        } catch (error) {
+          logger.warn(`Failed to preload ${locale}:${namespace}:`, error);
+        }
+      });
+      await Promise.allSettled(preloadPromises);
+    }
+    /**
+     * Reload a namespace by clearing cache and fetching fresh data from server
+     * Useful after syncing new translations to ensure fresh data
+     *
+     * @param namespace - The namespace to reload
+     * @param locale - Optional locale (defaults to current locale)
+     * @deprecated Use cache.invalidate({ namespace, refetch: true }) instead
+     */
+    async reloadNamespace(namespace, locale) {
+      const targetLocale = locale || this.currentLocale;
+      logger.debug(`Reloading namespace: ${targetLocale}:${namespace}`);
+      await this.cache.invalidate({
+        namespace,
+        locale: targetLocale,
+        refetch: true
+      });
+      logger.info(`Namespace reloaded: ${targetLocale}:${namespace}`);
+    }
+    // Helper methods
+    isEmbeddedPlugin(plugin) {
+      return plugin.capabilities.some(
+        (cap) => ["formatters", "processors", "pluralization", "context"].includes(cap)
+      );
+    }
+    isEventPlugin(plugin) {
+      return plugin.capabilities.some(
+        (cap) => [
+          "analytics",
+          "logging",
+          "react",
+          "validation",
+          "dev-tools",
+          "monitoring"
+        ].includes(cap)
+      );
+    }
+  };
+
+  // src/sync/missing-translation-queue.ts
+  var COOLDOWN_MS = 6e4;
+  var MissingTranslationQueue = class {
+    constructor(repository, config, eventEmitter) {
+      __publicField(this, "queue", /* @__PURE__ */ new Map());
+      __publicField(this, "debounceTimer", null);
+      __publicField(this, "repository");
+      __publicField(this, "config");
+      __publicField(this, "eventEmitter");
+      __publicField(this, "recentlySynced", /* @__PURE__ */ new Map());
+      this.repository = repository;
+      this.config = config;
+      this.eventEmitter = eventEmitter ?? null;
+      if (!config.enabled) {
+        logger.debug("MissingTranslationQueue is disabled");
+      } else {
+        logger.debug(
+          `MissingTranslationQueue: debounce=${config.debounceMs}ms, batchSize=${config.batchSize}`
+        );
+      }
+    }
+    /**
+     * Add a missing translation to the queue
+     * Triggers debounce timer or immediate flush if batch size reached
+     */
+    add(item) {
+      if (!this.config.enabled) return;
+      const cacheKey = `${item.locale}:${item.namespace}:${item.key}`;
+      const syncedAt = this.recentlySynced.get(cacheKey);
+      if (syncedAt && Date.now() - syncedAt < COOLDOWN_MS) {
+        logger.debug(`Skipping recently synced key: ${cacheKey}`);
+        return;
+      }
+      this.queue.set(cacheKey, item);
+      logger.debug(
+        `Missing translation queued: ${cacheKey} (queue size: ${this.queue.size})`
+      );
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = null;
+      }
+      if (this.queue.size >= this.config.batchSize) {
+        logger.debug(`Batch size reached (${this.config.batchSize}), flushing`);
+        this.flush();
+        return;
+      }
+      this.debounceTimer = setTimeout(() => {
+        this.flush();
+      }, this.config.debounceMs);
+    }
+    /**
+     * Flush the queue - send all queued items to the backend
+     * Fire-and-forget pattern (async but not awaited)
+     */
+    flush() {
+      if (this.queue.size === 0) return;
+      const now = Date.now();
+      for (const [key, ts] of this.recentlySynced) {
+        if (now - ts >= COOLDOWN_MS) this.recentlySynced.delete(key);
+      }
+      const batch = Array.from(this.queue.entries()).map(([cacheKey, item]) => ({
+        key: cacheKey,
+        value: item.fallbackValue,
+        styles: item.styles
+      }));
+      const batchSize = batch.length;
+      this.queue.clear();
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = null;
+      }
+      logger.debug(`Flushing ${batchSize} missing translations`);
+      this.syncBatch(batch).catch((error) => {
+        logger.warn(`Failed to sync ${batchSize} missing translations:`, error);
+      });
+    }
+    /**
+     * Send batch to backend via repository
+     * Uses repository's retry logic from makeRequest()
+     */
+    async syncBatch(batch) {
+      try {
+        const hasStyles = batch.some((item) => item.styles && Object.keys(item.styles).length > 0);
+        if (hasStyles && "setBatchContentUnits" in this.repository) {
+          const contentUnitBatch = batch.map((item) => ({
+            key: item.key,
+            value: { text: item.value, styles: item.styles ?? {} }
+          }));
+          await this.repository.setBatchContentUnits(contentUnitBatch);
+          logger.debug(`Synced ${batch.length} missing translations (ContentUnit)`);
+        } else if ("setBatch" in this.repository) {
+          const plainBatch = batch.map((item) => ({ key: item.key, value: item.value }));
+          await this.repository.setBatch(plainBatch);
+          logger.debug(`Synced ${batch.length} missing translations`);
+        } else {
+          logger.warn(
+            "Repository does not support setBatch, syncing individually"
+          );
+          await this.syncIndividually(batch);
+        }
+        const now = Date.now();
+        const syncedKeys = [];
+        for (const item of batch) {
+          this.recentlySynced.set(item.key, now);
+          syncedKeys.push(item.key);
+        }
+        if (this.eventEmitter) {
+          this.eventEmitter.emit("sync:batch:complete", {
+            payload: { count: batch.length, keys: syncedKeys }
+          });
+        }
+      } catch (error) {
+        logger.error("Batch sync failed:", error);
+        throw error;
+      }
+    }
+    /**
+     * Fallback: sync items individually in parallel
+     */
+    async syncIndividually(batch) {
+      const syncPromises = batch.map(async (item) => {
+        try {
+          await this.repository.set(item.key, item.value);
+          logger.debug(`Synced: ${item.key}`);
+        } catch (error) {
+          logger.warn(`Failed to sync ${item.key}:`, error);
+        }
+      });
+      await Promise.allSettled(syncPromises);
+    }
+    /**
+     * Get current queue size (for debugging)
+     */
+    getQueueSize() {
+      return this.queue.size;
+    }
+    /**
+     * Get queue stats (for debugging)
+     */
+    getStats() {
+      return {
+        queueSize: this.queue.size,
+        enabled: this.config.enabled,
+        debounceMs: this.config.debounceMs,
+        batchSize: this.config.batchSize
+      };
+    }
+    /**
+     * Cleanup - clear timer and queue
+     */
+    destroy() {
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = null;
+      }
+      this.queue.clear();
+      this.recentlySynced.clear();
+      logger.debug("MissingTranslationQueue destroyed");
+    }
+  };
+
+  // src/builder.ts
+  var LionRapidBuilder = class _LionRapidBuilder {
+    constructor(config) {
+      __publicField(this, "config");
+      __publicField(this, "plugins", []);
+      __publicField(this, "syncStorageRepos", []);
+      __publicField(this, "asyncStorageRepos", []);
+      __publicField(this, "networkRepos", []);
+      __publicField(this, "syncQueue", null);
+      this.config = {
+        defaultLocale: config.defaultLocale || "en",
+        fallbackLocale: config.fallbackLocale || "en",
+        namespace: config.namespace || "app"
+      };
+    }
+    static init(config = {}) {
+      return new _LionRapidBuilder(config);
+    }
+    useSyncStorage(memory) {
+      this.syncStorageRepos.push(memory);
+      return this;
+    }
+    useAsyncStorage(storage) {
+      this.asyncStorageRepos.push(storage);
+      return this;
+    }
+    useNetwork(network) {
+      this.networkRepos.push(network);
+      return this;
+    }
+    use(instance) {
+      switch (instance.type) {
+        case "plugin":
+          this.plugins.push(instance);
+          break;
+        case "memory":
+          this.useSyncStorage(instance);
+          break;
+        case "storage":
+          this.useAsyncStorage(instance);
+          break;
+        case "network":
+          this.useNetwork(instance);
+          break;
+      }
+      return this;
+    }
+    async build() {
+      const eventEmitter = new EventEmitter();
+      const buildBus = eventEmitter.builder();
+      logger.info("Builder started");
+      logger.debug("Builder config", this.config);
+      buildBus.buildStart(this.config.defaultLocale, this.config.namespace);
+      const handlerChain = new HandlerChain(eventEmitter);
+      for (const syncRepo of this.syncStorageRepos) {
+        if (!syncRepo.getConfig().enabled) continue;
+        const syncHandler = new SyncHandler(eventEmitter, syncRepo);
+        buildBus.use("sync");
+        handlerChain.addSyncHandler(syncHandler);
+      }
+      for (const asyncRepo of this.asyncStorageRepos) {
+        if (!asyncRepo.getConfig().enabled) continue;
+        const asyncHandler = new AsyncHandler(eventEmitter, asyncRepo);
+        buildBus.use("async");
+        handlerChain.addAsyncHandler(asyncHandler);
+      }
+      let networkFirst = null;
+      for (const networkRepo of this.networkRepos) {
+        if (!networkRepo.getConfig().enabled || !networkRepo.getConfig().options?.baseUrl)
+          continue;
+        const networkHandler = new NetworkHandler(eventEmitter, networkRepo);
+        if (!networkFirst) {
+          networkFirst = networkHandler;
+        }
+        buildBus.use("network");
+        handlerChain.addAsyncHandler(networkHandler);
+        const config = networkRepo.getConfig();
+        if (config.options?.syncMissing?.enabled) {
+          this.syncQueue = new MissingTranslationQueue(networkRepo, {
+            enabled: config.options.syncMissing.enabled,
+            debounceMs: config.options.syncMissing.debounceMs || 500,
+            batchSize: config.options.syncMissing.batchSize || 50
+          }, eventEmitter);
+          eventEmitter.on("translation:not-found", (envelope) => {
+            if (this.syncQueue) {
+              this.syncQueue.add({
+                key: envelope.payload.key,
+                fallbackValue: envelope.payload.fallbackValue,
+                styles: envelope.payload.styles,
+                locale: envelope.payload.locale,
+                namespace: envelope.payload.namespace
+              });
+            }
+          });
+          logger.info("Missing translation sync enabled");
+          logger.debug("Sync queue config", config.options.syncMissing);
+        }
+      }
+      logger.debug("Handler chain constructed");
+      const facade = new LionRapidCore(
+        eventEmitter,
+        handlerChain,
+        this.config.defaultLocale,
+        this.config.fallbackLocale,
+        this.config.namespace
+      );
+      for (const plugin of this.plugins) {
+        buildBus.use("plugin");
+        await plugin.initialize({ core: facade, bus: eventEmitter });
+        facade.registerPlugin(plugin);
+        logger.info(`Plugin initialized: ${plugin.name}`);
+        logger.debug(`Plugin version: ${plugin.version}`, plugin.capabilities);
+      }
+      const chainInfo = handlerChain.getChainInfo();
+      if (networkFirst) {
+        await this.executePreloading(networkFirst, handlerChain);
+      }
+      logger.info("Builder completed");
+      buildBus.buildDone(
+        chainInfo.handlers.map((r) => r.name),
+        this.plugins.map((p) => p.name)
+      );
+      return facade;
+    }
+    // ✅ CLEAN: Preloading logic
+    async executePreloading(networkHandler, handlerChain) {
+      const eagerPreloads = networkHandler.getPreload().filter((config) => config.eager !== false);
+      if (!eagerPreloads || eagerPreloads.length === 0) {
+        return;
+      }
+      logger.info(`Preloading ${eagerPreloads.length} namespaces`);
+      logger.debug("Preload targets", {
+        namespaces: eagerPreloads.map((c) => `${c.locale}:${c.namespace}`)
+      });
+      const promises = eagerPreloads.map(async (preloadConfig) => {
+        try {
+          const result = await networkHandler.loadNamespace(
+            preloadConfig.locale,
+            preloadConfig.namespace
+          );
+          if (result && result.data && result.status === 200) {
+            const context = {
+              locale: preloadConfig.locale,
+              namespace: preloadConfig.namespace,
+              fallbackLocale: this.config.fallbackLocale
+            };
+            await handlerChain.saveNamespaceToHandlers(result.data, context);
+            logger.debug(
+              `Preloaded: ${preloadConfig.locale}:${preloadConfig.namespace}`
+            );
+          }
+        } catch (error) {
+          logger.warn(
+            `Preload failed: ${preloadConfig.locale}:${preloadConfig.namespace}`,
+            error
+          );
+        }
+      });
+      await Promise.allSettled(promises);
+      logger.info("Preloading completed");
+    }
+  };
+
+  // src/repositories/network-repository.ts
+  var _NetworkRepository = class _NetworkRepository {
+    constructor(config = {}) {
+      __publicField(this, "name", "NetworkRepository");
+      __publicField(this, "type", "network");
+      __publicField(this, "config", {});
+      /** Cached version (opaque string from server) per namespace key "locale:namespace" */
+      __publicField(this, "namespaceVersions", /* @__PURE__ */ new Map());
+      /**
+       * Default endpoint templates with placeholder support
+       * Placeholders: :key, :locale, :namespace
+       */
+      __publicField(this, "DEFAULT_ENDPOINTS", {
+        getTranslation: "/api/integrations/translations/:key",
+        getNamespace: "/api/integrations/translations/:locale/:namespace",
+        setTranslation: "/api/integrations/sync/:key",
+        setNamespace: "/api/integrations/sync/:locale/:namespace",
+        setBatch: "/api/integrations/sync/batch",
+        removeTranslation: "/api/integrations/sync/:key",
+        clearTranslations: "/translations"
+      });
+      this.config = {
+        options: {
+          timeout: config.options?.timeout ?? 5e3,
+          baseUrl: config.options?.baseUrl ?? "",
+          headers: config.options?.headers ?? {}
+        },
+        ...config
+      };
+    }
+    /**
+     * Get single translation from API
+     * Uses platform-specific integration endpoint
+     * @throws {TranslationNotFoundError} When translation doesn't exist (404)
+     * @throws {TranslationLockedError} When translation is locked/not ready (423)
+     * @throws {ServerError} When server returns 5xx error
+     * @throws {NetworkError} When network request fails
+     */
+    async get(key) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        throw new NetworkError("API base URL is not set");
+      }
+      const url = this.buildUrl("getTranslation", { key });
+      logger.debug(`API GET: ${url}`);
+      try {
+        const response = await this.makeRequest(url, "GET");
+        if (!response.ok) {
+          this.handleHttpError(response, key);
+        }
+        const data = await response.json();
+        logger.debug("API response data:", data);
+        const translation = data.translations[data.meta?.key] || data.translations[key] || Object.values(data.translations)[0];
+        logger.debug(`Fetched translation for key "${key}":`, translation);
+        if (!translation) {
+          throw new TranslationNotFoundError(key);
+        }
+        if (typeof translation === "object" && "text" in translation) {
+          logger.debug(`ContentUnit text: "${translation.text}"`);
+          return translation.text;
+        }
+        return String(translation);
+      } catch (error) {
+        this.handleCaughtError(error);
+      }
+    }
+    /**
+     * Get single translation as full ContentUnit (with styles)
+     * Used by NetworkHandler for individual key lookups that need styles
+     * @throws {TranslationNotFoundError} When translation doesn't exist (404)
+     * @throws {TranslationLockedError} When translation is locked/not ready (423)
+     * @throws {ServerError} When server returns 5xx error
+     * @throws {NetworkError} When network request fails
+     */
+    async getContentUnit(key) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        throw new NetworkError("API base URL is not set");
+      }
+      const url = this.buildUrl("getTranslation", { key });
+      logger.debug(`API GET ContentUnit: ${url}`);
+      try {
+        const response = await this.makeRequest(url, "GET");
+        if (!response.ok) {
+          this.handleHttpError(response, key);
+        }
+        const data = await response.json();
+        logger.debug("API response data:", data);
+        const translation = data.translations[data.meta?.key] || data.translations[key] || Object.values(data.translations)[0];
+        if (!translation) {
+          throw new TranslationNotFoundError(key);
+        }
+        if (typeof translation === "object" && "text" in translation) {
+          logger.debug(`ContentUnit for "${key}": text="${translation.text}", styles=`, translation.styles);
+          return {
+            text: translation.text,
+            styles: translation.styles || {}
+          };
+        }
+        logger.debug(`Plain string for "${key}": "${translation}" (no styles)`);
+        return {
+          text: String(translation),
+          styles: {}
+        };
+      } catch (error) {
+        this.handleCaughtError(error);
+      }
+    }
+    /**
+     * Get namespace with all translations
+     * @throws {TranslationNotFoundError} When namespace doesn't exist (404)
+     * @throws {TranslationLockedError} When namespace is locked/not ready (423)
+     * @throws {ServerError} When server returns 5xx error
+     * @throws {NetworkError} When network request fails
+     */
+    async getNamespace(locale, namespace) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        throw new NetworkError("API base URL is not set");
+      }
+      const url = this.buildUrl("getNamespace", { locale, namespace });
+      logger.debug(`API GET Namespace: ${url}`);
+      const namespaceKey = `${locale}:${namespace}`;
+      try {
+        const extraHeaders = {};
+        const cachedVersion = this.getVersion(namespaceKey);
+        if (cachedVersion) {
+          extraHeaders["If-None-Match"] = `W/"${cachedVersion}"`;
+        }
+        const response = await this.makeRequest(url, "GET", void 0, extraHeaders);
+        if (response.status === 304) {
+          logger.debug(`Namespace ${namespaceKey}: 304 Not Modified`);
+          return null;
+        }
+        if (!response.ok) {
+          this.handleHttpError(response, namespaceKey);
+        }
+        const data = await response.json();
+        logger.debug("API response data:", data);
+        if (!data.translations) {
+          throw new TranslationNotFoundError(namespaceKey);
+        }
+        const version = data.meta?.version != null ? String(data.meta.version) : null;
+        if (version) {
+          this.setVersion(namespaceKey, version);
+        }
+        return data.translations;
+      } catch (error) {
+        this.handleCaughtError(error);
+      }
+    }
+    /**
+     * Save translation to API (if supported)
+     */
+    async set(key, value) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("setTranslation", { key });
+        const response = await this.makeRequest(url, "PUT", {
+          translation: value
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to save translation: ${response.status}`);
+        }
+      } catch (error) {
+        logger.debug(`API set failed for key "${key}":`, error);
+        throw error;
+      }
+    }
+    async setNamespace(locale, namespace, translations) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("setNamespace", { locale, namespace });
+        const response = await this.makeRequest(url, "PUT", {
+          translations
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to save namespace: ${response.status}`);
+        }
+      } catch (error) {
+        logger.debug(
+          `API setNamespace failed for ${locale}:${namespace}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    /**
+     * Batch sync multiple missing translations
+     * Uses new batch endpoint for efficiency
+     */
+    async setBatch(items) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("setBatch");
+        logger.debug(`API POST Batch: ${url} (${items.length} items)`);
+        const response = await this.makeRequest(url, "POST", {
+          translations: items
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to sync batch: ${response.status}`);
+        }
+        logger.debug(`Batch sync successful: ${items.length} items`);
+      } catch (error) {
+        logger.debug(`API setBatch failed for ${items.length} items:`, error);
+        throw error;
+      }
+    }
+    // ════════════════════════════════════════════════════════════════════════════
+    // ContentUnit API Methods
+    // ════════════════════════════════════════════════════════════════════════════
+    /**
+     * Get namespace with all translations as ContentUnit data
+     *
+     * @returns ContentUnitData (Record<string, ContentUnit>)
+     * @throws {TranslationNotFoundError} When namespace doesn't exist (404)
+     * @throws {TranslationLockedError} When namespace is locked/not ready (423)
+     * @throws {ServerError} When server returns 5xx error
+     * @throws {NetworkError} When network request fails
+     */
+    async getNamespaceContentUnits(locale, namespace) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        throw new NetworkError("API base URL is not set");
+      }
+      const url = this.buildUrl("getNamespace", { locale, namespace });
+      logger.debug(`API GET Namespace ContentUnits: ${url}`);
+      const namespaceKey = `${locale}:${namespace}`;
+      try {
+        const extraHeaders = {};
+        const cachedVersion = this.getVersion(namespaceKey);
+        if (cachedVersion) {
+          extraHeaders["If-None-Match"] = `W/"${cachedVersion}"`;
+        }
+        const response = await this.makeRequest(url, "GET", void 0, extraHeaders);
+        if (response.status === 304) {
+          logger.debug(`Namespace ContentUnits ${namespaceKey}: 304 Not Modified`);
+          return null;
+        }
+        if (!response.ok) {
+          this.handleHttpError(response, namespaceKey);
+        }
+        const data = await response.json();
+        logger.debug("API response data:", data);
+        if (!data.translations) {
+          throw new TranslationNotFoundError(namespaceKey);
+        }
+        const version = data.meta?.version != null ? String(data.meta.version) : null;
+        if (version) {
+          this.setVersion(namespaceKey, version);
+        }
+        return data.translations;
+      } catch (error) {
+        this.handleCaughtError(error);
+      }
+    }
+    /**
+     * Save ContentUnit to API
+     *
+     * Sends the ContentUnit format to server for storage.
+     * Server should store in ContentUnit format for efficient retrieval.
+     *
+     * @param key - Translation key
+     * @param unit - ContentUnit to save
+     */
+    async setContentUnit(key, unit) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("setTranslation", { key });
+        const response = await this.makeRequest(url, "PUT", {
+          translation: unit,
+          format: "contentunit"
+          // Signal to server that this is ContentUnit format
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to save ContentUnit: ${response.status}`);
+        }
+        logger.debug(`Saved ContentUnit for key "${key}"`);
+      } catch (error) {
+        logger.debug(`API setContentUnit failed for key "${key}":`, error);
+        throw error;
+      }
+    }
+    /**
+     * Batch sync multiple ContentUnits
+     *
+     * Sends ContentUnit format to server for batch storage.
+     *
+     * @param items - Array of key-ContentUnit pairs
+     */
+    async setBatchContentUnits(items) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("setBatch");
+        logger.debug(
+          `API POST Batch ContentUnits: ${url} (${items.length} items)`
+        );
+        const response = await this.makeRequest(url, "POST", {
+          translations: items,
+          format: "contentunit"
+          // Signal to server that this is ContentUnit format
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to sync batch ContentUnits: ${response.status}`);
+        }
+        logger.debug(`Batch ContentUnit sync successful: ${items.length} items`);
+      } catch (error) {
+        logger.debug(
+          `API setBatchContentUnits failed for ${items.length} items:`,
+          error
+        );
+        throw error;
+      }
+    }
+    /**
+     * Remove translation from API (if supported)
+     */
+    async remove(key) {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("removeTranslation", { key });
+        const response = await this.makeRequest(url, "DELETE");
+        if (!response.ok) {
+          throw new Error(`Failed to remove translation: ${response.status}`);
+        }
+      } catch (error) {
+        logger.debug(`API remove failed for key "${key}":`, error);
+        throw error;
+      }
+    }
+    /**
+     * Clear all translations (if supported)
+     */
+    async clear() {
+      if (!this.config?.options?.baseUrl) {
+        logger.debug("API base URL is not set");
+        return Promise.reject(new Error("API base URL is not set"));
+      }
+      try {
+        const url = this.buildUrl("clearTranslations");
+        const response = await this.makeRequest(url, "DELETE");
+        if (!response.ok) {
+          throw new Error(`Failed to clear translations: ${response.status}`);
+        }
+      } catch (error) {
+        logger.debug("API clear failed:", error);
+        throw error;
+      }
+    }
+    getConfig() {
+      return this.config;
+    }
+    /** Read persisted version from localStorage, falling back to in-memory map */
+    getVersion(namespaceKey) {
+      const mem = this.namespaceVersions.get(namespaceKey);
+      if (mem) return mem;
+      try {
+        const stored = localStorage.getItem(_NetworkRepository.VERSION_PREFIX + namespaceKey);
+        if (stored) {
+          this.namespaceVersions.set(namespaceKey, stored);
+          return stored;
+        }
+      } catch {
+      }
+      return void 0;
+    }
+    /** Persist version to both in-memory map and localStorage */
+    setVersion(namespaceKey, version) {
+      this.namespaceVersions.set(namespaceKey, version);
+      try {
+        localStorage.setItem(_NetworkRepository.VERSION_PREFIX + namespaceKey, version);
+      } catch {
+      }
+    }
+    /**
+     * Handle HTTP error responses by mapping to domain errors
+     * @throws {TranslationNotFoundError} When status is 404
+     * @throws {TranslationLockedError} When status is 423
+     * @throws {ServerError} When status is 5xx
+     * @throws {NetworkError} For other client errors
+     */
+    handleHttpError(response, key) {
+      logger.debug(`API response: ${response.status} ${response.statusText}`);
+      if (response.status === 404) {
+        throw new TranslationNotFoundError(key);
+      }
+      if (response.status === 423) {
+        const retryAfter = response.headers.get("Retry-After");
+        throw new TranslationLockedError(
+          key,
+          retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0
+        );
+      }
+      if (response.status >= 500 && response.status < 600) {
+        throw new ServerError(key, response.status);
+      }
+      throw new NetworkError(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    /**
+     * Handle caught errors by wrapping non-domain errors
+     * @throws {TranslationError} Always throws - propagates domain errors or wraps unexpected ones
+     */
+    handleCaughtError(error) {
+      if (error instanceof TranslationNotFoundError || error instanceof TranslationLockedError || error instanceof ServerError || error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError("Network request failed", error);
+    }
+    /**
+     * Build URL from endpoint template and parameters
+     * Supports placeholders: :key, :locale, :namespace
+     * @param endpoint - Endpoint key from DEFAULT_ENDPOINTS
+     * @param params - Parameters to replace placeholders with
+     * @returns Complete URL with baseUrl + endpoint path
+     */
+    buildUrl(endpoint, params = {}) {
+      const baseUrl = this.config.options?.baseUrl || "";
+      let endpointTemplate = this.config.options?.endpoints?.[endpoint] || this.DEFAULT_ENDPOINTS[endpoint];
+      if (!endpointTemplate.startsWith("/")) {
+        endpointTemplate = `/${endpointTemplate}`;
+      }
+      let path = endpointTemplate;
+      for (const [key, value] of Object.entries(params)) {
+        const placeholder = new RegExp(`:${key}`, "g");
+        path = path.replace(placeholder, encodeURIComponent(value));
+      }
+      return `${baseUrl}${path}`;
+    }
+    /**
+     * Make HTTP request with timeout and headers
+     */
+    async makeRequest(url, method, body, extraHeaders) {
+      const controller = new AbortController();
+      const timeout = this.config.options?.timeout ?? 1e4;
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        timeout
+      );
+      try {
+        const headers = {
+          "Content-Type": "application/json",
+          ...this.config.options?.headers,
+          ...extraHeaders
+        };
+        if (this.config.options?.apiKey) {
+          headers["Authorization"] = `Bearer ${this.config.options.apiKey}`;
+        }
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        return response;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
+  /** localStorage key prefix for persisted versions */
+  __publicField(_NetworkRepository, "VERSION_PREFIX", "lionrapid:v:");
+  var NetworkRepository = _NetworkRepository;
+
+  // src/repositories/memory-repository.ts
+  var MemoryRepository = class {
+    constructor(config) {
+      __publicField(this, "name", "MemoryRepository");
+      __publicField(this, "type", "memory");
+      __publicField(this, "config", {});
+      __publicField(this, "cache", /* @__PURE__ */ new Map());
+      __publicField(this, "accessOrder", /* @__PURE__ */ new Map());
+      __publicField(this, "maxSize", 1e3);
+      this.config = config;
+      this.maxSize = this.config.options?.maxSize || 1e3;
+    }
+    get(key) {
+      const value = this.cache.get(key);
+      if (value !== void 0) {
+        this.accessOrder.set(key, Date.now());
+        return value;
+      }
+      return null;
+    }
+    set(key, value) {
+      if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+        this.evictOldest();
+      }
+      this.cache.set(key, value);
+      this.accessOrder.set(key, Date.now());
+    }
+    remove(key) {
+      this.cache.delete(key);
+      this.accessOrder.delete(key);
+    }
+    clear() {
+      this.cache.clear();
+      this.accessOrder.clear();
+    }
+    /**
+     * Clear all entries for a specific namespace
+     * Removes both the namespace cache entry and all individual translation keys
+     */
+    clearNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const keyPrefix = `${locale}:${namespace}:`;
+      this.cache.delete(namespaceCacheKey);
+      this.accessOrder.delete(namespaceCacheKey);
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(keyPrefix)) {
+          this.cache.delete(key);
+          this.accessOrder.delete(key);
+        }
+      }
+    }
+    getNamespace(locale, namespace) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      const namespaceData = this.cache.get(namespaceCacheKey);
+      if (!namespaceData) return null;
+      try {
+        return JSON.parse(namespaceData);
+      } catch (error) {
+        this.cache.delete(namespaceCacheKey);
+        return null;
+      }
+    }
+    setNamespace(locale, namespace, translations) {
+      const namespaceCacheKey = createNamespaceCacheKey(locale, namespace);
+      this.cache.set(namespaceCacheKey, JSON.stringify(translations));
+    }
+    evictOldest() {
+      let oldestKey = "";
+      let oldestTime = Date.now();
+      for (const [key, time] of this.accessOrder.entries()) {
+        if (time < oldestTime) {
+          oldestTime = time;
+          oldestKey = key;
+        }
+      }
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        this.accessOrder.delete(oldestKey);
+      }
+    }
+    /**
+     * Get all cache entries for debugging
+     */
+    getEntries() {
+      const entries = {};
+      for (const [key, value] of this.cache.entries()) {
+        entries[key] = value;
+      }
+      return entries;
+    }
+    getConfig() {
+      return this.config;
+    }
+  };
+
+  // src/content/validator/ContentValidator.ts
+  var ContentValidator = class {
+    /**
+     * Validate a ContentUnit for structural integrity
+     *
+     * @param unit - ContentUnit to validate
+     * @returns Validation result with errors and warnings
+     */
+    validate(unit) {
+      const errors = [];
+      const warnings = [];
+      this.validateTagBalance(unit.text, errors);
+      this.validateStyleReferences(unit.text, unit.styles, errors, warnings);
+      this.validateICUBraces(unit.text, errors);
+      return {
+        valid: errors.length === 0,
+        errors,
+        warnings
+      };
+    }
+    /**
+     * Validate that all indexed tags are properly balanced and correctly nested
+     */
+    validateTagBalance(text, errors) {
+      const tagPattern = /<(\/?)?(\d+)(\/)?>/g;
+      const tagStack = [];
+      let match;
+      while ((match = tagPattern.exec(text)) !== null) {
+        const [, closingSlash, indexStr, selfClosingSlash] = match;
+        if (selfClosingSlash) {
+          continue;
+        }
+        if (closingSlash) {
+          if (tagStack.length === 0) {
+            errors.push({
+              code: "UNBALANCED_TAGS",
+              message: `Closing tag </${indexStr}> has no matching opening tag`,
+              path: `text[${match.index}]`
+            });
+          } else {
+            const lastOpen = tagStack[tagStack.length - 1];
+            if (lastOpen.index === indexStr) {
+              tagStack.pop();
+            } else {
+              const foundIndex = tagStack.findIndex((t) => t.index === indexStr);
+              if (foundIndex >= 0) {
+                errors.push({
+                  code: "UNBALANCED_TAGS",
+                  message: `Improperly nested: </${indexStr}> should close before </${lastOpen.index}>`,
+                  path: `text[${match.index}]`
+                });
+                tagStack.splice(foundIndex, 1);
+              } else {
+                errors.push({
+                  code: "UNBALANCED_TAGS",
+                  message: `Closing tag </${indexStr}> has no matching opening tag`,
+                  path: `text[${match.index}]`
+                });
+              }
+            }
+          }
+        } else {
+          tagStack.push({ index: indexStr, position: match.index });
+        }
+      }
+      for (const { index } of tagStack) {
+        errors.push({
+          code: "UNBALANCED_TAGS",
+          message: `Opening tag <${index}> has no matching closing tag`,
+          path: "text"
+        });
+      }
+    }
+    /**
+     * Validate style references - check that used tags have styles and vice versa
+     */
+    validateStyleReferences(text, styles, errors, warnings) {
+      const usedIndices = /* @__PURE__ */ new Set();
+      const tagPattern = /<\/?(\d+)(?:\/)?>/g;
+      let match;
+      while ((match = tagPattern.exec(text)) !== null) {
+        usedIndices.add(match[1]);
+      }
+      for (const index of usedIndices) {
+        if (!styles[index] || styles[index].length === 0) {
+          warnings.push({
+            code: "EMPTY_STYLE",
+            message: `Tag <${index}> has no style definition, will render as <span>`
+          });
+        }
+      }
+      for (const index of Object.keys(styles)) {
+        if (!usedIndices.has(index)) {
+          warnings.push({
+            code: "UNUSED_TAG",
+            message: `Style for tag <${index}> is defined but tag is not used in text`
+          });
+        }
+      }
+    }
+    /**
+     * Validate ICU MessageFormat brace balance
+     */
+    validateICUBraces(text, errors) {
+      let depth = 0;
+      let inString = false;
+      let stringChar = "";
+      for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        const prevChar = i > 0 ? text[i - 1] : "";
+        if ((char === '"' || char === "'") && prevChar !== "\\") {
+          if (!inString) {
+            inString = true;
+            stringChar = char;
+          } else if (char === stringChar) {
+            inString = false;
+            stringChar = "";
+          }
+          continue;
+        }
+        if (inString) continue;
+        if (char === "{") {
+          depth++;
+        } else if (char === "}") {
+          depth--;
+          if (depth < 0) {
+            errors.push({
+              code: "INVALID_ICU",
+              message: `Unbalanced ICU braces: unexpected '}' at position ${i}`,
+              path: `text[${i}]`
+            });
+            depth = 0;
+          }
+        }
+      }
+      if (depth > 0) {
+        errors.push({
+          code: "INVALID_ICU",
+          message: `Unbalanced ICU braces: ${depth} unclosed '{'`,
+          path: "text"
+        });
+      }
+      const emptyVarPattern = /\{\s*[,}]/;
+      if (emptyVarPattern.test(text)) {
+        errors.push({
+          code: "INVALID_ICU",
+          message: "ICU variable name is empty or missing",
+          path: "text"
+        });
+      }
+    }
+  };
+
+  // src/browser/storage/localstorage-repository.ts
+  var STORAGE_PREFIX = "lionrapid:";
+  var VERSION_KEY = `${STORAGE_PREFIX}version`;
+  var CURRENT_VERSION = "1";
+  var LocalStorageRepository = class {
+    constructor(config = {}) {
+      __publicField(this, "name", "LocalStorageRepository");
+      __publicField(this, "type", "memory");
+      __publicField(this, "config");
+      __publicField(this, "available");
+      __publicField(this, "prefix");
+      __publicField(this, "defaultTTL");
+      __publicField(this, "maxSize");
+      this.config = {
+        enabled: config.enabled ?? true,
+        priority: config.priority ?? 0,
+        options: {
+          prefix: config.options?.prefix ?? STORAGE_PREFIX,
+          ttl: config.options?.ttl ?? 24 * 60 * 60 * 1e3,
+          maxSize: config.options?.maxSize ?? 500,
+          ...config.options
+        }
+      };
+      this.prefix = this.config.options?.prefix ?? STORAGE_PREFIX;
+      this.defaultTTL = this.config.options?.ttl ?? 24 * 60 * 60 * 1e3;
+      this.maxSize = this.config.options?.maxSize ?? 500;
+      this.available = this.checkAvailability();
+      if (this.available) {
+        this.migrateIfNeeded();
+      }
+    }
+    checkAvailability() {
+      if (typeof window === "undefined") {
+        return false;
+      }
+      try {
+        const testKey = `${this.prefix}__test__`;
+        window.localStorage.setItem(testKey, "test");
+        window.localStorage.removeItem(testKey);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    migrateIfNeeded() {
+      try {
+        const storedVersion = window.localStorage.getItem(VERSION_KEY);
+        if (storedVersion !== CURRENT_VERSION) {
+          this.clear();
+          window.localStorage.setItem(VERSION_KEY, CURRENT_VERSION);
+        }
+      } catch {
+      }
+    }
+    get(key) {
+      if (!this.available) return null;
+      try {
+        const fullKey = this.prefix + key;
+        const itemStr = window.localStorage.getItem(fullKey);
+        if (!itemStr) return null;
+        const item = JSON.parse(itemStr);
+        if (item.expiry !== null && Date.now() > item.expiry) {
+          window.localStorage.removeItem(fullKey);
+          return null;
+        }
+        return item.value;
+      } catch {
+        return null;
+      }
+    }
+    set(key, value) {
+      if (!this.available) return;
+      const fullKey = this.prefix + key;
+      const item = {
+        value,
+        expiry: this.defaultTTL ? Date.now() + this.defaultTTL : null,
+        timestamp: Date.now()
+      };
+      try {
+        const entryCount = this.getEntryCount();
+        if (entryCount >= this.maxSize) {
+          this.evictOldest();
+        }
+        window.localStorage.setItem(fullKey, JSON.stringify(item));
+      } catch (error) {
+        if (this.isQuotaError(error)) {
+          this.evictOldest();
+          try {
+            window.localStorage.setItem(fullKey, JSON.stringify(item));
+          } catch {
+          }
+        }
+      }
+    }
+    remove(key) {
+      if (!this.available) return;
+      try {
+        window.localStorage.removeItem(this.prefix + key);
+      } catch {
+      }
+    }
+    clear() {
+      if (!this.available) return;
+      try {
+        const keysToRemove = [];
+        for (let i = 0; i < window.localStorage.length; i++) {
+          const key = window.localStorage.key(i);
+          if (key?.startsWith(this.prefix) && key !== VERSION_KEY) {
+            keysToRemove.push(key);
+          }
+        }
+        keysToRemove.forEach((k) => window.localStorage.removeItem(k));
+      } catch {
+      }
+    }
+    clearNamespace(locale, namespace) {
+      if (!this.available) return;
+      const namespaceCacheKey = `@${locale}:${namespace}`;
+      const keyPrefix = `${locale}:${namespace}:`;
+      try {
+        const keysToRemove = [];
+        for (let i = 0; i < window.localStorage.length; i++) {
+          const key = window.localStorage.key(i);
+          if (!key?.startsWith(this.prefix)) continue;
+          const innerKey = key.slice(this.prefix.length);
+          if (innerKey === namespaceCacheKey || innerKey.startsWith(keyPrefix)) {
+            keysToRemove.push(key);
+          }
+        }
+        keysToRemove.forEach((k) => window.localStorage.removeItem(k));
+      } catch {
+      }
+    }
+    getNamespace(locale, namespace) {
+      const namespaceCacheKey = `@${locale}:${namespace}`;
+      const value = this.get(namespaceCacheKey);
+      if (!value) return null;
+      try {
+        return JSON.parse(value);
+      } catch {
+        this.remove(namespaceCacheKey);
+        return null;
+      }
+    }
+    setNamespace(locale, namespace, translations) {
+      const namespaceCacheKey = `@${locale}:${namespace}`;
+      this.set(namespaceCacheKey, JSON.stringify(translations));
+    }
+    getEntries() {
+      const entries = {};
+      if (!this.available) return entries;
+      try {
+        for (let i = 0; i < window.localStorage.length; i++) {
+          const fullKey = window.localStorage.key(i);
+          if (!fullKey?.startsWith(this.prefix) || fullKey === VERSION_KEY) {
+            continue;
+          }
+          const key = fullKey.slice(this.prefix.length);
+          const value = this.get(key);
+          if (value !== null) {
+            entries[key] = value;
+          }
+        }
+      } catch {
+      }
+      return entries;
+    }
+    getConfig() {
+      return this.config;
+    }
+    isAvailable() {
+      return this.available;
+    }
+    getEntryCount() {
+      if (!this.available) return 0;
+      let count = 0;
+      try {
+        for (let i = 0; i < window.localStorage.length; i++) {
+          const key = window.localStorage.key(i);
+          if (key?.startsWith(this.prefix) && key !== VERSION_KEY) {
+            count++;
+          }
+        }
+      } catch {
+      }
+      return count;
+    }
+    isQuotaError(error) {
+      if (error instanceof DOMException) {
+        return error.name === "QuotaExceededError" || error.name === "NS_ERROR_DOM_QUOTA_REACHED";
+      }
+      return false;
+    }
+    evictOldest() {
+      if (!this.available) return;
+      try {
+        const entries = [];
+        for (let i = 0; i < window.localStorage.length; i++) {
+          const fullKey = window.localStorage.key(i);
+          if (!fullKey?.startsWith(this.prefix) || fullKey === VERSION_KEY) {
+            continue;
+          }
+          try {
+            const itemStr = window.localStorage.getItem(fullKey);
+            if (itemStr) {
+              const item = JSON.parse(itemStr);
+              entries.push({ key: fullKey, timestamp: item.timestamp });
+            }
+          } catch {
+            window.localStorage.removeItem(fullKey);
+          }
+        }
+        entries.sort((a, b) => a.timestamp - b.timestamp);
+        const removeCount = Math.max(1, Math.floor(entries.length * 0.25));
+        for (let i = 0; i < removeCount && i < entries.length; i++) {
+          window.localStorage.removeItem(entries[i].key);
+        }
+      } catch {
+      }
+    }
+    getCacheStats() {
+      const size = this.getEntryCount();
+      const usage = this.maxSize > 0 ? `${Math.round(size / this.maxSize * 100)}%` : "0%";
+      return {
+        size,
+        maxSize: this.maxSize,
+        usage
+      };
+    }
+  };
+
+  // src/browser/storage/cache-storage-repository.ts
+  var CACHE_NAME = "lionrapid-v1";
+  var CACHE_PREFIX = "lionrapid:";
+  var CacheStorageRepository = class {
+    constructor(config = {}) {
+      __publicField(this, "name", "CacheStorageRepository");
+      __publicField(this, "type", "storage");
+      __publicField(this, "config");
+      __publicField(this, "cacheName");
+      __publicField(this, "defaultTTL");
+      __publicField(this, "available");
+      this.config = {
+        enabled: config.enabled ?? true,
+        priority: config.priority ?? 0,
+        options: {
+          cacheName: config.options?.cacheName ?? CACHE_NAME,
+          ttl: config.options?.ttl ?? 7 * 24 * 60 * 60 * 1e3,
+          ...config.options
+        }
+      };
+      this.cacheName = this.config.options?.cacheName ?? CACHE_NAME;
+      this.defaultTTL = this.config.options?.ttl ?? 7 * 24 * 60 * 60 * 1e3;
+      this.available = this.checkAvailability();
+    }
+    checkAvailability() {
+      return typeof caches !== "undefined";
+    }
+    async get(key) {
+      if (!this.available) {
+        throw new TranslationNotFoundError(key);
+      }
+      try {
+        const cache = await caches.open(this.cacheName);
+        const response = await cache.match(CACHE_PREFIX + key);
+        if (!response) {
+          throw new TranslationNotFoundError(key);
+        }
+        const data = await response.json();
+        if (data.expiry !== null && Date.now() > data.expiry) {
+          await cache.delete(CACHE_PREFIX + key);
+          throw new TranslationNotFoundError(key);
+        }
+        return data.value;
+      } catch (error) {
+        if (error instanceof TranslationNotFoundError) {
+          throw error;
+        }
+        throw new TranslationNotFoundError(key);
+      }
+    }
+    async set(key, value) {
+      if (!this.available) return;
+      try {
+        const cache = await caches.open(this.cacheName);
+        const data = {
+          value,
+          expiry: this.defaultTTL ? Date.now() + this.defaultTTL : null,
+          timestamp: Date.now()
+        };
+        await cache.put(
+          CACHE_PREFIX + key,
+          new Response(JSON.stringify(data), {
+            headers: { "Content-Type": "application/json" }
+          })
+        );
+      } catch {
+      }
+    }
+    async remove(key) {
+      if (!this.available) return;
+      try {
+        const cache = await caches.open(this.cacheName);
+        await cache.delete(CACHE_PREFIX + key);
+      } catch {
+      }
+    }
+    async clear() {
+      if (!this.available) return;
+      try {
+        const cache = await caches.open(this.cacheName);
+        const keys = await cache.keys();
+        await Promise.all(
+          keys.filter((request) => request.url.includes(CACHE_PREFIX)).map((request) => cache.delete(request))
+        );
+      } catch {
+      }
+    }
+    async clearNamespace(locale, namespace) {
+      if (!this.available) return;
+      const namespaceCacheKey = `@${locale}:${namespace}`;
+      const keyPrefix = `${locale}:${namespace}:`;
+      try {
+        const cache = await caches.open(this.cacheName);
+        const keys = await cache.keys();
+        await Promise.all(
+          keys.filter((request) => {
+            const url = request.url;
+            const key = url.includes(CACHE_PREFIX) ? url.substring(url.indexOf(CACHE_PREFIX) + CACHE_PREFIX.length) : "";
+            return key === namespaceCacheKey || key.startsWith(keyPrefix);
+          }).map((request) => cache.delete(request))
+        );
+      } catch {
+      }
+    }
+    async getNamespace(locale, namespace) {
+      const namespaceCacheKey = `@${locale}:${namespace}`;
+      const value = await this.get(namespaceCacheKey);
+      try {
+        return JSON.parse(value);
+      } catch {
+        await this.remove(namespaceCacheKey);
+        throw new TranslationNotFoundError(namespaceCacheKey);
+      }
+    }
+    async setNamespace(locale, namespace, translations) {
+      const namespaceCacheKey = `@${locale}:${namespace}`;
+      await this.set(namespaceCacheKey, JSON.stringify(translations));
+    }
+    getConfig() {
+      return this.config;
+    }
+    isAvailable() {
+      return this.available;
+    }
+    async getEntries() {
+      const entries = {};
+      if (!this.available) return entries;
+      try {
+        const cache = await caches.open(this.cacheName);
+        const keys = await cache.keys();
+        for (const request of keys) {
+          const url = request.url;
+          if (!url.includes(CACHE_PREFIX)) continue;
+          const key = url.substring(
+            url.indexOf(CACHE_PREFIX) + CACHE_PREFIX.length
+          );
+          try {
+            const value = await this.get(key);
+            entries[key] = value;
+          } catch {
+          }
+        }
+      } catch {
+      }
+      return entries;
+    }
+    async getCacheStats() {
+      if (!this.available) {
+        return { size: 0, cacheName: this.cacheName };
+      }
+      try {
+        const cache = await caches.open(this.cacheName);
+        const keys = await cache.keys();
+        const size = keys.filter((r) => r.url.includes(CACHE_PREFIX)).length;
+        return { size, cacheName: this.cacheName };
+      } catch {
+        return { size: 0, cacheName: this.cacheName };
+      }
+    }
+  };
+
+  // src/index.ts
+  var VERSION = "1.0.0";
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=lionrapid.iife.dev.js.map