@nestjs-redisx/cache 1.0.0

package/dist/index.js

@@ -0,0 +1,4199 @@
+'use strict';
+
+var core$1 = require('@nestjs/core');
+var common = require('@nestjs/common');
+require('reflect-metadata');
+var core = require('@nestjs-redisx/core');
+var crypto = require('crypto');
+var events = require('events');
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/shared/constants/index.ts
+var CACHE_PLUGIN_OPTIONS = /* @__PURE__ */ Symbol.for("CACHE_PLUGIN_OPTIONS");
+var CACHE_SERVICE = /* @__PURE__ */ Symbol.for("CACHE_SERVICE");
+var L1_CACHE_STORE = /* @__PURE__ */ Symbol.for("L1_CACHE_STORE");
+var L2_CACHE_STORE = /* @__PURE__ */ Symbol.for("L2_CACHE_STORE");
+var STAMPEDE_PROTECTION = /* @__PURE__ */ Symbol.for("STAMPEDE_PROTECTION");
+var TAG_INDEX = /* @__PURE__ */ Symbol.for("TAG_INDEX");
+var SWR_MANAGER = /* @__PURE__ */ Symbol.for("SWR_MANAGER");
+var SERIALIZER = /* @__PURE__ */ Symbol.for("SERIALIZER");
+var INVALIDATION_REGISTRY = /* @__PURE__ */ Symbol.for("INVALIDATION_REGISTRY");
+var EVENT_INVALIDATION_SERVICE = /* @__PURE__ */ Symbol.for("EVENT_INVALIDATION_SERVICE");
+var LUA_SCRIPT_LOADER = /* @__PURE__ */ Symbol.for("LUA_SCRIPT_LOADER");
+var INVALIDATION_RULES_INIT = /* @__PURE__ */ Symbol.for("INVALIDATION_RULES_INIT");
+var AMQP_CONNECTION = /* @__PURE__ */ Symbol.for("AMQP_CONNECTION");
+var CACHE_OPTIONS_KEY = "cache:options";
+var INVALIDATE_TAGS_KEY = "cache:invalidate:tags";
+var DEFAULT_CACHE_CONFIG = {
+  l1: {
+    enabled: true,
+    maxSize: 1e3,
+    ttl: 60,
+    evictionPolicy: "lru"
+  },
+  l2: {
+    enabled: true,
+    defaultTtl: 3600,
+    maxTtl: 86400,
+    keyPrefix: "cache:",
+    clientName: "default"
+  },
+  stampede: {
+    enabled: true,
+    lockTimeout: 5e3,
+    waitTimeout: 1e4,
+    fallback: "load"
+  },
+  swr: {
+    enabled: false,
+    defaultStaleTime: 60
+  },
+  tags: {
+    enabled: true,
+    indexPrefix: "_tag:",
+    maxTagsPerKey: 10
+  },
+  warmup: {
+    enabled: false,
+    concurrency: 10
+  },
+  keys: {
+    maxLength: 1024,
+    version: "v1",
+    separator: ":"
+  },
+  invalidation: {
+    enabled: true,
+    source: "internal",
+    deduplicationTtl: 60
+  }
+};
+
+// src/cache/api/decorators/cached.decorator.ts
+var logger = new common.Logger("Cached");
+var globalCacheServiceGetter = null;
+var globalPluginOptions = null;
+function registerCacheServiceGetter(getter) {
+  globalCacheServiceGetter = getter;
+}
+function registerCachePluginOptions(options) {
+  globalPluginOptions = options;
+}
+function getCacheService() {
+  return globalCacheServiceGetter ? globalCacheServiceGetter() : null;
+}
+function Cached(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      if (!globalCacheServiceGetter) {
+        logger.warn(`@Cached: CacheService not yet available, executing method without cache`);
+        return originalMethod.apply(this, args);
+      }
+      const cacheService = globalCacheServiceGetter();
+      if (!cacheService) {
+        logger.warn(`@Cached: CacheService getter returned null, executing method without cache`);
+        return originalMethod.apply(this, args);
+      }
+      if (options.condition && !options.condition(...args)) {
+        return originalMethod.apply(this, args);
+      }
+      const key = buildCacheKey(this, propertyKey.toString(), args, options);
+      try {
+        const cached = await cacheService.get(key);
+        if (cached !== null) {
+          return cached;
+        }
+      } catch (error) {
+        logger.error(`@Cached: Cache get error for key ${key}:`, error);
+      }
+      const result = await originalMethod.apply(this, args);
+      if (options.unless?.(result, ...args)) {
+        return result;
+      }
+      await cacheResult(cacheService, key, result, options, args);
+      return result;
+    };
+    Object.defineProperty(descriptor.value, "name", {
+      value: originalMethod.name,
+      writable: false
+    });
+    Reflect.defineMetadata(CACHE_OPTIONS_KEY, options, descriptor.value);
+    return descriptor;
+  };
+}
+function buildCacheKey(instance, methodName, args, options) {
+  const className = instance.constructor.name;
+  let baseKey;
+  if (options.key) {
+    baseKey = interpolateKey(options.key, args);
+  } else {
+    const argKeys = args.map((arg) => serializeArg(arg)).join(":");
+    baseKey = `${className}:${methodName}:${argKeys}`;
+  }
+  return enrichWithContext(baseKey, options);
+}
+function enrichWithContext(key, options) {
+  if (options.skipContext) return key;
+  const pluginOpts = globalPluginOptions;
+  if (!pluginOpts?.contextProvider) return key;
+  const separator = pluginOpts.keys?.separator ?? ":";
+  const marker = `${separator}_ctx_${separator}`;
+  const contextMap = /* @__PURE__ */ new Map();
+  const contextKeys = options.contextKeys ?? pluginOpts.contextKeys ?? [];
+  for (const ctxKey of contextKeys) {
+    const value = pluginOpts.contextProvider.get(ctxKey);
+    if (value !== void 0 && value !== null) {
+      contextMap.set(ctxKey, String(value));
+    }
+  }
+  if (options.varyBy) {
+    for (const name of options.varyBy) {
+      if (!contextMap.has(name)) {
+        const value = pluginOpts.contextProvider.get(name);
+        if (value !== void 0 && value !== null) {
+          contextMap.set(name, String(value));
+        }
+      }
+    }
+  }
+  if (contextMap.size === 0) return key;
+  const sortedEntries = [...contextMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+  const suffix = sortedEntries.map(([k, v]) => `${sanitizeForKey(k)}.${sanitizeForKey(v)}`).join(separator);
+  return `${key}${marker}${suffix}`;
+}
+function sanitizeForKey(value) {
+  return String(value).replace(/[^a-zA-Z0-9\-_]/g, "_");
+}
+function interpolateKey(template, args) {
+  return template.replace(/\{(\d+)\}/g, (match, index) => {
+    const argIndex = parseInt(index, 10);
+    if (argIndex < args.length) {
+      return serializeArg(args[argIndex]);
+    }
+    return match;
+  });
+}
+function serializeArg(arg) {
+  if (arg === null || arg === void 0) {
+    return "null";
+  }
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
+    return String(arg);
+  }
+  if (typeof arg === "object") {
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return "object";
+    }
+  }
+  return "unknown";
+}
+async function cacheResult(cacheService, key, value, options, args) {
+  try {
+    const tags = typeof options.tags === "function" ? options.tags(...args) : options.tags;
+    if (options.swr?.enabled) {
+      await cacheService.getOrSet(
+        key,
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async () => value,
+        {
+          ttl: options.ttl,
+          tags,
+          strategy: options.strategy,
+          swr: options.swr
+        }
+      );
+    } else {
+      await cacheService.set(key, value, {
+        ttl: options.ttl,
+        tags,
+        strategy: options.strategy
+      });
+    }
+  } catch (error) {
+    logger.error(`@Cached: Failed to cache result for key ${key}:`, error);
+  }
+}
+
+// src/invalidation/infrastructure/decorators/invalidate-on.decorator.ts
+var INVALIDATE_ON_OPTIONS = /* @__PURE__ */ Symbol.for("INVALIDATE_ON_OPTIONS");
+var globalEventInvalidationServiceGetter = null;
+function registerEventInvalidationServiceGetter(getter) {
+  globalEventInvalidationServiceGetter = getter;
+}
+function getEventInvalidationService() {
+  return globalEventInvalidationServiceGetter ? globalEventInvalidationServiceGetter() : null;
+}
+function InvalidateOn(options) {
+  return (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const result = await originalMethod.apply(this, args);
+      const cacheService = getCacheService();
+      if (cacheService) {
+        try {
+          if (options.condition && !options.condition(result, args)) {
+            return result;
+          }
+          const tags = resolveTags(options.tags, result, args);
+          const keys = resolveKeys(options.keys, result, args);
+          if (tags.length > 0) {
+            await cacheService.invalidateTags(tags);
+          }
+          if (keys.length > 0) {
+            await cacheService.deleteMany(keys);
+          }
+          if (options.publish) {
+            const eventInvalidationService = getEventInvalidationService();
+            if (eventInvalidationService) {
+              for (const event of options.events) {
+                await eventInvalidationService.emit(event, {
+                  result,
+                  args,
+                  tags,
+                  keys,
+                  timestamp: Date.now()
+                });
+              }
+            }
+          }
+        } catch (error) {
+          console.error("@InvalidateOn: Invalidation failed:", error);
+        }
+      }
+      return result;
+    };
+    Object.defineProperty(descriptor.value, "name", {
+      value: originalMethod.name,
+      writable: false
+    });
+    Reflect.defineMetadata(INVALIDATE_ON_OPTIONS, options, descriptor.value);
+    return descriptor;
+  };
+}
+function resolveTags(tags, result, args) {
+  if (!tags) {
+    return [];
+  }
+  if (typeof tags === "function") {
+    return tags(result, args);
+  }
+  return tags;
+}
+function resolveKeys(keys, result, args) {
+  if (!keys) {
+    return [];
+  }
+  if (typeof keys === "function") {
+    return keys(result, args);
+  }
+  return keys;
+}
+
+// src/cache/application/services/cache-decorator-initializer.service.ts
+var CacheDecoratorInitializerService = class {
+  constructor(moduleRef, cacheService, pluginOptions, eventInvalidationService) {
+    this.moduleRef = moduleRef;
+    this.cacheService = cacheService;
+    this.pluginOptions = pluginOptions;
+    this.eventInvalidationService = eventInvalidationService;
+  }
+  logger = new common.Logger(CacheDecoratorInitializerService.name);
+  /**
+   * Called after all modules are initialized.
+   * Registers cache service getter and plugin options for @Cached decorator.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async onModuleInit() {
+    this.logger.debug("Registering CacheService getter for @Cached decorator");
+    registerCacheServiceGetter(() => this.cacheService);
+    registerCachePluginOptions(this.pluginOptions);
+    this.logger.log("@Cached decorator initialized and ready to use");
+    if (this.eventInvalidationService) {
+      this.logger.debug("Registering EventInvalidationService getter for @InvalidateOn decorator");
+      registerEventInvalidationServiceGetter(() => this.eventInvalidationService);
+      this.logger.log("@InvalidateOn decorator event publishing initialized");
+    }
+  }
+};
+CacheDecoratorInitializerService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(1, common.Inject(CACHE_SERVICE)),
+  __decorateParam(2, common.Inject(CACHE_PLUGIN_OPTIONS)),
+  __decorateParam(3, common.Optional()),
+  __decorateParam(3, common.Inject(EVENT_INVALIDATION_SERVICE))
+], CacheDecoratorInitializerService);
+var CacheError = class extends core.RedisXError {
+  constructor(message, code = core.ErrorCode.OPERATION_FAILED, cause) {
+    super(message, code, cause);
+    this.name = "CacheError";
+  }
+};
+var CacheKeyError = class extends CacheError {
+  constructor(key, message) {
+    super(`Invalid cache key "${key}": ${message}`, core.ErrorCode.CACHE_KEY_INVALID);
+    this.key = key;
+    this.name = "CacheKeyError";
+  }
+};
+var SerializationError = class extends CacheError {
+  constructor(message, cause) {
+    super(`Serialization error: ${message}`, core.ErrorCode.SERIALIZATION_FAILED, cause);
+    this.name = "SerializationError";
+  }
+};
+var LoaderError = class extends CacheError {
+  constructor(key, cause) {
+    super(`Loader failed for key "${key}": ${cause.message}`, core.ErrorCode.OPERATION_FAILED, cause);
+    this.key = key;
+    this.name = "LoaderError";
+  }
+};
+var StampedeError = class extends CacheError {
+  constructor(key, timeout) {
+    super(`Stampede protection timeout for key "${key}" after ${timeout}ms`, core.ErrorCode.OPERATION_TIMEOUT);
+    this.key = key;
+    this.timeout = timeout;
+    this.name = "StampedeError";
+  }
+};
+var TagInvalidationError = class extends CacheError {
+  constructor(tag, message, cause) {
+    super(`Tag invalidation failed for "${tag}": ${message}`, core.ErrorCode.OPERATION_FAILED, cause);
+    this.tag = tag;
+    this.name = "TagInvalidationError";
+  }
+};
+
+// src/cache/domain/value-objects/cache-entry.vo.ts
+var CacheEntry = class _CacheEntry {
+  constructor(value, cachedAt, ttl, tags) {
+    this.value = value;
+    this.cachedAt = cachedAt;
+    this.ttl = ttl;
+    this.tags = tags;
+  }
+  /**
+   * Creates a cache entry.
+   *
+   * @param value - Value to cache
+   * @param ttl - TTL in seconds
+   * @param tags - Optional tags
+   * @returns CacheEntry instance
+   */
+  static create(value, ttl, tags) {
+    return new _CacheEntry(value, Date.now(), ttl, tags);
+  }
+  /**
+   * Checks if entry is expired.
+   *
+   * @returns true if expired, false otherwise
+   */
+  isExpired() {
+    const expiresAt = this.cachedAt + this.ttl * 1e3;
+    return Date.now() > expiresAt;
+  }
+  /**
+   * Gets time until expiration in milliseconds.
+   *
+   * @returns Milliseconds until expiration (0 if expired)
+   */
+  getTimeToLive() {
+    const expiresAt = this.cachedAt + this.ttl * 1e3;
+    const remaining = expiresAt - Date.now();
+    return Math.max(0, remaining);
+  }
+  /**
+   * Gets age of entry in milliseconds.
+   *
+   * @returns Age in milliseconds
+   */
+  getAge() {
+    return Date.now() - this.cachedAt;
+  }
+  /**
+   * Checks if entry has a specific tag.
+   *
+   * @param tag - Tag to check
+   * @returns true if entry has the tag
+   */
+  hasTag(tag) {
+    return this.tags?.includes(tag) ?? false;
+  }
+  /**
+   * Serializes entry to JSON.
+   *
+   * @returns JSON representation
+   */
+  toJSON() {
+    return {
+      value: this.value,
+      cachedAt: this.cachedAt,
+      ttl: this.ttl,
+      tags: this.tags
+    };
+  }
+  /**
+   * Deserializes entry from JSON.
+   *
+   * @param json - JSON representation
+   * @returns CacheEntry instance
+   */
+  static fromJSON(json) {
+    return new _CacheEntry(json.value, json.cachedAt, json.ttl, json.tags);
+  }
+};
+
+// src/cache/domain/value-objects/cache-key.vo.ts
+var DEFAULT_OPTIONS = {
+  maxLength: 512,
+  prefix: "",
+  version: "",
+  separator: ":"
+};
+var CacheKey = class _CacheKey {
+  constructor(rawKey, options) {
+    this.rawKey = rawKey;
+    this.options = options;
+  }
+  /**
+   * Creates a validated cache key.
+   *
+   * @param key - Raw key
+   * @param options - Key options
+   * @returns CacheKey instance
+   * @throws CacheKeyError if validation fails
+   */
+  static create(key, options = {}) {
+    const opts = {
+      ...DEFAULT_OPTIONS,
+      ...options
+    };
+    const normalizedKey = key.trim();
+    if (!normalizedKey || normalizedKey.length === 0) {
+      throw new CacheKeyError(key, "Key cannot be empty");
+    }
+    if (/\s/.test(normalizedKey)) {
+      throw new CacheKeyError(key, "Key cannot contain whitespace");
+    }
+    if (!/^[a-zA-Z0-9\-_:.]+$/.test(normalizedKey)) {
+      throw new CacheKeyError(key, "Invalid characters in key. Only alphanumeric, hyphens, underscores, colons, and dots allowed");
+    }
+    const fullKey = opts.prefix + opts.version + (opts.version ? opts.separator : "") + normalizedKey;
+    if (fullKey.length > opts.maxLength) {
+      throw new CacheKeyError(normalizedKey, `Key exceeds maximum length (${fullKey.length} > ${opts.maxLength})`);
+    }
+    return new _CacheKey(normalizedKey, opts);
+  }
+  /**
+   * Returns the full cache key with prefix and version.
+   */
+  toString() {
+    return this.options.prefix + this.options.version + (this.options.version ? this.options.separator : "") + this.rawKey;
+  }
+  /**
+   * Returns the raw key without prefix/version.
+   */
+  getRaw() {
+    return this.rawKey;
+  }
+  /**
+   * Returns the prefix.
+   */
+  getPrefix() {
+    return this.options.prefix;
+  }
+  /**
+   * Returns the version.
+   */
+  getVersion() {
+    return this.options.version;
+  }
+  /**
+   * Checks equality with another CacheKey.
+   */
+  equals(other) {
+    return this.toString() === other.toString();
+  }
+};
+var DEFAULT_MAX_LENGTH = 128;
+var Tag = class _Tag {
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * Creates a validated tag.
+   *
+   * @param value - Tag value
+   * @param maxLength - Maximum tag length (default: 128)
+   * @returns Tag instance
+   * @throws CacheError if validation fails
+   *
+   * @example
+   * ```typescript
+   * const tag = Tag.create('users');
+   * const productTag = Tag.create('product:123');
+   * ```
+   */
+  static create(value, maxLength = DEFAULT_MAX_LENGTH) {
+    if (!value || value.length === 0) {
+      throw new CacheError("Tag cannot be empty", core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+      throw new CacheError("Tag cannot be empty after normalization", core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    if (/\s/.test(normalized)) {
+      throw new CacheError("Tag cannot contain whitespace", core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    if (!/^[a-z0-9\-_:.]+$/.test(normalized)) {
+      throw new CacheError("Invalid tag characters. Only lowercase alphanumeric, hyphens, underscores, colons, and dots allowed", core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    if (normalized.length > maxLength) {
+      throw new CacheError(`Tag exceeds maximum length (${normalized.length} > ${maxLength})`, core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    return new _Tag(normalized);
+  }
+  /**
+   * Returns the tag value.
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Returns the raw tag value.
+   */
+  getRaw() {
+    return this.value;
+  }
+  /**
+   * Checks equality with another tag.
+   */
+  equals(other) {
+    return this.value === other.value;
+  }
+};
+var DEFAULT_MAX_TAGS = 10;
+var Tags = class _Tags {
+  constructor(tags) {
+    this.tags = tags;
+  }
+  /**
+   * Creates a validated tags collection.
+   *
+   * @param values - Array of tag values
+   * @param maxTags - Maximum number of tags (default: 10)
+   * @returns Tags instance
+   * @throws CacheError if validation fails
+   *
+   * @example
+   * ```typescript
+   * const tags = Tags.create(['users', 'product:123']);
+   * const singleTag = Tags.create(['cache']);
+   * ```
+   */
+  static create(values, maxTags = DEFAULT_MAX_TAGS) {
+    if (values.length > maxTags) {
+      throw new CacheError(`Too many tags (${values.length} > ${maxTags})`, core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    const tagObjects = values.map((v) => Tag.create(v));
+    const uniqueValues = Array.from(new Set(tagObjects.map((t) => t.toString())));
+    const uniqueTags = uniqueValues.map((v) => Tag.create(v));
+    return new _Tags(uniqueTags);
+  }
+  /**
+   * Creates empty tags collection.
+   */
+  static empty() {
+    return new _Tags([]);
+  }
+  /**
+   * Returns array of tag strings.
+   */
+  toStrings() {
+    return this.tags.map((t) => t.toString());
+  }
+  /**
+   * Returns array of Tag objects.
+   */
+  toArray() {
+    return [...this.tags];
+  }
+  /**
+   * Returns number of tags.
+   */
+  size() {
+    return this.tags.length;
+  }
+  /**
+   * Checks if collection contains a specific tag.
+   */
+  has(tag) {
+    return this.tags.some((t) => t.equals(tag));
+  }
+  /**
+   * Checks if collection is empty.
+   */
+  isEmpty() {
+    return this.tags.length === 0;
+  }
+  /**
+   * Iterates over tags.
+   */
+  forEach(callback) {
+    this.tags.forEach(callback);
+  }
+  /**
+   * Maps over tags.
+   */
+  map(callback) {
+    return this.tags.map(callback);
+  }
+};
+var DEFAULT_MAX_TTL_SECONDS = 86400;
+var TTL = class _TTL {
+  constructor(seconds) {
+    this.seconds = seconds;
+  }
+  /**
+   * Creates a TTL value object.
+   *
+   * @param seconds - TTL in seconds
+   * @param maxTtl - Maximum allowed TTL
+   * @returns TTL instance
+   * @throws CacheError if validation fails
+   */
+  static create(seconds, maxTtl = DEFAULT_MAX_TTL_SECONDS) {
+    if (seconds <= 0) {
+      throw new CacheError(`TTL must be positive (got ${seconds})`, core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    if (seconds > maxTtl) {
+      throw new CacheError(`TTL exceeds maximum (${seconds} > ${maxTtl})`, core.ErrorCode.CACHE_KEY_INVALID);
+    }
+    const rounded = Math.round(seconds);
+    return new _TTL(rounded);
+  }
+  /**
+   * Creates TTL from milliseconds.
+   *
+   * @param milliseconds - TTL in milliseconds
+   * @param maxTtl - Maximum allowed TTL in seconds
+   * @returns TTL instance
+   */
+  static fromMilliseconds(milliseconds, maxTtl = DEFAULT_MAX_TTL_SECONDS) {
+    return _TTL.create(Math.ceil(milliseconds / 1e3), maxTtl);
+  }
+  /**
+   * Returns TTL in seconds.
+   */
+  toSeconds() {
+    return this.seconds;
+  }
+  /**
+   * Returns TTL in milliseconds.
+   */
+  toMilliseconds() {
+    return this.seconds * 1e3;
+  }
+  /**
+   * Checks if TTL is less than another TTL.
+   */
+  isLessThan(other) {
+    return this.seconds < other.seconds;
+  }
+  /**
+   * Checks if TTL is greater than another TTL.
+   */
+  isGreaterThan(other) {
+    return this.seconds > other.seconds;
+  }
+  /**
+   * Returns the minimum of two TTLs.
+   */
+  static min(a, b) {
+    return a.isLessThan(b) ? a : b;
+  }
+  /**
+   * Returns the maximum of two TTLs.
+   */
+  static max(a, b) {
+    return a.isGreaterThan(b) ? a : b;
+  }
+  /**
+   * Checks equality with another TTL.
+   */
+  equals(other) {
+    return this.seconds === other.seconds;
+  }
+  /**
+   * Returns string representation.
+   */
+  toString() {
+    return `${this.seconds}s`;
+  }
+};
+
+// src/cache/application/services/cache.service.ts
+var METRICS_SERVICE = /* @__PURE__ */ Symbol.for("METRICS_SERVICE");
+var TRACING_SERVICE = /* @__PURE__ */ Symbol.for("TRACING_SERVICE");
+var CacheService = class {
+  constructor(driver, l1Store, l2Store, stampede, tagIndex, swrManager, options, metrics, tracing) {
+    this.driver = driver;
+    this.l1Store = l1Store;
+    this.l2Store = l2Store;
+    this.stampede = stampede;
+    this.tagIndex = tagIndex;
+    this.swrManager = swrManager;
+    this.options = options;
+    this.metrics = metrics;
+    this.tracing = tracing;
+    this.l1Enabled = options.l1?.enabled ?? true;
+    this.l2Enabled = options.l2?.enabled ?? true;
+    this.keyPrefix = options.l2?.keyPrefix ?? "cache:";
+    this.stampedeEnabled = options.stampede?.enabled ?? true;
+    this.swrEnabled = options.swr?.enabled ?? false;
+    this.tagsEnabled = options.tags?.enabled ?? true;
+  }
+  logger = new common.Logger(CacheService.name);
+  l1Enabled;
+  l2Enabled;
+  stampedeEnabled;
+  swrEnabled;
+  tagsEnabled;
+  keyPrefix;
+  async get(key) {
+    const span = this.tracing?.startSpan("cache.get", {
+      kind: "INTERNAL",
+      attributes: { "cache.key": key }
+    });
+    try {
+      const normalizedKey = this.validateAndNormalizeKey(key);
+      const enrichedKey = this.enrichKeyWithContext(normalizedKey);
+      if (this.l1Enabled) {
+        const l1Entry = await this.l1Store.get(enrichedKey);
+        if (l1Entry) {
+          this.logger.debug(`L1 hit for key: ${key}`);
+          this.metrics?.incrementCounter("redisx_cache_hits_total", { layer: "l1" });
+          span?.setAttribute("cache.hit", true);
+          span?.setAttribute("cache.layer", "l1");
+          span?.setStatus("OK");
+          return l1Entry.value;
+        }
+        this.metrics?.incrementCounter("redisx_cache_misses_total", { layer: "l1" });
+      }
+      if (this.l2Enabled) {
+        const l2Entry = await this.l2Store.get(enrichedKey);
+        if (l2Entry) {
+          this.logger.debug(`L2 hit for key: ${key}`);
+          this.metrics?.incrementCounter("redisx_cache_hits_total", { layer: "l2" });
+          span?.setAttribute("cache.hit", true);
+          span?.setAttribute("cache.layer", "l2");
+          span?.setStatus("OK");
+          if (this.l1Enabled) {
+            await this.l1Store.set(enrichedKey, l2Entry, this.options.l1?.ttl);
+          }
+          return l2Entry.value;
+        }
+        this.metrics?.incrementCounter("redisx_cache_misses_total", { layer: "l2" });
+      }
+      span?.setAttribute("cache.hit", false);
+      span?.setStatus("OK");
+      return null;
+    } catch (error) {
+      if (error instanceof CacheKeyError) {
+        this.logger.warn(`Invalid cache key "${key}": ${error.message}`);
+      } else {
+        this.logger.error(`Cache get failed for key ${key}:`, error);
+      }
+      span?.recordException(error);
+      span?.setStatus("ERROR");
+      return null;
+    } finally {
+      span?.end();
+    }
+  }
+  async set(key, value, options = {}) {
+    const span = this.tracing?.startSpan("cache.set", {
+      kind: "INTERNAL",
+      attributes: { "cache.key": key, "cache.ttl": options.ttl }
+    });
+    try {
+      const normalizedKey = this.validateAndNormalizeKey(key);
+      const enrichedKey = this.enrichKeyWithContext(normalizedKey, options.varyBy);
+      const ttlSeconds = options.ttl ?? this.options.l2?.defaultTtl ?? 3600;
+      const maxTtl = this.options.l2?.maxTtl ?? 86400;
+      const ttl = TTL.create(ttlSeconds, maxTtl);
+      const entry = CacheEntry.create(value, ttl.toSeconds());
+      const strategy = options.strategy ?? "l1-l2";
+      span?.setAttribute("cache.strategy", strategy);
+      if (this.l2Enabled && strategy !== "l1-only") {
+        await this.l2Store.set(enrichedKey, entry, ttl.toSeconds());
+      }
+      if (this.l1Enabled && strategy !== "l2-only") {
+        const l1MaxTtl = TTL.create(this.options.l1?.ttl ?? 60, maxTtl);
+        const l1Ttl = TTL.min(ttl, l1MaxTtl);
+        await this.l1Store.set(enrichedKey, entry, l1Ttl.toSeconds());
+      }
+      if (this.tagsEnabled && options.tags && options.tags.length > 0 && strategy !== "l1-only") {
+        const fullKey = `${this.keyPrefix}${enrichedKey}`;
+        await this.tagIndex.addKeyToTags(fullKey, options.tags);
+        span?.setAttribute("cache.tags", options.tags.join(","));
+      }
+      span?.setStatus("OK");
+    } catch (error) {
+      span?.recordException(error);
+      span?.setStatus("ERROR");
+      if (error instanceof CacheKeyError || error instanceof CacheError) {
+        throw error;
+      }
+      throw new CacheError(`Failed to set cache for key "${key}": ${error.message}`, core.ErrorCode.CACHE_SET_FAILED, error);
+    } finally {
+      span?.end();
+    }
+  }
+  async getOrSet(key, loader, options = {}) {
+    const normalizedKey = this.validateAndNormalizeKey(key);
+    const enrichedKey = this.enrichKeyWithContext(normalizedKey, options.varyBy);
+    const swrEnabled = this.swrEnabled && (options.swr?.enabled ?? true);
+    if (swrEnabled) {
+      const swrEntry = await this.l2Store.getSwr(enrichedKey);
+      if (swrEntry) {
+        const isExpired = this.swrManager.isExpired(swrEntry);
+        if (!isExpired) {
+          const isStale = this.swrManager.isStale(swrEntry);
+          if (isStale && this.swrManager.shouldRevalidate(enrichedKey)) {
+            void this.swrManager.scheduleRevalidation(
+              enrichedKey,
+              loader,
+              async (freshValue) => {
+                await this.set(enrichedKey, freshValue, {
+                  ttl: options.ttl,
+                  tags: options.tags,
+                  strategy: options.strategy
+                });
+              },
+              (error) => {
+                this.logger.error(`SWR revalidation failed for key ${enrichedKey}:`, error);
+              }
+            );
+          }
+          return swrEntry.value;
+        }
+      }
+      const value = await this.loadWithStampede(enrichedKey, loader, options);
+      const staleTime = options.swr?.staleTime ?? this.options.swr?.defaultStaleTime ?? 60;
+      const ttl = options.ttl ?? this.options.l2?.defaultTtl ?? 3600;
+      const swrEntryNew = this.swrManager.createSwrEntry(value, ttl, staleTime);
+      await this.l2Store.setSwr(enrichedKey, swrEntryNew);
+      return value;
+    }
+    const cached = await this.get(enrichedKey);
+    if (cached !== null) {
+      return cached;
+    }
+    return this.loadWithStampede(enrichedKey, loader, options);
+  }
+  /**
+   * Loads value with stampede protection if enabled.
+   *
+   * @param key - Normalized cache key
+   * @param loader - Function to load value
+   * @param options - Cache options
+   * @returns Loaded value
+   * @private
+   */
+  async loadWithStampede(key, loader, options) {
+    if (this.stampedeEnabled && !options.skipStampede) {
+      const result = await this.stampede.protect(key, loader);
+      if (result.cached) {
+        this.metrics?.incrementCounter("redisx_cache_stampede_prevented_total");
+        return result.value;
+      }
+      await this.set(key, result.value, {
+        ttl: options.ttl,
+        tags: options.tags,
+        strategy: options.strategy
+      });
+      return result.value;
+    }
+    const value = await loader();
+    await this.set(key, value, {
+      ttl: options.ttl,
+      tags: options.tags,
+      strategy: options.strategy
+    });
+    return value;
+  }
+  async delete(key) {
+    try {
+      const normalizedKey = this.validateAndNormalizeKey(key);
+      const enrichedKey = this.enrichKeyWithContext(normalizedKey);
+      let deleted = false;
+      if (this.l1Enabled) {
+        const l1Deleted = await this.l1Store.delete(enrichedKey);
+        deleted = deleted || l1Deleted;
+      }
+      if (this.l2Enabled) {
+        const l2Deleted = await this.l2Store.delete(enrichedKey);
+        deleted = deleted || l2Deleted;
+      }
+      return deleted;
+    } catch (error) {
+      if (error instanceof CacheKeyError) {
+        throw error;
+      }
+      throw new CacheError(`Failed to delete cache for key "${key}": ${error.message}`, core.ErrorCode.CACHE_DELETE_FAILED, error);
+    }
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0) {
+      return 0;
+    }
+    try {
+      const normalizedKeys = keys.map((key) => {
+        try {
+          const normalized = this.validateAndNormalizeKey(key);
+          return this.enrichKeyWithContext(normalized);
+        } catch (error) {
+          if (error instanceof CacheKeyError) {
+            this.logger.warn(`Invalid key in deleteMany "${key}": ${error.message}`);
+          }
+          return null;
+        }
+      }).filter((k) => k !== null);
+      if (normalizedKeys.length === 0) {
+        return 0;
+      }
+      let deletedCount = 0;
+      if (this.l1Enabled) {
+        for (const key of normalizedKeys) {
+          const deleted = await this.l1Store.delete(key);
+          if (deleted) deletedCount++;
+        }
+      }
+      if (this.l2Enabled && normalizedKeys.length > 0) {
+        const fullKeys = normalizedKeys.map((k) => `${this.keyPrefix}${k}`);
+        const pipeline = this.driver.pipeline();
+        for (const fullKey of fullKeys) {
+          pipeline.del(fullKey);
+        }
+        const results = await pipeline.exec();
+        let l2Count = 0;
+        if (results) {
+          for (const [error, result] of results) {
+            if (!error && typeof result === "number" && result > 0) {
+              l2Count++;
+            }
+          }
+        }
+        deletedCount = Math.max(deletedCount, l2Count);
+      }
+      return deletedCount;
+    } catch (error) {
+      throw new CacheError(`Failed to delete multiple keys: ${error.message}`, core.ErrorCode.CACHE_DELETE_FAILED, error);
+    }
+  }
+  async clear() {
+    try {
+      if (this.l1Enabled) {
+        await this.l1Store.clear();
+      }
+      if (this.l2Enabled) {
+        await this.l2Store.clear();
+      }
+      if (this.tagsEnabled) {
+        await this.tagIndex.clearAllTags();
+      }
+    } catch (error) {
+      throw new CacheError(`Failed to clear cache: ${error.message}`, core.ErrorCode.CACHE_CLEAR_FAILED, error);
+    }
+  }
+  async has(key) {
+    try {
+      const normalizedKey = this.validateAndNormalizeKey(key);
+      const enrichedKey = this.enrichKeyWithContext(normalizedKey);
+      if (this.l1Enabled) {
+        const l1Has = await this.l1Store.has(enrichedKey);
+        if (l1Has) return true;
+      }
+      if (this.l2Enabled) {
+        return await this.l2Store.has(enrichedKey);
+      }
+      return false;
+    } catch (error) {
+      if (error instanceof CacheKeyError) {
+        this.logger.warn(`Invalid cache key "${key}": ${error.message}`);
+      }
+      return false;
+    }
+  }
+  async invalidateTag(tag) {
+    if (!this.tagsEnabled) {
+      return 0;
+    }
+    try {
+      const keysWithPrefix = await this.tagIndex.getKeysByTag(tag);
+      if (this.l1Enabled) {
+        const keysWithoutPrefix = keysWithPrefix.map((key) => key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key);
+        await Promise.all(keysWithoutPrefix.map((key) => this.l1Store.delete(key)));
+      }
+      return await this.tagIndex.invalidateTag(tag);
+    } catch (error) {
+      throw new CacheError(`Failed to invalidate tag "${tag}": ${error.message}`, core.ErrorCode.CACHE_TAG_INVALIDATION_FAILED, error);
+    }
+  }
+  async invalidateTags(tags) {
+    if (!this.tagsEnabled || tags.length === 0) {
+      return 0;
+    }
+    try {
+      let total = 0;
+      for (const tag of tags) {
+        const count = await this.invalidateTag(tag);
+        total += count;
+      }
+      return total;
+    } catch (error) {
+      throw new CacheError(`Failed to invalidate tags: ${error.message}`, core.ErrorCode.CACHE_TAG_INVALIDATION_FAILED, error);
+    }
+  }
+  async getKeysByTag(tag) {
+    if (!this.tagsEnabled) {
+      return [];
+    }
+    try {
+      const validTag = Tag.create(tag);
+      const keysWithPrefix = await this.tagIndex.getKeysByTag(validTag.toString());
+      return keysWithPrefix.map((key) => key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key);
+    } catch (error) {
+      this.logger.error(`Failed to get keys for tag ${tag}:`, error);
+      return [];
+    }
+  }
+  async getMany(keys) {
+    if (keys.length === 0) {
+      return [];
+    }
+    try {
+      const normalizedKeys = keys.map((key) => {
+        try {
+          const normalized = this.validateAndNormalizeKey(key);
+          return this.enrichKeyWithContext(normalized);
+        } catch (error) {
+          if (error instanceof CacheKeyError) {
+            this.logger.warn(`Invalid cache key in getMany "${key}": ${error.message}`);
+          }
+          return null;
+        }
+      });
+      if (!this.l2Enabled) {
+        return keys.map(() => null);
+      }
+      const validKeys = [];
+      const indexMap = /* @__PURE__ */ new Map();
+      normalizedKeys.forEach((key, index) => {
+        if (key !== null) {
+          indexMap.set(validKeys.length, index);
+          validKeys.push(key);
+        }
+      });
+      if (validKeys.length === 0) {
+        return keys.map(() => null);
+      }
+      const entries = await this.l2Store.getMany(validKeys);
+      const result = keys.map(() => null);
+      entries.forEach((entry, validIndex) => {
+        const originalIndex = indexMap.get(validIndex);
+        if (originalIndex !== void 0) {
+          result[originalIndex] = entry ? entry.value : null;
+        }
+      });
+      return result;
+    } catch (error) {
+      this.logger.error("Failed to getMany:", error);
+      return keys.map(() => null);
+    }
+  }
+  async setMany(entries) {
+    if (entries.length === 0) {
+      return;
+    }
+    try {
+      if (!this.l2Enabled) {
+        return;
+      }
+      const maxTtl = this.options.l2?.maxTtl ?? 86400;
+      const defaultTtl = this.options.l2?.defaultTtl ?? 3600;
+      const cacheEntries = entries.map(({ key, value, ttl }) => {
+        const entryTtl = ttl ?? defaultTtl;
+        return {
+          key: this.enrichKeyWithContext(this.validateAndNormalizeKey(key)),
+          entry: CacheEntry.create(value, Math.min(entryTtl, maxTtl)),
+          ttl: entryTtl
+        };
+      });
+      await this.l2Store.setMany(cacheEntries);
+      if (this.tagsEnabled) {
+        for (let i = 0; i < entries.length; i++) {
+          const entry = entries[i];
+          const { tags } = entry;
+          if (tags && tags.length > 0) {
+            const enrichedKey = cacheEntries[i].key;
+            const fullKey = `${this.keyPrefix}${enrichedKey}`;
+            const validatedTags = Tags.create(tags).toStrings();
+            await this.tagIndex.addKeyToTags(fullKey, validatedTags);
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof CacheKeyError) {
+        throw error;
+      }
+      throw new CacheError(`Failed to setMany: ${error.message}`, core.ErrorCode.CACHE_SET_FAILED, error);
+    }
+  }
+  async ttl(key) {
+    if (!this.l2Enabled) {
+      return -1;
+    }
+    try {
+      const normalizedKey = this.validateAndNormalizeKey(key);
+      const enrichedKey = this.enrichKeyWithContext(normalizedKey);
+      return await this.l2Store.ttl(enrichedKey);
+    } catch (error) {
+      if (error instanceof CacheKeyError) {
+        this.logger.warn(`Invalid cache key "${key}": ${error.message}`);
+      }
+      return -1;
+    }
+  }
+  async getStats() {
+    const l1Stats = this.l1Enabled ? this.l1Store.getStats() : { hits: 0, misses: 0, size: 0 };
+    const l2Stats = this.l2Enabled ? await this.l2Store.getStats() : { hits: 0, misses: 0 };
+    const stampedeStats = this.stampedeEnabled ? this.stampede.getStats() : { prevented: 0 };
+    return {
+      l1: l1Stats,
+      l2: l2Stats,
+      stampedePrevented: stampedeStats.prevented
+    };
+  }
+  async invalidateByPattern(pattern) {
+    if (!this.l2Enabled) {
+      return 0;
+    }
+    try {
+      const result = await this.l2Store.scan(pattern);
+      const keys = result.keys;
+      if (keys.length === 0) {
+        return 0;
+      }
+      if (this.l1Enabled) {
+        const keysWithoutPrefix = keys.map((key) => key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key);
+        await Promise.all(keysWithoutPrefix.map((key) => this.l1Store.delete(key)));
+      }
+      let deleted = 0;
+      for (const key of keys) {
+        const wasDeleted = await this.l2Store.delete(key);
+        if (wasDeleted) {
+          deleted++;
+        }
+      }
+      return deleted;
+    } catch (error) {
+      throw new CacheError(`Failed to invalidate by pattern "${pattern}": ${error.message}`, core.ErrorCode.CACHE_DELETE_FAILED, error);
+    }
+  }
+  /**
+   * Validates and normalizes cache key using CacheKey value object.
+   *
+   * @param rawKey - Raw key string
+   * @returns Normalized key string (without prefix - prefix added by L2 store)
+   * @throws CacheKeyError if validation fails
+   *
+   * @private
+   */
+  validateAndNormalizeKey(rawKey) {
+    try {
+      const keyOptions = {
+        maxLength: this.options.keys?.maxLength ?? 1024,
+        version: this.options.keys?.version,
+        separator: this.options.keys?.separator ?? ":",
+        // Don't include prefix here - it's added by L2 store
+        prefix: ""
+      };
+      const cacheKey = CacheKey.create(rawKey, keyOptions);
+      return cacheKey.getRaw();
+    } catch (error) {
+      if (error instanceof CacheKeyError) {
+        throw error;
+      }
+      throw new CacheKeyError(rawKey, `Invalid cache key: ${error.message}`);
+    }
+  }
+  /**
+   * Enriches a normalized key with context values.
+   * Appends global context keys and per-call varyBy values as key suffix.
+   * Uses a marker (_ctx_) to prevent double-enrichment in internal call chains.
+   *
+   * @param normalizedKey - Already validated and normalized cache key
+   * @param varyBy - Optional per-call context overrides
+   * @returns Enriched key with context suffix, or original key if no context
+   * @private
+   */
+  enrichKeyWithContext(normalizedKey, varyBy) {
+    const separator = this.options.keys?.separator ?? ":";
+    const marker = `${separator}_ctx_${separator}`;
+    if (normalizedKey.includes(marker)) {
+      return normalizedKey;
+    }
+    const contextProvider = this.options.contextProvider;
+    const contextKeys = this.options.contextKeys;
+    const contextMap = /* @__PURE__ */ new Map();
+    if (contextProvider && contextKeys && contextKeys.length > 0) {
+      for (const ctxKey of contextKeys) {
+        const value = contextProvider.get(ctxKey);
+        if (value !== void 0 && value !== null) {
+          contextMap.set(ctxKey, String(value));
+        }
+      }
+    }
+    if (varyBy) {
+      for (const [k, v] of Object.entries(varyBy)) {
+        contextMap.set(k, v);
+      }
+    }
+    if (contextMap.size === 0) return normalizedKey;
+    const sortedEntries = [...contextMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+    const suffix = sortedEntries.map(([k, v]) => `${this.sanitizeForKey(k)}.${this.sanitizeForKey(v)}`).join(separator);
+    return `${normalizedKey}${marker}${suffix}`;
+  }
+  /**
+   * Sanitizes a value for use in cache key (removes non-allowed characters).
+   * @private
+   */
+  sanitizeForKey(value) {
+    return String(value).replace(/[^a-zA-Z0-9\-_]/g, "_");
+  }
+};
+CacheService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(1, common.Inject(L1_CACHE_STORE)),
+  __decorateParam(2, common.Inject(L2_CACHE_STORE)),
+  __decorateParam(3, common.Inject(STAMPEDE_PROTECTION)),
+  __decorateParam(4, common.Inject(TAG_INDEX)),
+  __decorateParam(5, common.Inject(SWR_MANAGER)),
+  __decorateParam(6, common.Inject(CACHE_PLUGIN_OPTIONS)),
+  __decorateParam(7, common.Optional()),
+  __decorateParam(7, common.Inject(METRICS_SERVICE)),
+  __decorateParam(8, common.Optional()),
+  __decorateParam(8, common.Inject(TRACING_SERVICE))
+], CacheService);
+var WarmupService = class {
+  constructor(cacheService, options) {
+    this.cacheService = cacheService;
+    this.options = options;
+    this.enabled = options.warmup?.enabled ?? false;
+    this.keys = options.warmup?.keys ?? [];
+    this.concurrency = options.warmup?.concurrency ?? 10;
+  }
+  logger = new common.Logger(WarmupService.name);
+  enabled;
+  keys;
+  concurrency;
+  async onModuleInit() {
+    if (!this.enabled || this.keys.length === 0) {
+      return;
+    }
+    this.logger.log(`Starting cache warmup for ${this.keys.length} keys...`);
+    const startTime = Date.now();
+    const chunks = [];
+    for (let i = 0; i < this.keys.length; i += this.concurrency) {
+      chunks.push(this.keys.slice(i, i + this.concurrency));
+    }
+    let succeeded = 0;
+    let failed = 0;
+    for (const chunk of chunks) {
+      const results = await Promise.allSettled(chunk.map((warmupKey) => this.warmupKey(warmupKey)));
+      succeeded += results.filter((r) => r.status === "fulfilled").length;
+      failed += results.filter((r) => r.status === "rejected").length;
+    }
+    const duration = Date.now() - startTime;
+    this.logger.log(`Cache warmup completed: ${succeeded} succeeded, ${failed} failed (${duration}ms)`);
+  }
+  /**
+   * Warms up a single cache key.
+   *
+   * @param warmupKey - Warmup key configuration
+   * @private
+   */
+  async warmupKey(warmupKey) {
+    try {
+      this.logger.debug(`Warming up key: ${warmupKey.key}`);
+      await this.cacheService.getOrSet(warmupKey.key, warmupKey.loader, {
+        ttl: warmupKey.ttl,
+        tags: warmupKey.tags
+      });
+      this.logger.debug(`Successfully warmed up key: ${warmupKey.key}`);
+    } catch (error) {
+      this.logger.error(`Failed to warm up key ${warmupKey.key}:`, error);
+      throw error;
+    }
+  }
+};
+WarmupService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(CACHE_SERVICE)),
+  __decorateParam(1, common.Inject(CACHE_PLUGIN_OPTIONS))
+], WarmupService);
+var Serializer = class {
+  /**
+   * Serializes value to string.
+   *
+   * @param value - Value to serialize
+   * @returns Serialized string
+   * @throws SerializationError if serialization fails
+   */
+  serialize(value) {
+    try {
+      return JSON.stringify(value);
+    } catch (error) {
+      throw new SerializationError(`Failed to serialize value: ${error.message}`, error);
+    }
+  }
+  /**
+   * Deserializes string to value.
+   *
+   * @param serialized - Serialized string
+   * @returns Deserialized value
+   * @throws SerializationError if deserialization fails
+   */
+  deserialize(serialized) {
+    try {
+      return JSON.parse(serialized);
+    } catch (error) {
+      throw new SerializationError(`Failed to deserialize value: ${error.message}`, error);
+    }
+  }
+  /**
+   * Safely tries to deserialize, returns null on error.
+   *
+   * @param serialized - Serialized string
+   * @returns Deserialized value or null
+   */
+  tryDeserialize(serialized) {
+    try {
+      return this.deserialize(serialized);
+    } catch {
+      return null;
+    }
+  }
+};
+Serializer = __decorateClass([
+  common.Injectable()
+], Serializer);
+var L1MemoryStoreAdapter = class {
+  constructor(options) {
+    this.options = options;
+    this.maxSize = options.l1?.maxSize ?? 1e3;
+    this.defaultTtl = (options.l1?.ttl ?? 60) * 1e3;
+    this.evictionPolicy = options.l1?.evictionPolicy ?? "lru";
+  }
+  cache = /* @__PURE__ */ new Map();
+  head = null;
+  tail = null;
+  maxSize;
+  defaultTtl;
+  evictionPolicy;
+  hits = 0;
+  misses = 0;
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async get(key) {
+    const node = this.cache.get(key);
+    if (!node) {
+      this.misses++;
+      return null;
+    }
+    if (Date.now() > node.expiresAt) {
+      void this.delete(key);
+      this.misses++;
+      return null;
+    }
+    if (this.evictionPolicy === "lru") {
+      this.moveToFront(node);
+    } else {
+      node.frequency++;
+    }
+    this.hits++;
+    return node.entry;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async set(key, entry, ttl) {
+    const existingNode = this.cache.get(key);
+    if (existingNode) {
+      existingNode.entry = entry;
+      existingNode.expiresAt = Date.now() + (ttl ?? this.defaultTtl);
+      if (this.evictionPolicy === "lru") {
+        this.moveToFront(existingNode);
+      } else {
+        existingNode.frequency++;
+      }
+    } else {
+      if (this.cache.size >= this.maxSize) {
+        this.evict();
+      }
+      const node = {
+        key,
+        entry,
+        prev: null,
+        next: this.head,
+        expiresAt: Date.now() + (ttl ?? this.defaultTtl),
+        frequency: 1
+      };
+      if (this.head) {
+        this.head.prev = node;
+      }
+      this.head = node;
+      if (!this.tail) {
+        this.tail = node;
+      }
+      this.cache.set(key, node);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async delete(key) {
+    const node = this.cache.get(key);
+    if (!node) {
+      return false;
+    }
+    this.removeNode(node);
+    this.cache.delete(key);
+    return true;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async clear() {
+    this.cache.clear();
+    this.head = null;
+    this.tail = null;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async has(key) {
+    const node = this.cache.get(key);
+    if (!node) {
+      return false;
+    }
+    if (Date.now() > node.expiresAt) {
+      void this.delete(key);
+      return false;
+    }
+    return true;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async size() {
+    const now = Date.now();
+    for (const [key, node] of this.cache.entries()) {
+      if (now > node.expiresAt) {
+        void this.delete(key);
+      }
+    }
+    return this.cache.size;
+  }
+  moveToFront(node) {
+    if (node === this.head) {
+      return;
+    }
+    this.removeNode(node);
+    node.prev = null;
+    node.next = this.head;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+  }
+  removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+  }
+  evict() {
+    if (this.evictionPolicy === "lfu") {
+      this.evictLFU();
+    } else {
+      this.evictLRU();
+    }
+  }
+  evictLRU() {
+    if (!this.tail) {
+      return;
+    }
+    const key = this.tail.key;
+    this.removeNode(this.tail);
+    this.cache.delete(key);
+  }
+  evictLFU() {
+    if (this.cache.size === 0) {
+      return;
+    }
+    let victim = null;
+    let current = this.tail;
+    while (current) {
+      if (!victim || current.frequency < victim.frequency) {
+        victim = current;
+      }
+      current = current.prev;
+    }
+    if (victim) {
+      this.removeNode(victim);
+      this.cache.delete(victim.key);
+    }
+  }
+  getStats() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.cache.size
+    };
+  }
+};
+L1MemoryStoreAdapter = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(CACHE_PLUGIN_OPTIONS))
+], L1MemoryStoreAdapter);
+var DEFAULT_BATCH_SIZE = 100;
+var L2RedisStoreAdapter = class {
+  constructor(driver, options, serializer) {
+    this.driver = driver;
+    this.options = options;
+    this.serializer = serializer;
+    this.keyPrefix = options.l2?.keyPrefix ?? "cache:";
+    this.defaultTtl = options.l2?.defaultTtl ?? 3600;
+  }
+  keyPrefix;
+  defaultTtl;
+  hits = 0;
+  misses = 0;
+  async get(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const value = await this.driver.get(fullKey);
+      if (!value) {
+        this.misses++;
+        return null;
+      }
+      this.hits++;
+      return this.serializer.deserialize(value);
+    } catch {
+      this.misses++;
+      return null;
+    }
+  }
+  async set(key, entry, ttl) {
+    try {
+      const fullKey = this.buildKey(key);
+      const serialized = this.serializer.serialize(entry);
+      const ttlSeconds = ttl ?? this.defaultTtl;
+      await this.driver.setex(fullKey, ttlSeconds, serialized);
+    } catch (error) {
+      throw new CacheError(`Failed to set cache entry for key "${key}": ${error.message}`, core.ErrorCode.CACHE_SET_FAILED, error);
+    }
+  }
+  async delete(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const result = await this.driver.del(fullKey);
+      return result > 0;
+    } catch (error) {
+      throw new CacheError(`Failed to delete cache entry for key "${key}": ${error.message}`, core.ErrorCode.CACHE_DELETE_FAILED, error);
+    }
+  }
+  async clear() {
+    try {
+      const pattern = `${this.keyPrefix}*`;
+      const keys = await this.scanKeys(pattern);
+      if (keys.length === 0) {
+        return;
+      }
+      const batchSize = DEFAULT_BATCH_SIZE;
+      for (let i = 0; i < keys.length; i += batchSize) {
+        const batch = keys.slice(i, i + batchSize);
+        await Promise.all(batch.map((key) => this.driver.del(key)));
+      }
+    } catch (error) {
+      throw new CacheError(`Failed to clear cache: ${error.message}`, core.ErrorCode.CACHE_CLEAR_FAILED, error);
+    }
+  }
+  async has(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const exists = await this.driver.exists(fullKey);
+      return exists > 0;
+    } catch {
+      return false;
+    }
+  }
+  async ttl(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const ttl = await this.driver.ttl(fullKey);
+      return ttl;
+    } catch {
+      return -1;
+    }
+  }
+  async expire(key, ttl) {
+    try {
+      const fullKey = this.buildKey(key);
+      const result = await this.driver.expire(fullKey, ttl);
+      return result === 1;
+    } catch (error) {
+      throw new CacheError(`Failed to set expiration for key "${key}": ${error.message}`, core.ErrorCode.CACHE_OPERATION_FAILED, error);
+    }
+  }
+  async scan(pattern, count = DEFAULT_BATCH_SIZE) {
+    try {
+      const fullPattern = `${this.keyPrefix}${pattern}`;
+      const keys = await this.scanKeys(fullPattern, count);
+      const strippedKeys = keys.map((key) => key.startsWith(this.keyPrefix) ? key.slice(this.keyPrefix.length) : key);
+      return {
+        keys: strippedKeys,
+        cursor: "0"
+        // Simplified: full scan completed
+      };
+    } catch (error) {
+      throw new CacheError(`Failed to scan keys with pattern "${pattern}": ${error.message}`, core.ErrorCode.CACHE_OPERATION_FAILED, error);
+    }
+  }
+  async getMany(keys) {
+    try {
+      if (keys.length === 0) {
+        return [];
+      }
+      const fullKeys = keys.map((key) => this.buildKey(key));
+      const values = await this.driver.mget(...fullKeys);
+      return values.map((value) => {
+        if (!value) {
+          this.misses++;
+          return null;
+        }
+        this.hits++;
+        return this.serializer.tryDeserialize(value);
+      });
+    } catch {
+      return keys.map(() => null);
+    }
+  }
+  async setMany(entries) {
+    try {
+      if (entries.length === 0) {
+        return;
+      }
+      await Promise.all(
+        entries.map(async ({ key, entry, ttl }) => {
+          const fullKey = this.buildKey(key);
+          const serialized = this.serializer.serialize(entry);
+          const ttlSeconds = ttl ?? this.defaultTtl;
+          await this.driver.setex(fullKey, ttlSeconds, serialized);
+        })
+      );
+    } catch (error) {
+      throw new CacheError(`Failed to set multiple cache entries: ${error.message}`, core.ErrorCode.CACHE_SET_FAILED, error);
+    }
+  }
+  buildKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  async scanKeys(pattern, count = DEFAULT_BATCH_SIZE) {
+    const keys = [];
+    let cursor = 0;
+    do {
+      const result = await this.driver.scan(cursor, {
+        match: pattern,
+        count
+      });
+      cursor = parseInt(result[0], 10);
+      keys.push(...result[1]);
+    } while (cursor !== 0);
+    return keys;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getStats() {
+    return {
+      hits: this.hits,
+      misses: this.misses
+    };
+  }
+  async getSwr(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const value = await this.driver.get(fullKey);
+      if (!value) {
+        this.misses++;
+        return null;
+      }
+      this.hits++;
+      return this.serializer.deserialize(value);
+    } catch {
+      this.misses++;
+      return null;
+    }
+  }
+  async setSwr(key, swrEntry) {
+    try {
+      const fullKey = this.buildKey(key);
+      const serialized = this.serializer.serialize(swrEntry);
+      const now = Date.now();
+      const ttlMs = swrEntry.expiresAt - now;
+      if (ttlMs <= 0) {
+        return;
+      }
+      const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1e3));
+      await this.driver.setex(fullKey, ttlSeconds, serialized);
+    } catch (error) {
+      throw new CacheError(`Failed to set SWR entry for key "${key}": ${error.message}`, core.ErrorCode.CACHE_SET_FAILED, error);
+    }
+  }
+};
+L2RedisStoreAdapter = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(1, common.Inject(CACHE_PLUGIN_OPTIONS)),
+  __decorateParam(2, common.Inject(SERIALIZER))
+], L2RedisStoreAdapter);
+exports.CacheService = class CacheService2 {
+  constructor(internalCache) {
+    this.internalCache = internalCache;
+  }
+  /**
+   * Gets value from cache.
+   *
+   * @param key - Cache key
+   * @returns Cached value or null if not found
+   *
+   * @example
+   * ```typescript
+   * const user = await cacheService.get<User>('user:123');
+   * ```
+   */
+  async get(key) {
+    return this.internalCache.get(key);
+  }
+  /**
+   * Sets value in cache with optional TTL and tags.
+   *
+   * @param key - Cache key
+   * @param value - Value to cache
+   * @param options - Cache options (ttl, tags, strategy)
+   *
+   * @example
+   * ```typescript
+   * await cacheService.set('user:123', user, {
+   *   ttl: 3600,
+   *   tags: ['users', 'user:123']
+   * });
+   * ```
+   */
+  async set(key, value, options) {
+    return this.internalCache.set(key, value, options);
+  }
+  /**
+   * Deletes key from cache.
+   *
+   * @param key - Cache key
+   * @returns True if key was deleted, false if not found
+   *
+   * @example
+   * ```typescript
+   * const deleted = await cacheService.del('user:123');
+   * ```
+   */
+  async del(key) {
+    return this.internalCache.delete(key);
+  }
+  /**
+   * Gets multiple values from cache.
+   *
+   * @param keys - Array of cache keys
+   * @returns Array of values (null for missing keys)
+   *
+   * @example
+   * ```typescript
+   * const users = await cacheService.getMany<User>(['user:1', 'user:2', 'user:3']);
+   * ```
+   */
+  async getMany(keys) {
+    return this.internalCache.getMany(keys);
+  }
+  /**
+   * Sets multiple values in cache.
+   *
+   * @param entries - Array of key-value-ttl tuples
+   *
+   * @example
+   * ```typescript
+   * await cacheService.setMany([
+   *   { key: 'user:1', value: user1, ttl: 3600 },
+   *   { key: 'user:2', value: user2, ttl: 3600 }
+   * ]);
+   * ```
+   */
+  async setMany(entries) {
+    return this.internalCache.setMany(entries);
+  }
+  /**
+   * Gets value from cache or loads it using the provided loader function.
+   * Implements cache-aside pattern with anti-stampede protection.
+   *
+   * @param key - Cache key
+   * @param loader - Function to load value if not cached
+   * @param options - Cache options
+   * @returns Cached or loaded value
+   *
+   * @example
+   * ```typescript
+   * const user = await cacheService.getOrSet(
+   *   'user:123',
+   *   async () => {
+   *     return await userRepository.findById('123');
+   *   },
+   *   { ttl: 3600, tags: ['users'] }
+   * );
+   * ```
+   */
+  async getOrSet(key, loader, options) {
+    return this.internalCache.getOrSet(key, loader, options);
+  }
+  /**
+   * Wraps a function with caching logic.
+   * Helper for creating cached functions.
+   *
+   * @param fn - Function to wrap
+   * @param options - Cache options or key builder function
+   * @returns Wrapped function with caching
+   *
+   * @example
+   * ```typescript
+   * const getCachedUser = cacheService.wrap(
+   *   async (id: string) => userRepository.findById(id),
+   *   {
+   *     key: (id: string) => `user:${id}`,
+   *     ttl: 3600,
+   *     tags: (id: string) => [`user:${id}`, 'users']
+   *   }
+   * );
+   *
+   * const user = await getCachedUser('123');
+   * ```
+   */
+  wrap(fn, options) {
+    return async (...args) => {
+      const key = options.key(...args);
+      const tags = typeof options.tags === "function" ? options.tags(...args) : options.tags;
+      return this.getOrSet(key, () => fn(...args), {
+        ttl: options.ttl,
+        tags
+      });
+    };
+  }
+  /**
+   * Deletes multiple keys from cache.
+   *
+   * @param keys - Array of cache keys
+   * @returns Number of keys deleted
+   *
+   * @example
+   * ```typescript
+   * const count = await cacheService.deleteMany(['user:1', 'user:2', 'user:3']);
+   * console.log(`Deleted ${count} keys`);
+   * ```
+   */
+  async deleteMany(keys) {
+    return this.internalCache.deleteMany(keys);
+  }
+  /**
+   * Gets all cache keys associated with a tag.
+   *
+   * @param tag - Tag name
+   * @returns Array of cache keys
+   *
+   * @example
+   * ```typescript
+   * const keys = await cacheService.getKeysByTag('users');
+   * console.log(`Found ${keys.length} cached user keys`);
+   * ```
+   */
+  async getKeysByTag(tag) {
+    return this.internalCache.getKeysByTag(tag);
+  }
+  /**
+   * Invalidates cache by tag.
+   *
+   * @param tag - Tag to invalidate
+   * @returns Number of keys invalidated
+   *
+   * @example
+   * ```typescript
+   * // Invalidate all user caches
+   * const count = await cacheService.invalidate('users');
+   * console.log(`Invalidated ${count} keys`);
+   * ```
+   */
+  async invalidate(tag) {
+    return this.internalCache.invalidateTag(tag);
+  }
+  /**
+   * Invalidates multiple tags.
+   *
+   * @param tags - Array of tags to invalidate
+   * @returns Total number of keys invalidated
+   *
+   * @example
+   * ```typescript
+   * const count = await cacheService.invalidate(['users', 'products']);
+   * ```
+   */
+  async invalidateTags(tags) {
+    return this.internalCache.invalidateTags(tags);
+  }
+  /**
+   * Invalidates cache keys matching a pattern.
+   * Uses Redis SCAN for safe iteration.
+   *
+   * @param pattern - Redis pattern (supports * and ?)
+   * @returns Number of keys deleted
+   *
+   * @example
+   * ```typescript
+   * // Delete all user-related caches
+   * await cacheService.invalidateByPattern('user:*');
+   *
+   * // Delete specific locale caches
+   * await cacheService.invalidateByPattern('*:en_US');
+   * ```
+   */
+  async invalidateByPattern(pattern) {
+    return this.internalCache.invalidateByPattern(pattern);
+  }
+  /**
+   * Checks if key exists in cache.
+   *
+   * @param key - Cache key
+   * @returns True if key exists
+   */
+  async has(key) {
+    return this.internalCache.has(key);
+  }
+  /**
+   * Gets TTL for a cached key.
+   *
+   * @param key - Cache key
+   * @returns TTL in seconds, -1 if no TTL, -2 if key doesn't exist
+   */
+  async ttl(key) {
+    return this.internalCache.ttl(key);
+  }
+  /**
+   * Clears all cache entries.
+   * Use with caution in production.
+   *
+   * @example
+   * ```typescript
+   * await cacheService.clear();
+   * ```
+   */
+  async clear() {
+    return this.internalCache.clear();
+  }
+  /**
+   * Gets cache statistics.
+   *
+   * @returns Cache stats (hits, misses, size)
+   *
+   * @example
+   * ```typescript
+   * const stats = await cacheService.getStats();
+   * console.log(`L1 Hit Rate: ${stats.l1.hits / (stats.l1.hits + stats.l1.misses) * 100}%`);
+   * ```
+   */
+  async getStats() {
+    return this.internalCache.getStats();
+  }
+};
+exports.CacheService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(CACHE_SERVICE))
+], exports.CacheService);
+exports.EventInvalidationService = class EventInvalidationService {
+  constructor(registry, cacheService, driver, config) {
+    this.registry = registry;
+    this.cacheService = cacheService;
+    this.driver = driver;
+    this.config = config;
+  }
+  logger = new common.Logger(exports.EventInvalidationService.name);
+  handlers = /* @__PURE__ */ new Set();
+  eventEmitter = new events.EventEmitter();
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async onModuleInit() {
+    const source = this.config.invalidation?.source ?? "internal";
+    if (source === "internal") {
+      this.setupInternalSource();
+      this.logger.log("Event invalidation initialized with internal source");
+    }
+  }
+  async processEvent(event, payload) {
+    const startTime = Date.now();
+    try {
+      const eventId = this.generateEventId(event, payload);
+      const isDuplicate = await this.checkDuplicate(eventId);
+      if (isDuplicate) {
+        this.logger.debug(`Skipping duplicate event "${event}"`);
+        return {
+          event,
+          tagsInvalidated: [],
+          keysInvalidated: [],
+          totalKeysDeleted: 0,
+          duration: Date.now() - startTime,
+          skipped: true,
+          skipReason: "duplicate"
+        };
+      }
+      const resolved = this.registry.resolve(event, payload);
+      if (resolved.tags.length === 0 && resolved.keys.length === 0) {
+        this.logger.debug(`No matching rules for event "${event}"`);
+        return {
+          event,
+          tagsInvalidated: [],
+          keysInvalidated: [],
+          totalKeysDeleted: 0,
+          duration: Date.now() - startTime,
+          skipped: true,
+          skipReason: "no_matching_rules"
+        };
+      }
+      let totalDeleted = 0;
+      if (resolved.tags.length > 0) {
+        this.logger.debug(`Invalidating tags: ${resolved.tags.join(", ")} for event "${event}"`);
+        totalDeleted += await this.cacheService.invalidateTags(resolved.tags);
+      }
+      if (resolved.keys.length > 0) {
+        this.logger.debug(`Invalidating keys: ${resolved.keys.join(", ")} for event "${event}"`);
+        totalDeleted += await this.cacheService.deleteMany(resolved.keys);
+      }
+      await this.markProcessed(eventId);
+      const result = {
+        event,
+        tagsInvalidated: resolved.tags,
+        keysInvalidated: resolved.keys,
+        totalKeysDeleted: totalDeleted,
+        duration: Date.now() - startTime,
+        skipped: false
+      };
+      this.logger.log(`Processed event "${event}": invalidated ${resolved.tags.length} tags, ${resolved.keys.length} keys, deleted ${totalDeleted} cache entries (${result.duration}ms)`);
+      await this.notifyHandlers(event, payload, result);
+      return result;
+    } catch (error) {
+      this.logger.error(`Failed to process event "${event}":`, error);
+      throw error;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async emit(event, payload) {
+    this.eventEmitter.emit("invalidation", { event, payload });
+  }
+  subscribe(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  setupInternalSource() {
+    this.eventEmitter.on("invalidation", async ({ event, payload }) => {
+      try {
+        await this.processEvent(event, payload);
+      } catch (error) {
+        this.logger.error(`Internal event processing failed for "${event}":`, error);
+      }
+    });
+  }
+  async checkDuplicate(eventId) {
+    try {
+      const key = `_invalidation:processed:${eventId}`;
+      const exists = await this.driver.exists(key);
+      return exists > 0;
+    } catch (error) {
+      this.logger.warn("Deduplication check failed:", error);
+      return false;
+    }
+  }
+  async markProcessed(eventId) {
+    try {
+      const key = `_invalidation:processed:${eventId}`;
+      const ttl = this.config.invalidation?.deduplicationTtl ?? 60;
+      await this.driver.setex(key, ttl, "1");
+    } catch (error) {
+      this.logger.warn("Failed to mark event as processed:", error);
+    }
+  }
+  generateEventId(event, payload) {
+    const hash = crypto.createHash("sha256").update(event).update(JSON.stringify(payload ?? {})).digest("hex").slice(0, 16);
+    return hash;
+  }
+  async notifyHandlers(event, payload, result) {
+    for (const handler of this.handlers) {
+      try {
+        await handler(event, payload, result);
+      } catch (error) {
+        this.logger.error("Invalidation handler error:", error);
+      }
+    }
+  }
+};
+exports.EventInvalidationService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(INVALIDATION_REGISTRY)),
+  __decorateParam(1, common.Inject(CACHE_SERVICE)),
+  __decorateParam(2, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(3, common.Inject(CACHE_PLUGIN_OPTIONS))
+], exports.EventInvalidationService);
+exports.InvalidationRegistryService = class InvalidationRegistryService {
+  logger = new common.Logger(exports.InvalidationRegistryService.name);
+  rules = [];
+  register(rule) {
+    this.rules.push(rule);
+    this.rules.sort((a, b) => b.getPriority() - a.getPriority());
+    this.logger.debug(`Registered invalidation rule for event "${rule.getEventPattern()}" with priority ${rule.getPriority()}`);
+  }
+  registerMany(rules) {
+    for (const rule of rules) {
+      this.register(rule);
+    }
+  }
+  unregister(event) {
+    const initialLength = this.rules.length;
+    this.rules = this.rules.filter((r) => r.getEventPattern() !== event);
+    const removed = initialLength - this.rules.length;
+    if (removed > 0) {
+      this.logger.debug(`Unregistered ${removed} rule(s) for event "${event}"`);
+    }
+  }
+  findRules(event) {
+    return this.rules.filter((rule) => rule.matches(event));
+  }
+  resolve(event, payload) {
+    const matchedRules = this.findRules(event);
+    const tagsSet = /* @__PURE__ */ new Set();
+    const keysSet = /* @__PURE__ */ new Set();
+    const applicableRules = [];
+    for (const rule of matchedRules) {
+      if (!rule.testCondition(payload)) {
+        this.logger.debug(`Rule for event "${rule.getEventPattern()}" skipped - condition not met`);
+        continue;
+      }
+      applicableRules.push(rule);
+      if (rule.hasTags()) {
+        const tags = rule.resolveTags(payload);
+        for (const tag of tags) {
+          if (!tag.includes("{")) {
+            tagsSet.add(tag);
+          } else {
+            this.logger.warn(`Tag template "${tag}" has unresolved placeholders for event "${event}"`);
+          }
+        }
+      }
+      if (rule.hasKeys()) {
+        const keys = rule.resolveKeys(payload);
+        for (const key of keys) {
+          if (!key.includes("{")) {
+            keysSet.add(key);
+          } else {
+            this.logger.warn(`Key template "${key}" has unresolved placeholders for event "${event}"`);
+          }
+        }
+      }
+    }
+    return {
+      tags: Array.from(tagsSet),
+      keys: Array.from(keysSet),
+      matchedRules: applicableRules
+    };
+  }
+  getRules() {
+    return [...this.rules];
+  }
+};
+exports.InvalidationRegistryService = __decorateClass([
+  common.Injectable()
+], exports.InvalidationRegistryService);
+var EventPattern = class _EventPattern {
+  pattern;
+  regex;
+  constructor(pattern, regex) {
+    this.pattern = pattern;
+    this.regex = regex;
+  }
+  /**
+   * Creates EventPattern from string pattern.
+   * @param pattern - AMQP-style pattern (e.g., 'user.*', 'order.#', 'product.updated')
+   */
+  static create(pattern) {
+    if (!pattern || pattern.trim().length === 0) {
+      throw new CacheError("Event pattern cannot be empty", core.ErrorCode.VALIDATION_FAILED);
+    }
+    const normalized = pattern.trim();
+    if (!/^[a-z0-9*#._-]+$/i.test(normalized)) {
+      throw new CacheError(`Invalid event pattern "${normalized}". Only alphanumeric, dots, dashes, underscores, *, and # are allowed`, core.ErrorCode.VALIDATION_FAILED);
+    }
+    let regexStr = normalized.replace(/\./g, "\\.").replace(/\*/g, "[^.]+").replace(/#/g, ".*");
+    regexStr = regexStr.replace(/\\\.\.\*$/, "(?:\\..*)?");
+    const regex = new RegExp(`^${regexStr}$`);
+    return new _EventPattern(normalized, regex);
+  }
+  /**
+   * Tests if this pattern matches the given event.
+   */
+  matches(event) {
+    return this.regex.test(event);
+  }
+  /**
+   * Returns the raw pattern string.
+   */
+  toString() {
+    return this.pattern;
+  }
+  /**
+   * Checks equality with another pattern.
+   */
+  equals(other) {
+    return this.pattern === other.pattern;
+  }
+};
+var TagTemplate = class _TagTemplate {
+  template;
+  placeholders;
+  constructor(template, placeholders) {
+    this.template = template;
+    this.placeholders = placeholders;
+  }
+  /**
+   * Creates TagTemplate from template string.
+   * @param template - Template string with placeholders (e.g., 'user:{userId}')
+   */
+  static create(template) {
+    if (!template || template.trim().length === 0) {
+      throw new CacheError("Tag template cannot be empty", core.ErrorCode.VALIDATION_FAILED);
+    }
+    const normalized = template.trim();
+    const placeholders = [];
+    const placeholderRegex = /\{([^}]+)\}/g;
+    let match;
+    while ((match = placeholderRegex.exec(normalized)) !== null) {
+      placeholders.push(match[1]);
+    }
+    return new _TagTemplate(normalized, placeholders);
+  }
+  /**
+   * Resolves template with given payload.
+   * @param payload - Data object to resolve placeholders from
+   * @returns Resolved tag string
+   */
+  resolve(payload) {
+    return this.template.replace(/\{([^}]+)\}/g, (_, path) => {
+      const value = this.getNestedValue(payload, path);
+      if (value === void 0 || value === null) {
+        return `{${path}}`;
+      }
+      return String(value);
+    });
+  }
+  /**
+   * Returns the raw template string.
+   */
+  toString() {
+    return this.template;
+  }
+  /**
+   * Returns all placeholders in the template.
+   */
+  getPlaceholders() {
+    return [...this.placeholders];
+  }
+  /**
+   * Checks if template has any placeholders.
+   */
+  hasPlaceholders() {
+    return this.placeholders.length > 0;
+  }
+  getNestedValue(obj, path) {
+    if (obj === null || obj === void 0) {
+      return void 0;
+    }
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || current === void 0) {
+        return void 0;
+      }
+      if (typeof current !== "object") {
+        return void 0;
+      }
+      current = current[part];
+    }
+    return current;
+  }
+};
+
+// src/invalidation/domain/entities/invalidation-rule.entity.ts
+var InvalidationRule = class _InvalidationRule {
+  eventPattern;
+  tagTemplates;
+  keyTemplates;
+  condition;
+  priority;
+  constructor(eventPattern, tagTemplates, keyTemplates, condition, priority) {
+    this.eventPattern = eventPattern;
+    this.tagTemplates = tagTemplates;
+    this.keyTemplates = keyTemplates;
+    this.condition = condition;
+    this.priority = priority;
+  }
+  /**
+   * Creates InvalidationRule from props.
+   */
+  static create(props) {
+    const eventPattern = EventPattern.create(props.event);
+    const tagTemplates = (props.tags ?? []).map((tag) => TagTemplate.create(tag));
+    const keyTemplates = (props.keys ?? []).map((key) => TagTemplate.create(key));
+    const priority = props.priority ?? 0;
+    return new _InvalidationRule(eventPattern, tagTemplates, keyTemplates, props.condition, priority);
+  }
+  /**
+   * Tests if this rule matches the given event.
+   */
+  matches(event) {
+    return this.eventPattern.matches(event);
+  }
+  /**
+   * Tests if condition passes for the given payload.
+   */
+  testCondition(payload) {
+    if (!this.condition) {
+      return true;
+    }
+    try {
+      return this.condition(payload);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Resolves tags for the given payload.
+   */
+  resolveTags(payload) {
+    return this.tagTemplates.map((template) => template.resolve(payload));
+  }
+  /**
+   * Resolves keys for the given payload.
+   */
+  resolveKeys(payload) {
+    return this.keyTemplates.map((template) => template.resolve(payload));
+  }
+  /**
+   * Gets rule priority (higher = processed first).
+   */
+  getPriority() {
+    return this.priority;
+  }
+  /**
+   * Gets the event pattern string.
+   */
+  getEventPattern() {
+    return this.eventPattern.toString();
+  }
+  /**
+   * Checks if rule has any tags.
+   */
+  hasTags() {
+    return this.tagTemplates.length > 0;
+  }
+  /**
+   * Checks if rule has any keys.
+   */
+  hasKeys() {
+    return this.keyTemplates.length > 0;
+  }
+  /**
+   * Checks if rule has a condition.
+   */
+  hasCondition() {
+    return this.condition !== void 0;
+  }
+};
+var AMQPEventSourceAdapter = class {
+  constructor(invalidationService, config, amqpConnection) {
+    this.invalidationService = invalidationService;
+    this.config = config;
+    this.amqpConnection = amqpConnection;
+  }
+  logger = new common.Logger(AMQPEventSourceAdapter.name);
+  amqpConnection;
+  async onModuleInit() {
+    const source = this.config.invalidation?.source;
+    if (source !== "amqp") {
+      return;
+    }
+    if (!this.amqpConnection) {
+      this.logger.warn("AMQP source configured but @golevelup/nestjs-rabbitmq is not available. Install it with: npm install @golevelup/nestjs-rabbitmq");
+      return;
+    }
+    const amqpConfig = this.config.invalidation?.amqp;
+    if (!amqpConfig) {
+      this.logger.warn("AMQP source configured but amqp config is missing");
+      return;
+    }
+    const exchange = amqpConfig.exchange ?? "cache.invalidation";
+    const queue = amqpConfig.queue ?? `${this.getServiceName()}.cache.invalidation`;
+    const routingKeys = amqpConfig.routingKeys ?? ["#"];
+    try {
+      await this.amqpConnection.createSubscriber(
+        async (msg, rawMsg) => {
+          const routingKey = rawMsg.fields.routingKey;
+          this.logger.debug(`Received AMQP invalidation event: ${routingKey}`);
+          await this.invalidationService.processEvent(routingKey, msg.payload);
+        },
+        {
+          exchange,
+          queue,
+          routingKey: routingKeys,
+          queueOptions: {
+            durable: true
+          }
+        }
+      );
+      this.logger.log(`AMQP event source initialized: exchange=${exchange}, queue=${queue}, routingKeys=${routingKeys.join(",")}`);
+    } catch (error) {
+      this.logger.error("Failed to setup AMQP event source:", error);
+      throw error;
+    }
+  }
+  getServiceName() {
+    return process.env.SERVICE_NAME ?? "app";
+  }
+};
+AMQPEventSourceAdapter = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(EVENT_INVALIDATION_SERVICE)),
+  __decorateParam(1, common.Inject(CACHE_PLUGIN_OPTIONS)),
+  __decorateParam(2, common.Optional()),
+  __decorateParam(2, common.Inject(AMQP_CONNECTION))
+], AMQPEventSourceAdapter);
+var RELEASE_LOCK_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("del", KEYS[1])
+else
+  return 0
+end
+`.trim();
+var LOCK_PREFIX = "_stampede:";
+var StampedeProtectionService = class {
+  constructor(options, driver) {
+    this.options = options;
+    this.driver = driver;
+    this.lockTimeout = options.stampede?.lockTimeout ?? 5e3;
+    this.waitTimeout = options.stampede?.waitTimeout ?? 1e4;
+  }
+  logger = new common.Logger(StampedeProtectionService.name);
+  flights = /* @__PURE__ */ new Map();
+  lockTimeout;
+  waitTimeout;
+  prevented = 0;
+  async protect(key, loader) {
+    const existingFlight = this.flights.get(key);
+    if (existingFlight) {
+      existingFlight.waiters++;
+      this.prevented++;
+      const value = await this.waitForFlight(existingFlight, key);
+      return { value, cached: true, waited: true };
+    }
+    let resolveFunc;
+    let rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    const flight = {
+      promise,
+      resolve: resolveFunc,
+      reject: rejectFunc,
+      waiters: 0,
+      timestamp: Date.now()
+    };
+    this.flights.set(key, flight);
+    let lock;
+    try {
+      const lockKey = `${LOCK_PREFIX}${key}`;
+      const lockValue = this.generateLockValue();
+      const lockTtlSeconds = Math.ceil(this.lockTimeout / 1e3);
+      const acquired = await this.tryAcquireLock(lockKey, lockValue, lockTtlSeconds);
+      if (acquired) {
+        lock = { lockKey, lockValue };
+      }
+    } catch {
+    }
+    try {
+      const value = await this.executeLoader(loader, key);
+      flight.resolve(value);
+      return { value, cached: false, waited: false };
+    } catch (error) {
+      if (flight.waiters > 0) {
+        flight.reject(error);
+      }
+      throw error;
+    } finally {
+      setTimeout(() => {
+        this.flights.delete(key);
+      }, 100);
+      if (lock) {
+        this.releaseLock(lock.lockKey, lock.lockValue).catch((err) => {
+          this.logger.warn(`Failed to release lock for "${key}": ${err.message}`);
+        });
+      }
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async clearKey(key) {
+    const flight = this.flights.get(key);
+    if (flight) {
+      flight.reject(new Error("Flight cancelled"));
+      this.flights.delete(key);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async clearAll() {
+    for (const [, flight] of this.flights.entries()) {
+      flight.reject(new Error("All flights cancelled"));
+    }
+    this.flights.clear();
+  }
+  getStats() {
+    const stats = {
+      activeFlights: this.flights.size,
+      totalWaiters: 0,
+      oldestFlight: 0,
+      prevented: this.prevented
+    };
+    const now = Date.now();
+    let oldestTimestamp = now;
+    for (const flight of this.flights.values()) {
+      stats.totalWaiters += flight.waiters;
+      if (flight.timestamp < oldestTimestamp) {
+        oldestTimestamp = flight.timestamp;
+      }
+    }
+    stats.oldestFlight = stats.activeFlights > 0 ? now - oldestTimestamp : 0;
+    return stats;
+  }
+  async waitForFlight(flight, key) {
+    const age = Date.now() - flight.timestamp;
+    if (age > this.lockTimeout) {
+      throw new StampedeError(key, age);
+    }
+    let timeoutId;
+    let timeoutCancelled = false;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        if (!timeoutCancelled) {
+          reject(new StampedeError(key, this.waitTimeout));
+        }
+      }, this.waitTimeout);
+    });
+    try {
+      const result = await Promise.race([flight.promise, timeoutPromise]);
+      timeoutCancelled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      return result;
+    } catch (error) {
+      timeoutCancelled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async executeLoader(loader, key) {
+    let timeoutId;
+    let timeoutCancelled = false;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        if (!timeoutCancelled) {
+          reject(new StampedeError(key, this.lockTimeout));
+        }
+      }, this.lockTimeout);
+    });
+    try {
+      const result = await Promise.race([loader(), timeoutPromise]);
+      timeoutCancelled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      return result;
+    } catch (error) {
+      timeoutCancelled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      if (error instanceof StampedeError) {
+        throw error;
+      }
+      throw new LoaderError(key, error);
+    }
+  }
+  async tryAcquireLock(lockKey, lockValue, ttlSeconds) {
+    try {
+      const result = await this.driver.set(lockKey, lockValue, { ex: ttlSeconds, nx: true });
+      return result === "OK";
+    } catch (error) {
+      this.logger.warn(`Failed to acquire distributed lock: ${error.message}`);
+      return false;
+    }
+  }
+  async releaseLock(lockKey, lockValue) {
+    try {
+      await this.driver.eval(RELEASE_LOCK_SCRIPT, [lockKey], [lockValue]);
+    } catch (error) {
+      this.logger.warn(`Failed to release distributed lock: ${error.message}`);
+    }
+  }
+  generateLockValue() {
+    return `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  }
+};
+StampedeProtectionService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(CACHE_PLUGIN_OPTIONS)),
+  __decorateParam(1, common.Inject(core.REDIS_DRIVER))
+], StampedeProtectionService);
+var SwrManagerService = class {
+  constructor(options) {
+    this.options = options;
+    this.enabled = options.swr?.enabled ?? false;
+    this.staleTtl = options.swr?.defaultStaleTime ?? 60;
+  }
+  logger = new common.Logger(SwrManagerService.name);
+  jobs = /* @__PURE__ */ new Map();
+  staleTtl;
+  enabled;
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async get(_key) {
+    return null;
+  }
+  async set(_key, _value, _staleTimeSeconds) {
+  }
+  async delete(_key) {
+  }
+  isStale(entry) {
+    if (!this.enabled) {
+      return false;
+    }
+    const now = Date.now();
+    return now > entry.staleAt;
+  }
+  isExpired(entry) {
+    const now = Date.now();
+    return now > entry.expiresAt;
+  }
+  shouldRevalidate(key) {
+    return !this.jobs.has(key);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async scheduleRevalidation(key, loader, onSuccess, onError) {
+    if (this.jobs.has(key)) {
+      this.logger.debug(`Revalidation already scheduled for key: ${key}`);
+      return;
+    }
+    const job = {
+      key,
+      loader,
+      onSuccess,
+      onError: onError ?? ((error) => this.logger.error(`Revalidation failed for ${key}:`, error)),
+      timestamp: Date.now()
+    };
+    this.jobs.set(key, job);
+    setImmediate(() => {
+      void this.executeRevalidation(job);
+    });
+  }
+  createSwrEntry(value, freshTtl, staleTtl) {
+    const now = Date.now();
+    const freshTtlMs = freshTtl * 1e3;
+    const staleTtlMs = (staleTtl ?? this.staleTtl) * 1e3;
+    return {
+      value,
+      cachedAt: now,
+      staleAt: now + freshTtlMs,
+      expiresAt: now + freshTtlMs + staleTtlMs
+    };
+  }
+  getStats() {
+    return {
+      activeRevalidations: this.jobs.size,
+      enabled: this.enabled,
+      staleTtl: this.staleTtl
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async clearRevalidations() {
+    this.jobs.clear();
+  }
+  async executeRevalidation(job) {
+    try {
+      this.logger.debug(`Starting revalidation for key: ${job.key}`);
+      const value = await job.loader();
+      this.logger.debug(`Revalidation successful for key: ${job.key}`);
+      await job.onSuccess(value);
+    } catch (error) {
+      this.logger.error(`Revalidation failed for key: ${job.key}`, error);
+      job.onError(error);
+    } finally {
+      this.jobs.delete(job.key);
+    }
+  }
+};
+SwrManagerService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(CACHE_PLUGIN_OPTIONS))
+], SwrManagerService);
+var TAG_BATCH_SIZE = 100;
+var TagIndexRepository = class {
+  constructor(driver, options, luaLoader) {
+    this.driver = driver;
+    this.options = options;
+    this.luaLoader = luaLoader;
+    const l2Prefix = options.l2?.keyPrefix ?? "cache:";
+    const tagIndexPrefix = options.tags?.indexPrefix ?? "_tag:";
+    this.tagPrefix = `${l2Prefix}${tagIndexPrefix}`;
+  }
+  tagPrefix;
+  async addKeyToTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    try {
+      const validatedTags = this.validateTags(tags);
+      const tagTtl = this.options.tags?.ttl ?? this.options.l2?.maxTtl ?? 86400;
+      const operations = validatedTags.map(async (tag) => {
+        const tagKey = this.buildTagKey(tag);
+        await this.driver.sadd(tagKey, key);
+        await this.driver.expire(tagKey, tagTtl);
+      });
+      await Promise.all(operations);
+    } catch (error) {
+      throw new TagInvalidationError(tags[0] ?? "unknown", `Failed to add key "${key}" to tags [${tags.join(", ")}]: ${error.message}`, error);
+    }
+  }
+  async removeKeyFromTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    try {
+      const validatedTags = this.validateTags(tags);
+      await Promise.all(
+        validatedTags.map(async (tag) => {
+          const tagKey = this.buildTagKey(tag);
+          await this.driver.srem(tagKey, key);
+        })
+      );
+    } catch (error) {
+      throw new TagInvalidationError(tags[0] ?? "unknown", `Failed to remove key "${key}" from tags [${tags.join(", ")}]: ${error.message}`, error);
+    }
+  }
+  async getKeysByTag(tag) {
+    try {
+      const validTag = Tag.create(tag);
+      const tagKey = this.buildTagKey(validTag.toString());
+      const keys = await this.driver.smembers(tagKey);
+      return keys;
+    } catch (error) {
+      throw new TagInvalidationError(tag, `Failed to get keys for tag: ${error.message}`, error);
+    }
+  }
+  async invalidateTag(tag) {
+    try {
+      const validTag = Tag.create(tag);
+      const tagKey = this.buildTagKey(validTag.toString());
+      const cacheKeys = await this.driver.smembers(tagKey);
+      if (cacheKeys.length === 0) {
+        await this.driver.del(tagKey);
+        return 0;
+      }
+      let deletedCount = 0;
+      const batchSize = TAG_BATCH_SIZE;
+      for (let i = 0; i < cacheKeys.length; i += batchSize) {
+        const batch = cacheKeys.slice(i, i + batchSize);
+        const results = await Promise.all(batch.map((key) => this.driver.del(key)));
+        deletedCount += results.reduce((sum, result) => sum + result, 0);
+      }
+      await this.driver.del(tagKey);
+      return deletedCount;
+    } catch (error) {
+      throw new TagInvalidationError(tag, `Failed to invalidate tag: ${error.message}`, error);
+    }
+  }
+  async invalidateTags(tags) {
+    if (tags.length === 0) {
+      return 0;
+    }
+    try {
+      const validatedTags = this.validateTags(tags);
+      let totalInvalidated = 0;
+      for (const tag of validatedTags) {
+        const count = await this.invalidateTag(tag);
+        totalInvalidated += count;
+      }
+      return totalInvalidated;
+    } catch (error) {
+      throw new TagInvalidationError(tags[0] ?? "unknown", `Failed to invalidate tags [${tags.join(", ")}]: ${error.message}`, error);
+    }
+  }
+  async clearAllTags() {
+    try {
+      const pattern = `${this.tagPrefix}*`;
+      const keys = await this.scanKeys(pattern);
+      if (keys.length === 0) {
+        return;
+      }
+      const batchSize = TAG_BATCH_SIZE;
+      for (let i = 0; i < keys.length; i += batchSize) {
+        const batch = keys.slice(i, i + batchSize);
+        await Promise.all(batch.map((key) => this.driver.del(key)));
+      }
+    } catch (error) {
+      throw new TagInvalidationError("_all", `Failed to clear all tags: ${error.message}`, error);
+    }
+  }
+  async getTagStats(tag) {
+    try {
+      const validTag = Tag.create(tag);
+      const tagKey = this.buildTagKey(validTag.toString());
+      const exists = await this.driver.exists(tagKey) > 0;
+      const keyCount = exists ? await this.driver.scard(tagKey) : 0;
+      return { keyCount, exists };
+    } catch {
+      return { keyCount: 0, exists: false };
+    }
+  }
+  /**
+   * Validates tags using Tags value object.
+   *
+   * @param tags - Array of tag strings
+   * @returns Array of validated tag strings
+   * @throws CacheError if validation fails
+   * @private
+   */
+  validateTags(tags) {
+    const maxTags = this.options.tags?.maxTagsPerKey ?? 10;
+    const tagsVo = Tags.create(tags, maxTags);
+    return tagsVo.toStrings();
+  }
+  buildTagKey(tag) {
+    return `${this.tagPrefix}${tag}`;
+  }
+  async scanKeys(pattern) {
+    const keys = [];
+    let cursor = 0;
+    do {
+      const result = await this.driver.scan(cursor, {
+        match: pattern,
+        count: TAG_BATCH_SIZE
+      });
+      cursor = parseInt(result[0], 10);
+      keys.push(...result[1]);
+    } while (cursor !== 0);
+    return keys;
+  }
+};
+TagIndexRepository = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(1, common.Inject(CACHE_PLUGIN_OPTIONS)),
+  __decorateParam(2, common.Inject(LUA_SCRIPT_LOADER))
+], TagIndexRepository);
+
+// src/tags/infrastructure/scripts/lua-scripts.ts
+var ADD_KEY_TO_TAGS_SCRIPT = `
+local cache_key = ARGV[1]
+local tag_ttl = tonumber(ARGV[2])
+
+for i = 1, #KEYS do
+  local tag_key = KEYS[i]
+  redis.call('SADD', tag_key, cache_key)
+  redis.call('EXPIRE', tag_key, tag_ttl)
+end
+
+return #KEYS
+`.trim();
+var INVALIDATE_TAG_SCRIPT = `
+local tag_key = KEYS[1]
+
+-- Get all cache keys for this tag
+local cache_keys = redis.call('SMEMBERS', tag_key)
+
+if #cache_keys == 0 then
+  -- Delete empty tag set and return 0
+  redis.call('DEL', tag_key)
+  return 0
+end
+
+-- Delete all cache keys
+local deleted = 0
+for i = 1, #cache_keys do
+  local result = redis.call('DEL', cache_keys[i])
+  deleted = deleted + result
+end
+
+-- Delete the tag set itself
+redis.call('DEL', tag_key)
+
+return deleted
+`.trim();
+
+// src/tags/infrastructure/services/lua-script-loader.service.ts
+var SCRIPTS = {
+  "invalidate-tag": INVALIDATE_TAG_SCRIPT,
+  "add-key-to-tags": ADD_KEY_TO_TAGS_SCRIPT
+};
+var LuaScriptLoader = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  logger = new common.Logger(LuaScriptLoader.name);
+  scriptShas = /* @__PURE__ */ new Map();
+  async onModuleInit() {
+    await this.loadScripts();
+  }
+  /**
+   * Loads all Lua scripts into Redis.
+   */
+  async loadScripts() {
+    for (const [scriptName, scriptContent] of Object.entries(SCRIPTS)) {
+      try {
+        const sha = await this.driver.scriptLoad(scriptContent);
+        this.scriptShas.set(scriptName, sha);
+        this.logger.debug(`Loaded Lua script: ${scriptName} (SHA: ${sha})`);
+      } catch (error) {
+        this.logger.error(`Failed to load script ${scriptName}:`, error);
+        throw error;
+      }
+    }
+    this.logger.log(`Successfully loaded ${this.scriptShas.size} Lua scripts`);
+  }
+  /**
+   * Executes a Lua script by name using EVALSHA.
+   *
+   * @param scriptName - Name of the script
+   * @param keys - Redis keys to pass to the script
+   * @param args - Arguments to pass to the script
+   * @returns Script execution result
+   */
+  async evalSha(scriptName, keys, args) {
+    const sha = this.scriptShas.get(scriptName);
+    if (!sha) {
+      throw new Error(`Lua script not loaded: ${scriptName}`);
+    }
+    return this.driver.evalsha(sha, keys, args);
+  }
+  /**
+   * Gets the SHA hash of a loaded script.
+   *
+   * @param scriptName - Name of the script
+   * @returns SHA hash or undefined if not loaded
+   */
+  getSha(scriptName) {
+    return this.scriptShas.get(scriptName);
+  }
+  /**
+   * Checks if a script is loaded.
+   *
+   * @param scriptName - Name of the script
+   * @returns True if script is loaded
+   */
+  isLoaded(scriptName) {
+    return this.scriptShas.has(scriptName);
+  }
+};
+LuaScriptLoader = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER))
+], LuaScriptLoader);
+
+// src/cache.plugin.ts
+var CachePlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "cache";
+  version = "0.1.0";
+  description = "Advanced caching with L1+L2, anti-stampede, SWR, and tag invalidation";
+  getProviders() {
+    const config = {
+      l1: { ...DEFAULT_CACHE_CONFIG.l1, ...this.options.l1 },
+      l2: { ...DEFAULT_CACHE_CONFIG.l2, ...this.options.l2 },
+      stampede: { ...DEFAULT_CACHE_CONFIG.stampede, ...this.options.stampede },
+      swr: { ...DEFAULT_CACHE_CONFIG.swr, ...this.options.swr },
+      tags: { ...DEFAULT_CACHE_CONFIG.tags, ...this.options.tags },
+      warmup: { ...DEFAULT_CACHE_CONFIG.warmup, ...this.options.warmup },
+      keys: { ...DEFAULT_CACHE_CONFIG.keys, ...this.options.keys },
+      invalidation: {
+        ...DEFAULT_CACHE_CONFIG.invalidation,
+        ...this.options.invalidation
+      }
+    };
+    return [
+      // Configuration
+      {
+        provide: CACHE_PLUGIN_OPTIONS,
+        useValue: config
+      },
+      // Domain services
+      {
+        provide: SERIALIZER,
+        useClass: Serializer
+      },
+      // Infrastructure adapters
+      {
+        provide: L1_CACHE_STORE,
+        useClass: L1MemoryStoreAdapter
+      },
+      {
+        provide: L2_CACHE_STORE,
+        useClass: L2RedisStoreAdapter
+      },
+      // Application services
+      {
+        provide: CACHE_SERVICE,
+        useClass: CacheService
+      },
+      {
+        provide: STAMPEDE_PROTECTION,
+        useClass: StampedeProtectionService
+      },
+      {
+        provide: TAG_INDEX,
+        useClass: TagIndexRepository
+      },
+      {
+        provide: SWR_MANAGER,
+        useClass: SwrManagerService
+      },
+      {
+        provide: LUA_SCRIPT_LOADER,
+        useClass: LuaScriptLoader
+      },
+      // Invalidation services
+      {
+        provide: INVALIDATION_REGISTRY,
+        useClass: exports.InvalidationRegistryService
+      },
+      {
+        provide: EVENT_INVALIDATION_SERVICE,
+        useClass: exports.EventInvalidationService
+      },
+      // Invalidation adapters (optional)
+      AMQPEventSourceAdapter,
+      // Public API
+      exports.CacheService,
+      // @Cached decorator initialization
+      CacheDecoratorInitializerService,
+      // Cache warmup (runs on OnModuleInit if enabled)
+      WarmupService,
+      // Reflector is needed for decorator metadata
+      core$1.Reflector,
+      // Factory for registering static invalidation rules
+      {
+        provide: INVALIDATION_RULES_INIT,
+        useFactory: (registry, config2) => {
+          if (config2.invalidation?.rules && config2.invalidation.rules.length > 0) {
+            const rules = config2.invalidation.rules.map((ruleProps) => InvalidationRule.create(ruleProps));
+            registry.registerMany(rules);
+          }
+          return true;
+        },
+        inject: [INVALIDATION_REGISTRY, CACHE_PLUGIN_OPTIONS]
+      }
+    ];
+  }
+  getExports() {
+    return [CACHE_PLUGIN_OPTIONS, CACHE_SERVICE, exports.CacheService, INVALIDATION_REGISTRY, EVENT_INVALIDATION_SERVICE];
+  }
+};
+var logger2 = new common.Logger("InvalidateTags");
+function InvalidateTags(options) {
+  return (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    const when = options.when ?? "after";
+    descriptor.value = async function(...args) {
+      const cacheService = getCacheService();
+      const tags = typeof options.tags === "function" ? options.tags(...args) : options.tags;
+      if (when === "before" && cacheService && tags.length > 0) {
+        try {
+          await cacheService.invalidateTags(tags);
+        } catch (error) {
+          logger2.error(`@InvalidateTags: Failed to invalidate tags before method:`, error);
+        }
+      }
+      const result = await originalMethod.apply(this, args);
+      if (when === "after" && cacheService && tags.length > 0) {
+        try {
+          await cacheService.invalidateTags(tags);
+        } catch (error) {
+          logger2.error(`@InvalidateTags: Failed to invalidate tags after method:`, error);
+        }
+      }
+      return result;
+    };
+    Object.defineProperty(descriptor.value, "name", {
+      value: originalMethod.name,
+      writable: false
+    });
+    Reflect.defineMetadata(INVALIDATE_TAGS_KEY, options, descriptor.value);
+    return descriptor;
+  };
+}
+var CACHEABLE_METADATA_KEY = "cache:cacheable";
+function Cacheable(options) {
+  return common.SetMetadata(CACHEABLE_METADATA_KEY, options);
+}
+var CACHE_PUT_METADATA_KEY = "cache:put";
+function CachePut(options) {
+  return common.SetMetadata(CACHE_PUT_METADATA_KEY, options);
+}
+var CACHE_EVICT_METADATA_KEY = "cache:evict";
+function CacheEvict(options = {}) {
+  return common.SetMetadata(CACHE_EVICT_METADATA_KEY, options);
+}
+
+// src/decorators/key-generator.util.ts
+function getParameterNames(method) {
+  const fnStr = method.toString().replace(/\/\*[\s\S]*?\*\//g, "");
+  const match = fnStr.match(/\(([^)]*)\)/);
+  if (!match?.[1]) {
+    return [];
+  }
+  const params = match[1];
+  return params.split(",").map((param) => param.trim().split("=")[0]?.trim() ?? "").filter((param) => param && param !== "");
+}
+function getNestedValue(obj, path) {
+  if (!obj || typeof obj !== "object") {
+    return void 0;
+  }
+  const keys = path.split(".");
+  let value = obj;
+  for (const key of keys) {
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    value = value[key];
+  }
+  return value;
+}
+function generateKey(template, method, args, namespace) {
+  const paramNames = getParameterNames(method);
+  const paramMap = /* @__PURE__ */ new Map();
+  paramNames.forEach((name, index) => {
+    if (index < args.length) {
+      paramMap.set(name, args[index]);
+    }
+  });
+  let key = template;
+  const placeholderRegex = /\{([^}]+)\}/g;
+  const matches = Array.from(template.matchAll(placeholderRegex));
+  if (matches.length === 0) {
+    return namespace ? `${namespace}:${template}` : template;
+  }
+  for (const match of matches) {
+    const placeholder = match[0];
+    const path = match[1];
+    if (!path) {
+      continue;
+    }
+    let value;
+    if (path.includes(".")) {
+      const [rootParam, ...nestedPath] = path.split(".");
+      if (!rootParam) {
+        throw new CacheKeyError(template, "Invalid nested property path");
+      }
+      const rootValue = paramMap.get(rootParam);
+      if (rootValue === void 0) {
+        throw new CacheKeyError(template, `Parameter '${rootParam}' not found in method signature`);
+      }
+      value = getNestedValue(rootValue, nestedPath.join("."));
+      if (value === void 0) {
+        throw new CacheKeyError(template, `Nested property '${path}' not found or is undefined`);
+      }
+    } else {
+      if (!paramMap.has(path)) {
+        throw new CacheKeyError(template, `Parameter '${path}' not found in method signature`);
+      }
+      value = paramMap.get(path);
+      if (value === void 0 || value === null) {
+        throw new CacheKeyError(template, `Parameter '${path}' is null or undefined`);
+      }
+    }
+    const stringValue = String(value);
+    if (stringValue.includes(":") || stringValue.includes("{") || stringValue.includes("}")) {
+      throw new CacheKeyError(template, `Parameter value '${stringValue}' contains invalid characters (:, {, })`);
+    }
+    key = key.replace(placeholder, stringValue);
+  }
+  if (namespace) {
+    key = `${namespace}:${key}`;
+  }
+  return key;
+}
+function generateKeys(templates, method, args, namespace) {
+  return templates.map((template) => generateKey(template, method, args, namespace));
+}
+function evaluateTags(tags, args) {
+  if (!tags) {
+    return [];
+  }
+  if (typeof tags === "function") {
+    return tags(...args);
+  }
+  return tags;
+}
+function evaluateCondition(condition, args) {
+  if (!condition) {
+    return true;
+  }
+  return condition(...args);
+}
+exports.DeclarativeCacheInterceptor = class CacheInterceptor {
+  constructor(cacheService, reflector) {
+    this.cacheService = cacheService;
+    this.reflector = reflector;
+  }
+  logger = new common.Logger(exports.DeclarativeCacheInterceptor.name);
+  intercept(context, next) {
+    const handler = context.getHandler();
+    context.getClass();
+    const cacheableOptions = this.reflector.get(CACHEABLE_METADATA_KEY, handler);
+    const cachePutOptions = this.reflector.get(CACHE_PUT_METADATA_KEY, handler);
+    const cacheEvictOptions = this.reflector.get(CACHE_EVICT_METADATA_KEY, handler);
+    const args = context.getArgByIndex(context.getArgs().length - 1) ? context.getArgs() : [];
+    const method = handler;
+    if (cacheableOptions) {
+      return this.handleCacheable(cacheableOptions, method, args, next);
+    }
+    if (cachePutOptions) {
+      return this.handleCachePut(cachePutOptions, method, args, next);
+    }
+    if (cacheEvictOptions) {
+      return this.handleCacheEvict(cacheEvictOptions, method, args, next);
+    }
+    return next.handle();
+  }
+  /**
+   * Handles @Cacheable decorator.
+   * Returns cached value or executes method and caches result.
+   */
+  handleCacheable(options, method, args, next) {
+    if (!evaluateCondition(options.condition, args)) {
+      this.logger.debug("Cacheable condition not met, executing method");
+      return next.handle();
+    }
+    try {
+      const key = options.keyGenerator ? options.keyGenerator(...args) : generateKey(options.key, method, args, options.namespace);
+      this.logger.debug(`Cacheable: checking cache for key: ${key}`);
+      return rxjs.from(this.cacheService.get(key)).pipe(
+        operators.switchMap((cachedValue) => {
+          if (cachedValue !== null) {
+            this.logger.debug(`Cacheable: cache hit for key: ${key}`);
+            return rxjs.of(cachedValue);
+          }
+          this.logger.debug(`Cacheable: cache miss for key: ${key}, executing method`);
+          return next.handle().pipe(
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            operators.tap(async (result) => {
+              const tags = evaluateTags(options.tags, args);
+              const ttl = options.ttl ?? 3600;
+              try {
+                await this.cacheService.set(key, result, { ttl, tags });
+                this.logger.debug(`Cacheable: cached result for key: ${key}`);
+              } catch (error) {
+                this.logger.error(`Cacheable: failed to cache result for key ${key}: ${error.message}`);
+              }
+            })
+          );
+        })
+      );
+    } catch (error) {
+      this.logger.error(`Cacheable: error processing cache: ${error.message}`);
+      return next.handle();
+    }
+  }
+  /**
+   * Handles @CachePut decorator.
+   * Always executes method and caches the result.
+   */
+  handleCachePut(options, method, args, next) {
+    if (!evaluateCondition(options.condition, args)) {
+      this.logger.debug("CachePut condition not met, executing method without caching");
+      return next.handle();
+    }
+    try {
+      const key = options.keyGenerator ? options.keyGenerator(...args) : generateKey(options.key, method, args, options.namespace);
+      this.logger.debug(`CachePut: executing method for key: ${key}`);
+      return next.handle().pipe(
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        operators.tap(async (result) => {
+          if ((result === null || result === void 0) && !options.cacheNullValues) {
+            this.logger.debug(`CachePut: skipping null/undefined result for key: ${key}`);
+            return;
+          }
+          const tags = evaluateTags(options.tags, args);
+          const ttl = options.ttl ?? 3600;
+          try {
+            await this.cacheService.set(key, result, { ttl, tags });
+            this.logger.debug(`CachePut: cached result for key: ${key}`);
+          } catch (error) {
+            this.logger.error(`CachePut: failed to cache result for key ${key}: ${error.message}`);
+          }
+        })
+      );
+    } catch (error) {
+      this.logger.error(`CachePut: error processing cache: ${error.message}`);
+      return next.handle();
+    }
+  }
+  /**
+   * Handles @CacheEvict decorator.
+   * Evicts cache entries before or after method execution.
+   */
+  handleCacheEvict(options, method, args, next) {
+    if (!evaluateCondition(options.condition, args)) {
+      this.logger.debug("CacheEvict condition not met, executing method without eviction");
+      return next.handle();
+    }
+    const evictFn = async () => {
+      try {
+        if (options.allEntries) {
+          this.logger.debug("CacheEvict: clearing all cache entries");
+          await this.cacheService.clear();
+          return;
+        }
+        if (options.tags && options.tags.length > 0) {
+          this.logger.debug(`CacheEvict: invalidating tags: ${options.tags.join(", ")}`);
+          await this.cacheService.invalidateTags(options.tags);
+        }
+        if (options.keys && options.keys.length > 0) {
+          const keys = options.keyGenerator ? options.keyGenerator(...args) : generateKeys(options.keys, method, args, options.namespace);
+          this.logger.debug(`CacheEvict: evicting keys: ${keys.join(", ")}`);
+          for (const key of keys) {
+            if (key.includes("*")) {
+              this.logger.warn(`CacheEvict: wildcard keys not supported: ${key}. Use tags instead.`);
+            } else {
+              await this.cacheService.del(key);
+            }
+          }
+        }
+      } catch (error) {
+        this.logger.error(`CacheEvict: error evicting cache: ${error.message}`);
+      }
+    };
+    if (options.beforeInvocation) {
+      return rxjs.from(evictFn()).pipe(operators.switchMap(() => next.handle()));
+    }
+    return next.handle().pipe(
+      operators.tap(() => {
+        void evictFn();
+      })
+    );
+  }
+};
+exports.DeclarativeCacheInterceptor = __decorateClass([
+  common.Injectable()
+], exports.DeclarativeCacheInterceptor);
+
+// src/strategies/lru.strategy.ts
+var LruStrategy = class {
+  /**
+   * Map maintaining keys in LRU order.
+   * JavaScript Map maintains insertion order, so we use delete+set to move to end.
+   */
+  keyOrder;
+  /**
+   * Timestamp counter for tracking access order
+   */
+  timestamp;
+  constructor() {
+    this.keyOrder = /* @__PURE__ */ new Map();
+    this.timestamp = 0;
+  }
+  /**
+   * Records access to a key, moving it to most recently used position.
+   *
+   * @param key - Key that was accessed
+   */
+  recordAccess(key) {
+    this.timestamp++;
+    this.keyOrder.set(key, this.timestamp);
+  }
+  /**
+   * Records insertion of a new key.
+   *
+   * @param key - Key that was inserted
+   */
+  recordInsert(key) {
+    this.timestamp++;
+    this.keyOrder.set(key, this.timestamp);
+  }
+  /**
+   * Records deletion of a key.
+   *
+   * @param key - Key that was deleted
+   */
+  recordDelete(key) {
+    this.keyOrder.delete(key);
+  }
+  /**
+   * Selects the least recently used key for eviction.
+   *
+   * @returns Least recently used key, or undefined if empty
+   */
+  selectVictim() {
+    if (this.keyOrder.size === 0) {
+      return void 0;
+    }
+    let oldestKey;
+    let oldestTimestamp = Infinity;
+    for (const [key, timestamp] of this.keyOrder.entries()) {
+      if (timestamp < oldestTimestamp) {
+        oldestTimestamp = timestamp;
+        oldestKey = key;
+      }
+    }
+    return oldestKey;
+  }
+  /**
+   * Clears all tracking data.
+   */
+  clear() {
+    this.keyOrder.clear();
+    this.timestamp = 0;
+  }
+  /**
+   * Gets current number of tracked keys.
+   *
+   * @returns Number of keys
+   */
+  size() {
+    return this.keyOrder.size;
+  }
+  /**
+   * Gets all keys in LRU order (oldest to newest).
+   *
+   * @returns Array of keys sorted by access time
+   */
+  getKeys() {
+    return Array.from(this.keyOrder.entries()).sort(([, a], [, b]) => a - b).map(([key]) => key);
+  }
+  /**
+   * Gets keys that should be evicted to reach target size.
+   *
+   * @param targetSize - Desired size after eviction
+   * @returns Array of keys to evict
+   */
+  getVictims(targetSize) {
+    const currentSize = this.keyOrder.size;
+    if (currentSize <= targetSize) {
+      return [];
+    }
+    const numToEvict = currentSize - targetSize;
+    const sortedKeys = this.getKeys();
+    return sortedKeys.slice(0, numToEvict);
+  }
+};
+
+// src/strategies/fifo.strategy.ts
+var FifoStrategy = class {
+  /**
+   * Queue maintaining keys in insertion order.
+   * First element is oldest (next to evict).
+   */
+  queue;
+  /**
+   * Set for O(1) existence checks
+   */
+  keySet;
+  constructor() {
+    this.queue = [];
+    this.keySet = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Records access to a key.
+   * In FIFO, access doesn't affect eviction order, so this is a no-op.
+   *
+   * @param _key - Key that was accessed
+   */
+  recordAccess(_key) {
+  }
+  /**
+   * Records insertion of a new key.
+   *
+   * @param key - Key that was inserted
+   */
+  recordInsert(key) {
+    if (!this.keySet.has(key)) {
+      this.queue.push(key);
+      this.keySet.add(key);
+    }
+  }
+  /**
+   * Records deletion of a key.
+   *
+   * @param key - Key that was deleted
+   */
+  recordDelete(key) {
+    if (this.keySet.has(key)) {
+      const index = this.queue.indexOf(key);
+      if (index !== -1) {
+        this.queue.splice(index, 1);
+      }
+      this.keySet.delete(key);
+    }
+  }
+  /**
+   * Selects the oldest inserted key for eviction.
+   *
+   * @returns Oldest key (first in queue), or undefined if empty
+   */
+  selectVictim() {
+    return this.queue[0];
+  }
+  /**
+   * Clears all tracking data.
+   */
+  clear() {
+    this.queue.length = 0;
+    this.keySet.clear();
+  }
+  /**
+   * Gets current number of tracked keys.
+   *
+   * @returns Number of keys
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Gets all keys in FIFO order (oldest to newest).
+   *
+   * @returns Array of keys in insertion order
+   */
+  getKeys() {
+    return [...this.queue];
+  }
+  /**
+   * Gets keys that should be evicted to reach target size.
+   *
+   * @param targetSize - Desired size after eviction
+   * @returns Array of keys to evict (oldest first)
+   */
+  getVictims(targetSize) {
+    const currentSize = this.queue.length;
+    if (currentSize <= targetSize) {
+      return [];
+    }
+    const numToEvict = currentSize - targetSize;
+    return this.queue.slice(0, numToEvict);
+  }
+  /**
+   * Checks if a key is tracked.
+   *
+   * @param key - Key to check
+   * @returns True if key is tracked
+   */
+  has(key) {
+    return this.keySet.has(key);
+  }
+};
+
+// src/strategies/lfu.strategy.ts
+var LfuStrategy = class {
+  entries;
+  insertCounter;
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.insertCounter = 0;
+  }
+  /**
+   * Records access to a key, incrementing its frequency counter.
+   *
+   * @param key - Key that was accessed
+   */
+  recordAccess(key) {
+    const entry = this.entries.get(key);
+    if (entry) {
+      entry.frequency++;
+    }
+  }
+  /**
+   * Records insertion of a new key with initial frequency of 1.
+   *
+   * @param key - Key that was inserted
+   */
+  recordInsert(key) {
+    if (!this.entries.has(key)) {
+      this.insertCounter++;
+      this.entries.set(key, {
+        key,
+        frequency: 1,
+        insertOrder: this.insertCounter
+      });
+    }
+  }
+  /**
+   * Records deletion of a key.
+   *
+   * @param key - Key that was deleted
+   */
+  recordDelete(key) {
+    this.entries.delete(key);
+  }
+  /**
+   * Selects the least frequently used key for eviction.
+   * When frequencies are equal, the oldest inserted key is selected.
+   *
+   * @returns Least frequently used key, or undefined if empty
+   */
+  selectVictim() {
+    if (this.entries.size === 0) {
+      return void 0;
+    }
+    let victim;
+    for (const entry of this.entries.values()) {
+      if (!victim || entry.frequency < victim.frequency || entry.frequency === victim.frequency && entry.insertOrder < victim.insertOrder) {
+        victim = entry;
+      }
+    }
+    return victim?.key;
+  }
+  /**
+   * Clears all tracking data.
+   */
+  clear() {
+    this.entries.clear();
+    this.insertCounter = 0;
+  }
+  /**
+   * Gets current number of tracked keys.
+   *
+   * @returns Number of keys
+   */
+  size() {
+    return this.entries.size;
+  }
+  /**
+   * Gets all keys sorted by frequency (lowest first), then by insertion order.
+   *
+   * @returns Array of keys sorted by eviction priority
+   */
+  getKeys() {
+    return Array.from(this.entries.values()).sort((a, b) => a.frequency - b.frequency || a.insertOrder - b.insertOrder).map((entry) => entry.key);
+  }
+  /**
+   * Gets keys that should be evicted to reach target size.
+   *
+   * @param targetSize - Desired size after eviction
+   * @returns Array of keys to evict
+   */
+  getVictims(targetSize) {
+    const currentSize = this.entries.size;
+    if (currentSize <= targetSize) {
+      return [];
+    }
+    const numToEvict = currentSize - targetSize;
+    const sortedKeys = this.getKeys();
+    return sortedKeys.slice(0, numToEvict);
+  }
+  /**
+   * Checks if a key is tracked.
+   *
+   * @param key - Key to check
+   * @returns True if key is tracked
+   */
+  has(key) {
+    return this.entries.has(key);
+  }
+  /**
+   * Gets the frequency count for a key.
+   *
+   * @param key - Key to check
+   * @returns Frequency count, or 0 if key not tracked
+   */
+  getFrequency(key) {
+    return this.entries.get(key)?.frequency ?? 0;
+  }
+};
+
+// src/serializers/json.serializer.ts
+var JsonSerializer = class {
+  /**
+   * Serializes value to JSON string.
+   *
+   * @param value - Value to serialize
+   * @returns JSON string
+   * @throws SerializationError if serialization fails
+   */
+  serialize(value) {
+    try {
+      return JSON.stringify(value);
+    } catch (error) {
+      throw new SerializationError(`JSON serialization failed: ${error.message}`, error);
+    }
+  }
+  /**
+   * Deserializes JSON string back to value.
+   *
+   * @param data - JSON string or buffer
+   * @returns Deserialized value
+   * @throws SerializationError if deserialization fails
+   */
+  deserialize(data) {
+    try {
+      const str = Buffer.isBuffer(data) ? data.toString("utf8") : data;
+      return JSON.parse(str);
+    } catch (error) {
+      throw new SerializationError(`JSON deserialization failed: ${error.message}`, error);
+    }
+  }
+  /**
+   * Safely tries to deserialize, returns null on error.
+   *
+   * @param data - JSON string or buffer
+   * @returns Deserialized value or null
+   */
+  tryDeserialize(data) {
+    try {
+      return this.deserialize(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Gets content type for JSON.
+   *
+   * @returns Content type string
+   */
+  getContentType() {
+    return "application/json";
+  }
+};
+
+// src/serializers/msgpack.serializer.ts
+var MsgpackSerializer = class {
+  encoder;
+  decoder;
+  constructor() {
+    try {
+      const msgpackr = __require("msgpackr");
+      this.encoder = new msgpackr.Encoder({
+        useRecords: false,
+        // Don't use msgpack extension records
+        structuredClone: true
+        // Deep clone objects
+      });
+      this.decoder = new msgpackr.Decoder({
+        useRecords: false
+      });
+    } catch {
+      throw new Error("msgpackr package is required for MsgpackSerializer. Install with: npm install msgpackr");
+    }
+  }
+  /**
+   * Serializes value to MessagePack buffer.
+   *
+   * @param value - Value to serialize
+   * @returns MessagePack buffer
+   * @throws SerializationError if serialization fails
+   */
+  serialize(value) {
+    try {
+      return this.encoder.encode(value);
+    } catch (error) {
+      throw new SerializationError(`MessagePack serialization failed: ${error.message}`, error);
+    }
+  }
+  /**
+   * Deserializes MessagePack buffer back to value.
+   *
+   * @param data - MessagePack buffer or string
+   * @returns Deserialized value
+   * @throws SerializationError if deserialization fails
+   */
+  deserialize(data) {
+    try {
+      const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, "binary");
+      return this.decoder.decode(buffer);
+    } catch (error) {
+      throw new SerializationError(`MessagePack deserialization failed: ${error.message}`, error);
+    }
+  }
+  /**
+   * Safely tries to deserialize, returns null on error.
+   *
+   * @param data - MessagePack buffer or string
+   * @returns Deserialized value or null
+   */
+  tryDeserialize(data) {
+    try {
+      return this.deserialize(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Gets content type for MessagePack.
+   *
+   * @returns Content type string
+   */
+  getContentType() {
+    return "application/msgpack";
+  }
+  /**
+   * Compares serialized size with JSON.
+   *
+   * @param value - Value to compare
+   * @returns Object with sizes and compression ratio
+   */
+  compareWithJson(value) {
+    const jsonSize = Buffer.from(JSON.stringify(value), "utf8").length;
+    const msgpackSize = this.serialize(value).length;
+    return {
+      jsonSize,
+      msgpackSize,
+      compressionRatio: jsonSize / msgpackSize
+    };
+  }
+};
+
+// src/key-builder.ts
+var KeyBuilder = class _KeyBuilder {
+  keySegments = [];
+  options;
+  constructor(options = {}) {
+    this.options = {
+      separator: options.separator ?? ":",
+      maxLength: options.maxLength ?? 512,
+      validate: options.validate ?? true,
+      lowercase: options.lowercase ?? false
+    };
+  }
+  /**
+   * Creates a new KeyBuilder instance.
+   *
+   * @param options - Builder options
+   * @returns New KeyBuilder
+   */
+  static create(options) {
+    return new _KeyBuilder(options);
+  }
+  /**
+   * Creates a key from a template string with placeholders.
+   *
+   * @param template - Template string (e.g., 'user:{id}:post:{postId}')
+   * @param params - Parameter values
+   * @param options - Builder options
+   * @returns Generated key
+   *
+   * @example
+   * ```typescript
+   * KeyBuilder.fromTemplate('user:{id}', { id: '123' })
+   * // 'user:123'
+   *
+   * KeyBuilder.fromTemplate('user:{userId}:post:{postId}', {
+   *   userId: '123',
+   *   postId: '456',
+   * })
+   * // 'user:123:post:456'
+   * ```
+   */
+  static fromTemplate(template, params, options) {
+    let result = template;
+    const placeholderRegex = /\{([^}]+)\}/g;
+    const matches = Array.from(template.matchAll(placeholderRegex));
+    for (const match of matches) {
+      const placeholder = match[0];
+      const paramName = match[1];
+      if (!paramName) {
+        continue;
+      }
+      if (!(paramName in params)) {
+        throw new CacheKeyError(template, `Parameter '${paramName}' not found in params`);
+      }
+      const value = params[paramName];
+      if (value === null || value === void 0) {
+        throw new CacheKeyError(template, `Parameter '${paramName}' is null or undefined`);
+      }
+      result = result.replace(placeholder, String(value));
+    }
+    const builder = new _KeyBuilder(options);
+    builder.validateKey(result);
+    return result;
+  }
+  /**
+   * Creates a key from an array of segments.
+   *
+   * @param segments - Array of key segments
+   * @param options - Builder options
+   * @returns Generated key
+   */
+  static fromSegments(segments, options) {
+    const builder = new _KeyBuilder(options);
+    segments.forEach((segment) => builder.segment(segment));
+    return builder.build();
+  }
+  /**
+   * Adds a namespace segment (first segment).
+   *
+   * @param ns - Namespace value
+   * @returns This builder for chaining
+   */
+  namespace(ns) {
+    this.keySegments.unshift(this.normalizeSegment(ns));
+    return this;
+  }
+  /**
+   * Adds a prefix segment.
+   *
+   * @param prefix - Prefix value
+   * @returns This builder for chaining
+   */
+  prefix(prefix) {
+    return this.segment(prefix);
+  }
+  /**
+   * Adds a version segment.
+   *
+   * @param version - Version value (e.g., 'v1', 'v2')
+   * @returns This builder for chaining
+   */
+  version(version) {
+    return this.segment(version);
+  }
+  /**
+   * Adds a segment to the key.
+   *
+   * @param value - Segment value
+   * @returns This builder for chaining
+   */
+  segment(value) {
+    this.keySegments.push(this.normalizeSegment(String(value)));
+    return this;
+  }
+  /**
+   * Adds multiple segments at once.
+   *
+   * @param values - Array of segment values
+   * @returns This builder for chaining
+   */
+  segments(...values) {
+    values.forEach((value) => this.segment(value));
+    return this;
+  }
+  /**
+   * Adds a tag segment (useful for grouping).
+   *
+   * @param tag - Tag value
+   * @returns This builder for chaining
+   */
+  tag(tag) {
+    this.segment("tag");
+    this.segment(tag);
+    return this;
+  }
+  /**
+   * Adds timestamp segment.
+   *
+   * @param timestamp - Unix timestamp (default: now)
+   * @returns This builder for chaining
+   */
+  timestamp(timestamp) {
+    return this.segment(timestamp ?? Date.now());
+  }
+  /**
+   * Adds a hash segment from an object.
+   * Useful for cache keys based on complex objects.
+   *
+   * @param obj - Object to hash
+   * @returns This builder for chaining
+   */
+  hash(obj) {
+    const hash = this.simpleHash(JSON.stringify(obj));
+    return this.segment(hash);
+  }
+  /**
+   * Builds and returns the final key.
+   *
+   * @returns Generated cache key
+   * @throws CacheKeyError if key is invalid
+   */
+  build() {
+    if (this.keySegments.length === 0) {
+      throw new CacheKeyError("", "Cannot build key with no segments");
+    }
+    const key = this.keySegments.join(this.options.separator);
+    this.validateKey(key);
+    return key;
+  }
+  /**
+   * Resets the builder to initial state.
+   *
+   * @returns This builder for chaining
+   */
+  reset() {
+    this.keySegments = [];
+    return this;
+  }
+  /**
+   * Gets current segments.
+   *
+   * @returns Array of segments
+   */
+  getSegments() {
+    return [...this.keySegments];
+  }
+  /**
+   * Normalizes a segment value.
+   *
+   * @param value - Segment value
+   * @returns Normalized value
+   */
+  normalizeSegment(value) {
+    let normalized = value.trim();
+    if (this.options.lowercase) {
+      normalized = normalized.toLowerCase();
+    }
+    if (this.options.validate) {
+      const invalidChars = [this.options.separator, "{", "}", " ", "\n", "\r", "	"];
+      for (const char of invalidChars) {
+        if (normalized.includes(char)) {
+          throw new CacheKeyError(normalized, `Segment contains invalid character: '${char}'`);
+        }
+      }
+      if (normalized.length === 0) {
+        throw new CacheKeyError(normalized, "Segment cannot be empty");
+      }
+    }
+    return normalized;
+  }
+  /**
+   * Validates a complete key.
+   *
+   * @param key - Key to validate
+   * @throws CacheKeyError if key is invalid
+   */
+  validateKey(key) {
+    if (!this.options.validate) {
+      return;
+    }
+    if (key.length === 0) {
+      throw new CacheKeyError(key, "Key cannot be empty");
+    }
+    if (key.length > this.options.maxLength) {
+      throw new CacheKeyError(key, `Key length ${key.length} exceeds maximum ${this.options.maxLength}`);
+    }
+    if (key.startsWith(this.options.separator) || key.endsWith(this.options.separator)) {
+      throw new CacheKeyError(key, "Key cannot start or end with separator");
+    }
+    const consecutiveSeparators = this.options.separator + this.options.separator;
+    if (key.includes(consecutiveSeparators)) {
+      throw new CacheKeyError(key, "Key cannot contain consecutive separators");
+    }
+  }
+  /**
+   * Simple hash function for objects.
+   *
+   * @param str - String to hash
+   * @returns Hash string
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+};
+
+exports.AMQP_CONNECTION = AMQP_CONNECTION;
+exports.CACHE_OPTIONS_KEY = CACHE_OPTIONS_KEY;
+exports.CACHE_PLUGIN_OPTIONS = CACHE_PLUGIN_OPTIONS;
+exports.CACHE_SERVICE = CACHE_SERVICE;
+exports.CacheEntry = CacheEntry;
+exports.CacheError = CacheError;
+exports.CacheEvict = CacheEvict;
+exports.CacheKey = CacheKey;
+exports.CacheKeyError = CacheKeyError;
+exports.CachePlugin = CachePlugin;
+exports.CachePut = CachePut;
+exports.Cacheable = Cacheable;
+exports.Cached = Cached;
+exports.DEFAULT_CACHE_CONFIG = DEFAULT_CACHE_CONFIG;
+exports.EVENT_INVALIDATION_SERVICE = EVENT_INVALIDATION_SERVICE;
+exports.EventPattern = EventPattern;
+exports.FifoStrategy = FifoStrategy;
+exports.INVALIDATE_TAGS_KEY = INVALIDATE_TAGS_KEY;
+exports.INVALIDATION_REGISTRY = INVALIDATION_REGISTRY;
+exports.InvalidateOn = InvalidateOn;
+exports.InvalidateTags = InvalidateTags;
+exports.InvalidationRule = InvalidationRule;
+exports.JsonSerializer = JsonSerializer;
+exports.KeyBuilder = KeyBuilder;
+exports.L1_CACHE_STORE = L1_CACHE_STORE;
+exports.L2_CACHE_STORE = L2_CACHE_STORE;
+exports.LUA_SCRIPT_LOADER = LUA_SCRIPT_LOADER;
+exports.LfuStrategy = LfuStrategy;
+exports.LoaderError = LoaderError;
+exports.LruStrategy = LruStrategy;
+exports.MsgpackSerializer = MsgpackSerializer;
+exports.SERIALIZER = SERIALIZER;
+exports.STAMPEDE_PROTECTION = STAMPEDE_PROTECTION;
+exports.SWR_MANAGER = SWR_MANAGER;
+exports.SerializationError = SerializationError;
+exports.StampedeError = StampedeError;
+exports.TAG_INDEX = TAG_INDEX;
+exports.TTL = TTL;
+exports.TagInvalidationError = TagInvalidationError;
+exports.TagTemplate = TagTemplate;
+exports.evaluateCondition = evaluateCondition;
+exports.evaluateTags = evaluateTags;
+exports.generateKey = generateKey;
+exports.generateKeys = generateKeys;
+exports.getNestedValue = getNestedValue;
+exports.getParameterNames = getParameterNames;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map