@lionrapid/core 0.1.0

package/dist/browser/lionrapid.esm.js

@@ -0,0 +1,4786 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// 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 = true;
+var IS_DEVELOPMENT = false;
+var IS_CI = false;
+var LIONRAPID_DEV = false;
+var PERFORMANCE_TRACKING = false;
+var LOG_LEVEL_ENV = IS_PRODUCTION ? "ERROR" : "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", false);
+  }
+  /**
+   * 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" && false) {
+    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";
+export {
+  CacheManager,
+  CacheStorageRepository,
+  Colors,
+  ContentValidator,
+  DefaultStyleMapper,
+  EventEmitter,
+  HTMLSerializer,
+  HandlerChain,
+  LionRapidBuilder,
+  LionRapidCore,
+  LocalStorageRepository,
+  LogLevel,
+  Logger,
+  MarkupParser,
+  MemoryRepository,
+  MissingTranslationQueue,
+  NetworkError,
+  NetworkRepository,
+  ServerError,
+  TranslationError,
+  TranslationLockedError,
+  TranslationNotFoundError,
+  VERSION,
+  createPackageLogger,
+  isClientError,
+  isRetryableError,
+  isTranslationError,
+  logger,
+  measure,
+  parseKeyPath,
+  prepareTranslationRequest,
+  resolveNestedKey
+};
+//# sourceMappingURL=lionrapid.esm.js.map