@burdenoff/be-sdk 2026.510.79

package/dist/chunk-4XGGWW36.js

@@ -0,0 +1,1405 @@
+import { DEFAULT_LAYER_RESOURCES } from './chunk-NGMEI42S.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+
+// src/cache/index.ts
+var cache_exports = {};
+__export(cache_exports, {
+  CacheFactory: () => CacheFactory,
+  CacheProviderType: () => CacheProviderType,
+  MemoryCacheProvider: () => MemoryCacheProvider,
+  ValkeyGlideProvider: () => ValkeyGlideProvider,
+  closeAllCaches: () => closeAllCaches,
+  createCache: () => createCache,
+  getCache: () => getCache,
+  getValkeyClient: () => getValkeyClient
+});
+
+// src/cache/implementations/memory/MemoryCacheProvider.ts
+var MemoryCacheProvider = class {
+  static {
+    __name(this, "MemoryCacheProvider");
+  }
+  cache = /* @__PURE__ */ new Map();
+  namespace;
+  defaultTTL;
+  maxSize;
+  enableLogging;
+  connected = false;
+  // Statistics
+  stats = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+    deletes: 0,
+    evictions: 0
+  };
+  constructor(config, namespace = "default") {
+    this.namespace = namespace;
+    this.defaultTTL = config.defaultTTL || 300;
+    this.maxSize = config.maxSize || 1e3;
+    this.enableLogging = config.enableLogging ?? false;
+    this.startCleanupInterval();
+  }
+  /**
+  * Connect (no-op for memory cache)
+  */
+  async connect() {
+    await Promise.resolve();
+    this.connected = true;
+    if (this.enableLogging) {
+      logger.info(`[MemoryCacheProvider:${this.namespace}] Connected (in-memory)`);
+    }
+  }
+  /**
+  * Disconnect (cleanup)
+  */
+  async disconnect() {
+    await Promise.resolve();
+    this.connected = false;
+    this.cache.clear();
+    if (this.enableLogging) {
+      logger.info(`[MemoryCacheProvider:${this.namespace}] Disconnected`);
+    }
+  }
+  /**
+  * Check if connected
+  */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+  * Health check
+  */
+  async healthCheck() {
+    await Promise.resolve();
+    return {
+      status: "healthy",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      connected: this.connected,
+      latencyMs: 0,
+      details: {
+        provider: "memory",
+        cacheSize: this.cache.size,
+        maxSize: this.maxSize
+      }
+    };
+  }
+  /**
+  * Get statistics
+  */
+  async getStatistics() {
+    await Promise.resolve();
+    const totalOperations = this.stats.hits + this.stats.misses;
+    const hitRate = totalOperations > 0 ? this.stats.hits / totalOperations : 0;
+    const memoryUsed = this.cache.size * 500;
+    return {
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      hitRate,
+      keyCount: this.cache.size,
+      memoryUsed,
+      totalOperations,
+      details: {
+        sets: this.stats.sets,
+        deletes: this.stats.deletes,
+        evictions: this.stats.evictions,
+        maxSize: this.maxSize
+      }
+    };
+  }
+  /**
+  * Build cache key with namespace
+  */
+  buildKey(key) {
+    return `${this.namespace}:${key}`;
+  }
+  /**
+  * Check if entry is expired
+  */
+  isExpired(expiresAt) {
+    return Date.now() > expiresAt;
+  }
+  /**
+  * Evict LRU entry if cache is full
+  */
+  evictIfNeeded() {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+        this.stats.evictions++;
+      }
+    }
+  }
+  /**
+  * Cleanup expired entries
+  */
+  cleanup() {
+    let cleaned = 0;
+    for (const [key, value] of this.cache.entries()) {
+      if (this.isExpired(value.expiresAt)) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0 && this.enableLogging) {
+      logger.debug(`[MemoryCacheProvider:${this.namespace}] Cleaned up ${cleaned} expired entries`);
+    }
+  }
+  /**
+  * Start cleanup interval
+  */
+  startCleanupInterval() {
+    setInterval(() => this.cleanup(), 6e4);
+  }
+  /**
+  * Get value from cache
+  */
+  async get(key, _options) {
+    await Promise.resolve();
+    const cacheKey = this.buildKey(key);
+    const cached = this.cache.get(cacheKey);
+    if (!cached) {
+      this.stats.misses++;
+      if (this.enableLogging) {
+        logger.debug(`[MemoryCacheProvider:${this.namespace}] Cache miss`, {
+          key
+        });
+      }
+      return null;
+    }
+    if (this.isExpired(cached.expiresAt)) {
+      this.cache.delete(cacheKey);
+      this.stats.misses++;
+      if (this.enableLogging) {
+        logger.debug(`[MemoryCacheProvider:${this.namespace}] Cache miss (expired)`, {
+          key
+        });
+      }
+      return null;
+    }
+    this.stats.hits++;
+    if (this.enableLogging) {
+      logger.debug(`[MemoryCacheProvider:${this.namespace}] Cache hit`, {
+        key
+      });
+    }
+    this.cache.delete(cacheKey);
+    this.cache.set(cacheKey, cached);
+    return cached.entry.data;
+  }
+  /**
+  * Set value in cache
+  */
+  async set(key, value, options) {
+    await Promise.resolve();
+    const cacheKey = this.buildKey(key);
+    const ttlSeconds = options?.ttl || this.defaultTTL;
+    this.evictIfNeeded();
+    const entry = {
+      data: value,
+      timestamp: Date.now(),
+      ttl: ttlSeconds,
+      metadata: options?.metadata
+    };
+    this.cache.set(cacheKey, {
+      entry,
+      expiresAt: Date.now() + ttlSeconds * 1e3
+    });
+    this.stats.sets++;
+    if (this.enableLogging) {
+      logger.debug(`[MemoryCacheProvider:${this.namespace}] Cache set`, {
+        key,
+        ttl: ttlSeconds
+      });
+    }
+    return true;
+  }
+  /**
+  * Delete value from cache
+  */
+  async delete(key) {
+    await Promise.resolve();
+    const cacheKey = this.buildKey(key);
+    const deleted = this.cache.delete(cacheKey);
+    if (deleted) {
+      this.stats.deletes++;
+      if (this.enableLogging) {
+        logger.debug(`[MemoryCacheProvider:${this.namespace}] Cache delete`, {
+          key
+        });
+      }
+    }
+    return deleted;
+  }
+  /**
+  * Check if key exists
+  */
+  async has(key) {
+    await Promise.resolve();
+    const cacheKey = this.buildKey(key);
+    const cached = this.cache.get(cacheKey);
+    if (!cached) {
+      return false;
+    }
+    if (this.isExpired(cached.expiresAt)) {
+      this.cache.delete(cacheKey);
+      return false;
+    }
+    return true;
+  }
+  /**
+  * Get TTL for key
+  */
+  async ttl(key) {
+    await Promise.resolve();
+    const cacheKey = this.buildKey(key);
+    const cached = this.cache.get(cacheKey);
+    if (!cached) {
+      return -2;
+    }
+    const remaining = Math.floor((cached.expiresAt - Date.now()) / 1e3);
+    if (remaining <= 0) {
+      this.cache.delete(cacheKey);
+      return -2;
+    }
+    return remaining;
+  }
+  /**
+  * Update TTL for key
+  */
+  async expire(key, ttl) {
+    await Promise.resolve();
+    const cacheKey = this.buildKey(key);
+    const cached = this.cache.get(cacheKey);
+    if (!cached) {
+      return false;
+    }
+    cached.expiresAt = Date.now() + ttl * 1e3;
+    cached.entry.ttl = ttl;
+    return true;
+  }
+  /**
+  * Get multiple values (batch operation)
+  */
+  async mget(keys, _options) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const value = await this.get(key);
+      if (value !== null) {
+        result.set(key, value);
+      }
+    }
+    return result;
+  }
+  /**
+  * Set multiple values (batch operation)
+  */
+  async mset(entries, options) {
+    for (const [key, value] of entries) {
+      await this.set(key, value, options);
+    }
+    return true;
+  }
+  /**
+  * Delete multiple keys (batch operation)
+  */
+  async mdel(keys) {
+    let deleted = 0;
+    for (const key of keys) {
+      const result = await this.delete(key);
+      if (result) {
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  /**
+  * Match key against pattern (supports * wildcard)
+  */
+  matchPattern(key, pattern) {
+    if (!pattern.includes("*")) {
+      return key === pattern;
+    }
+    const parts = pattern.split("*");
+    let position = 0;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!part || part === "") continue;
+      const index = key.indexOf(part, position);
+      if (index === -1) return false;
+      if (i === 0 && index !== 0) return false;
+      position = index + part.length;
+    }
+    const lastPart = parts[parts.length - 1];
+    return !lastPart || lastPart === "" || key.endsWith(lastPart);
+  }
+  /**
+  * Clear keys by pattern
+  */
+  async clearPattern(pattern) {
+    await Promise.resolve();
+    const searchPattern = this.buildKey(pattern);
+    let deleted = 0;
+    for (const key of this.cache.keys()) {
+      if (this.matchPattern(key, searchPattern)) {
+        this.cache.delete(key);
+        deleted++;
+      }
+    }
+    if (this.enableLogging) {
+      logger.debug(`[MemoryCacheProvider:${this.namespace}] Pattern cleared`, {
+        pattern,
+        deleted
+      });
+    }
+    return deleted;
+  }
+  /**
+  * Get keys by pattern
+  */
+  async keys(options) {
+    await Promise.resolve();
+    const searchPattern = this.buildKey(options.pattern);
+    const matchedKeys = [];
+    const prefix = `${this.namespace}:`;
+    for (const key of this.cache.keys()) {
+      if (this.matchPattern(key, searchPattern)) {
+        matchedKeys.push(key.replace(prefix, ""));
+      }
+    }
+    const limitedKeys = options.limit ? matchedKeys.slice(0, options.limit) : matchedKeys;
+    return {
+      keys: limitedKeys,
+      nextCursor: null,
+      totalCount: matchedKeys.length
+    };
+  }
+  /**
+  * Clear all keys in namespace
+  */
+  async clear() {
+    await Promise.resolve();
+    const prefix = `${this.namespace}:`;
+    let cleared = 0;
+    for (const key of Array.from(this.cache.keys())) {
+      if (key.startsWith(prefix)) {
+        this.cache.delete(key);
+        cleared++;
+      }
+    }
+    if (this.enableLogging) {
+      logger.info(`[MemoryCacheProvider:${this.namespace}] Cleared ${cleared} keys`);
+    }
+    return true;
+  }
+  /**
+  * Increment numeric value
+  */
+  async increment(key, amount = 1) {
+    const current = await this.get(key);
+    const newValue = (current || 0) + amount;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  /**
+  * Decrement numeric value
+  */
+  async decrement(key, amount = 1) {
+    const current = await this.get(key);
+    const newValue = (current || 0) - amount;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  /**
+  * Get or set value
+  */
+  async getOrSet(key, fetcher, options) {
+    const cached = await this.get(key, options);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await fetcher();
+    await this.set(key, value, options);
+    return value;
+  }
+  /**
+  * Invalidate by tags
+  */
+  async invalidateTags(tags) {
+    let totalDeleted = 0;
+    for (const tag of tags) {
+      const pattern = `*:tag:${tag}:*`;
+      const deleted = await this.clearPattern(pattern);
+      totalDeleted += deleted;
+    }
+    return totalDeleted;
+  }
+};
+
+// src/cache/implementations/valkey/ValkeyGlideProvider.ts
+var ValkeyGlideProvider = class {
+  static {
+    __name(this, "ValkeyGlideProvider");
+  }
+  client = null;
+  clusterScanCursor = null;
+  clientIsCluster = false;
+  connected = false;
+  config;
+  namespace;
+  defaultTTL;
+  enableLogging;
+  // Statistics
+  stats = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+    deletes: 0,
+    errors: 0
+  };
+  constructor(config, namespace = "default") {
+    this.config = config;
+    this.namespace = namespace;
+    this.defaultTTL = config.defaultTTL || 300;
+    this.enableLogging = config.enableLogging ?? process.env["NODE_ENV"] === "development";
+  }
+  async serverReportsCluster(client) {
+    try {
+      const info = await client.info("cluster");
+      return /(?:^|\n)cluster_enabled:1(?:\r?\n|$)/.test(info);
+    } catch {
+      return false;
+    }
+  }
+  async scanClusterKeys(pattern) {
+    if (!this.client || !this.clientIsCluster || !this.clusterScanCursor) {
+      return [];
+    }
+    const clusterClient = this.client;
+    let cursor = new this.clusterScanCursor();
+    const keys = [];
+    do {
+      const [nextCursor, batch] = await clusterClient.scan(cursor, {
+        match: pattern,
+        count: 1e3
+      });
+      keys.push(...batch);
+      cursor = nextCursor;
+    } while (!cursor.isFinished());
+    return keys;
+  }
+  async getKeys(pattern) {
+    if (!this.client) {
+      throw new Error("Not connected");
+    }
+    if (this.clientIsCluster) {
+      return this.scanClusterKeys(pattern);
+    }
+    if (!this.client.keys) {
+      throw new Error("KEYS command is not available on this Valkey client");
+    }
+    return this.client.keys(pattern);
+  }
+  /**
+  * Connect to Valkey server using @valkey/valkey-glide
+  */
+  async connect() {
+    if (this.connected && this.client) {
+      return;
+    }
+    try {
+      const glideModule = await import('@valkey/valkey-glide');
+      const GlideClient = glideModule.GlideClient || glideModule.default;
+      const GlideClusterClient = glideModule.GlideClusterClient;
+      this.clusterScanCursor = glideModule.ClusterScanCursor ?? null;
+      if (!GlideClient) {
+        throw new Error("Valkey GLIDE standalone client is unavailable");
+      }
+      let host = this.config.host || "localhost";
+      let port = this.config.port || 6379;
+      let password = this.config.password;
+      let username = this.config.username;
+      if (this.config.url) {
+        const url = new URL(this.config.url.replace("valkey://", "redis://"));
+        host = url.hostname;
+        port = parseInt(url.port || "6379", 10);
+        if (!password && url.password) {
+          try {
+            password = decodeURIComponent(url.password);
+          } catch {
+            password = url.password;
+          }
+        }
+        if (!username && url.username) {
+          try {
+            username = decodeURIComponent(url.username);
+          } catch {
+            username = url.username;
+          }
+        }
+      }
+      const addresses = this.config.clusterNodes?.length ? this.config.clusterNodes : [
+        {
+          host,
+          port
+        }
+      ];
+      const baseClientConfig = {
+        addresses,
+        useTLS: this.config.useTLS,
+        credentials: password || username ? {
+          password,
+          username
+        } : void 0,
+        clientName: this.config.name || `valkey-glide-${this.namespace}`,
+        databaseId: this.config.db,
+        connectionTimeout: this.config.connectionTimeout,
+        readFrom: "primary"
+      };
+      if (this.config.cluster === true) {
+        if (!GlideClusterClient) {
+          throw new Error("Valkey GLIDE cluster client is unavailable");
+        }
+        this.client = await GlideClusterClient.createClient({
+          ...baseClientConfig,
+          periodicChecks: {
+            duration_in_sec: 30
+          },
+          advancedConfiguration: {
+            refreshTopologyFromInitialNodes: true
+          }
+        });
+        this.clientIsCluster = true;
+      } else {
+        const standaloneClient = await GlideClient.createClient(baseClientConfig);
+        if (this.config.cluster !== false && await this.serverReportsCluster(standaloneClient)) {
+          if (!GlideClusterClient) {
+            throw new Error("Valkey server is clustered but GLIDE cluster client is unavailable");
+          }
+          await standaloneClient.close();
+          this.client = await GlideClusterClient.createClient({
+            ...baseClientConfig,
+            periodicChecks: {
+              duration_in_sec: 30
+            },
+            advancedConfiguration: {
+              refreshTopologyFromInitialNodes: true
+            }
+          });
+          this.clientIsCluster = true;
+        } else {
+          this.client = standaloneClient;
+          this.clientIsCluster = false;
+        }
+      }
+      this.connected = true;
+      if (this.enableLogging) {
+        logger.info(`[ValkeyGlideProvider:${this.namespace}] Connected to Valkey`, {
+          host,
+          port,
+          cluster: this.clientIsCluster
+        });
+      }
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Failed to connect:`, error);
+      throw error;
+    }
+  }
+  /**
+  * Disconnect from Valkey server
+  */
+  async disconnect() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.clientIsCluster = false;
+      this.connected = false;
+      if (this.enableLogging) {
+        logger.info(`[ValkeyGlideProvider:${this.namespace}] Disconnected`);
+      }
+    }
+  }
+  /**
+  * Check if connected
+  */
+  isConnected() {
+    return this.connected && this.client !== null;
+  }
+  /**
+  * Health check
+  */
+  async healthCheck() {
+    const startTime = Date.now();
+    try {
+      if (!this.client) {
+        return {
+          status: "unhealthy",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          connected: false,
+          error: "Not connected"
+        };
+      }
+      const result = await this.client.ping();
+      const latencyMs = Date.now() - startTime;
+      if (result === "PONG") {
+        return {
+          status: "healthy",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          connected: true,
+          latencyMs
+        };
+      }
+      return {
+        status: "unhealthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        connected: false,
+        error: "Unexpected ping response"
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        connected: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        latencyMs: Date.now() - startTime
+      };
+    }
+  }
+  /**
+  * Get statistics
+  */
+  async getStatistics() {
+    const totalOperations = this.stats.hits + this.stats.misses;
+    const hitRate = totalOperations > 0 ? this.stats.hits / totalOperations : 0;
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const info = await this.client.info("memory");
+      const memoryRegex = /used_memory:(\d+)/;
+      const memoryMatch = memoryRegex.exec(info);
+      const memoryUsed = memoryMatch && memoryMatch[1] ? parseInt(memoryMatch[1], 10) : void 0;
+      const keyCount = await this.client.dbsize();
+      return {
+        hits: this.stats.hits,
+        misses: this.stats.misses,
+        hitRate,
+        keyCount,
+        memoryUsed,
+        totalOperations,
+        details: {
+          sets: this.stats.sets,
+          deletes: this.stats.deletes,
+          errors: this.stats.errors
+        }
+      };
+    } catch (error) {
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Failed to get statistics:`, error);
+      return {
+        hits: this.stats.hits,
+        misses: this.stats.misses,
+        hitRate,
+        totalOperations,
+        details: {
+          sets: this.stats.sets,
+          deletes: this.stats.deletes,
+          errors: this.stats.errors
+        }
+      };
+    }
+  }
+  /**
+  * Build cache key with namespace
+  */
+  buildKey(key) {
+    return `${this.namespace}:${key}`;
+  }
+  /**
+  * Get value from cache
+  */
+  async get(key, _options) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      const value = await this.client.get(cacheKey);
+      if (value === null) {
+        this.stats.misses++;
+        if (this.enableLogging) {
+          logger.debug(`[ValkeyGlideProvider:${this.namespace}] Cache miss`, {
+            key
+          });
+        }
+        return null;
+      }
+      this.stats.hits++;
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Cache hit`, {
+          key
+        });
+      }
+      const entry = JSON.parse(value);
+      return entry.data;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error getting cache key:`, error);
+      return null;
+    }
+  }
+  /**
+  * Set value in cache
+  */
+  async set(key, value, options) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      const ttlSeconds = options?.ttl || this.defaultTTL;
+      const entry = {
+        data: value,
+        timestamp: Date.now(),
+        ttl: ttlSeconds,
+        metadata: options?.metadata
+      };
+      await this.client.set(cacheKey, JSON.stringify(entry), {
+        expiry: {
+          type: "EX",
+          count: ttlSeconds
+        }
+      });
+      this.stats.sets++;
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Cache set`, {
+          key,
+          ttl: ttlSeconds
+        });
+      }
+      return true;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error setting cache key:`, error);
+      return false;
+    }
+  }
+  /**
+  * Delete value from cache
+  */
+  async delete(key) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      const result = await this.client.del([
+        cacheKey
+      ]);
+      this.stats.deletes++;
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Cache delete`, {
+          key,
+          deleted: result > 0
+        });
+      }
+      return result > 0;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error deleting cache key:`, error);
+      return false;
+    }
+  }
+  /**
+  * Check if key exists
+  */
+  async has(key) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      const exists = await this.client.exists([
+        cacheKey
+      ]);
+      return exists === 1;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error checking cache key:`, error);
+      return false;
+    }
+  }
+  /**
+  * Get TTL for key
+  */
+  async ttl(key) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      return await this.client.ttl(cacheKey);
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error getting TTL:`, error);
+      return -2;
+    }
+  }
+  /**
+  * Update TTL for key
+  */
+  async expire(key, ttl) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      return await this.client.expire(cacheKey, ttl);
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error setting expiration:`, error);
+      return false;
+    }
+  }
+  /**
+  * Get multiple values (batch operation)
+  */
+  async mget(keys, _options) {
+    const result = /* @__PURE__ */ new Map();
+    if (keys.length === 0) {
+      return result;
+    }
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKeys = keys.map((key) => this.buildKey(key));
+      const values = await this.client.mget(cacheKeys);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (!key) continue;
+        if (values[i] !== null) {
+          const entry = JSON.parse(values[i]);
+          result.set(key, entry.data);
+          this.stats.hits++;
+        } else {
+          this.stats.misses++;
+        }
+      }
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Batch get`, {
+          requested: keys.length,
+          found: result.size
+        });
+      }
+      return result;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error in batch get:`, error);
+      return result;
+    }
+  }
+  /**
+  * Set multiple values (batch operation)
+  */
+  async mset(entries, options) {
+    if (entries.size === 0) {
+      return true;
+    }
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const ttlSeconds = options?.ttl || this.defaultTTL;
+      const keyValuePairs = {};
+      for (const [key, value] of entries) {
+        const cacheKey = this.buildKey(key);
+        const entry = {
+          data: value,
+          timestamp: Date.now(),
+          ttl: ttlSeconds,
+          metadata: options?.metadata
+        };
+        keyValuePairs[cacheKey] = JSON.stringify(entry);
+      }
+      await this.client.mset(keyValuePairs);
+      for (const cacheKey of Object.keys(keyValuePairs)) {
+        await this.client.expire(cacheKey, ttlSeconds);
+      }
+      this.stats.sets += entries.size;
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Batch set`, {
+          count: entries.size,
+          ttl: ttlSeconds
+        });
+      }
+      return true;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error in batch set:`, error);
+      return false;
+    }
+  }
+  /**
+  * Delete multiple keys (batch operation)
+  */
+  async mdel(keys) {
+    if (keys.length === 0) {
+      return 0;
+    }
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKeys = keys.map((key) => this.buildKey(key));
+      const result = await this.client.del(cacheKeys);
+      this.stats.deletes += result;
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Batch delete`, {
+          requested: keys.length,
+          deleted: result
+        });
+      }
+      return result;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error in batch delete:`, error);
+      return 0;
+    }
+  }
+  /**
+  * Clear keys by pattern
+  */
+  async clearPattern(pattern) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const searchPattern = this.buildKey(pattern);
+      const keys = await this.getKeys(searchPattern);
+      if (keys.length === 0) {
+        return 0;
+      }
+      const result = await this.client.del(keys);
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Pattern cleared`, {
+          pattern,
+          deleted: result
+        });
+      }
+      return result;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error clearing pattern:`, error);
+      return 0;
+    }
+  }
+  /**
+  * Get keys by pattern
+  */
+  async keys(options) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const searchPattern = this.buildKey(options.pattern);
+      const keys = await this.getKeys(searchPattern);
+      const prefix = `${this.namespace}:`;
+      const cleanKeys = keys.map((key) => key.replace(prefix, ""));
+      const limitedKeys = options.limit ? cleanKeys.slice(0, options.limit) : cleanKeys;
+      return {
+        keys: limitedKeys,
+        nextCursor: null,
+        totalCount: cleanKeys.length
+      };
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error getting keys:`, error);
+      return {
+        keys: [],
+        nextCursor: null,
+        totalCount: 0
+      };
+    }
+  }
+  /**
+  * Clear all keys in namespace
+  */
+  async clear() {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const pattern = this.buildKey("*");
+      const keys = await this.getKeys(pattern);
+      if (keys.length > 0) {
+        await this.client.del(keys);
+        if (this.enableLogging) {
+          logger.info(`[ValkeyGlideProvider:${this.namespace}] Cleared ${keys.length} keys`);
+        }
+      }
+      return true;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error clearing cache:`, error);
+      return false;
+    }
+  }
+  /**
+  * Increment numeric value
+  */
+  async increment(key, amount = 1) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      return await this.client.incrBy(cacheKey, amount);
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error incrementing:`, error);
+      throw error;
+    }
+  }
+  /**
+  * Decrement numeric value
+  */
+  async decrement(key, amount = 1) {
+    try {
+      if (!this.client) {
+        throw new Error("Not connected");
+      }
+      const cacheKey = this.buildKey(key);
+      return await this.client.decrBy(cacheKey, amount);
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error decrementing:`, error);
+      throw error;
+    }
+  }
+  /**
+  * Get or set value
+  */
+  async getOrSet(key, fetcher, options) {
+    const cached = await this.get(key, options);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await fetcher();
+    await this.set(key, value, options);
+    return value;
+  }
+  /**
+  * Invalidate by tags
+  */
+  async invalidateTags(tags) {
+    try {
+      let totalDeleted = 0;
+      for (const tag of tags) {
+        const pattern = `*:tag:${tag}:*`;
+        const deleted = await this.clearPattern(pattern);
+        totalDeleted += deleted;
+      }
+      if (this.enableLogging) {
+        logger.debug(`[ValkeyGlideProvider:${this.namespace}] Tags invalidated`, {
+          tags,
+          deleted: totalDeleted
+        });
+      }
+      return totalDeleted;
+    } catch (error) {
+      this.stats.errors++;
+      logger.error(`[ValkeyGlideProvider:${this.namespace}] Error invalidating tags:`, error);
+      return 0;
+    }
+  }
+};
+
+// src/cache/factory/CacheFactory.ts
+var CacheFactory = class _CacheFactory {
+  static {
+    __name(this, "CacheFactory");
+  }
+  static instances = /* @__PURE__ */ new Map();
+  static parseBoolean(value) {
+    if (value === void 0) return void 0;
+    const normalized = value.trim().toLowerCase();
+    if ([
+      "1",
+      "true",
+      "yes",
+      "on"
+    ].includes(normalized)) return true;
+    if ([
+      "0",
+      "false",
+      "no",
+      "off"
+    ].includes(normalized)) return false;
+    return void 0;
+  }
+  static parseClusterNodes(value) {
+    if (!value) return void 0;
+    const nodes = value.split(",").map((node) => node.trim()).filter(Boolean).map((node) => {
+      const [host, rawPort] = node.replace(/^redis:\/\//, "").replace(/^valkey:\/\//, "").split(":");
+      if (!host) return null;
+      return {
+        host,
+        port: rawPort ? parseInt(rawPort, 10) : 6379
+      };
+    }).filter((node) => node !== null && Number.isFinite(node.port));
+    return nodes.length > 0 ? nodes : void 0;
+  }
+  /**
+  * Resolve port from multiple environment variable sources
+  * @param layerPort - Layer-specific port environment variable value
+  * @param genericPort - Generic port environment variable value
+  * @param defaultPort - Default port if none provided
+  * @returns Resolved port number
+  */
+  static resolvePort(layerPort, genericPort, defaultPort = 6379) {
+    if (layerPort) {
+      return parseInt(layerPort, 10);
+    }
+    if (genericPort) {
+      return parseInt(genericPort, 10);
+    }
+    return defaultPort;
+  }
+  /**
+  * Create a cache provider based on configuration
+  */
+  static createCache(config, namespace = "default") {
+    logger.info("[CacheFactory] Creating cache provider", {
+      type: config.type,
+      namespace
+    });
+    switch (config.type) {
+      case "valkey":
+      case "redis":
+        return new ValkeyGlideProvider({
+          type: "valkey-glide",
+          url: config.url,
+          host: config.host,
+          port: config.port,
+          password: config.password,
+          username: config.username,
+          db: config.db,
+          keyPrefix: config.keyPrefix,
+          defaultTTL: config.defaultTTL,
+          enableLogging: config.enableLogging,
+          maxReconnectAttempts: config.maxReconnectAttempts,
+          reconnectTimeWait: config.reconnectTimeWait,
+          connectionTimeout: config.connectionTimeout,
+          name: config.name,
+          useTLS: config.tls?.enabled,
+          cluster: config.cluster,
+          clusterNodes: config.clusterNodes
+        }, namespace);
+      case "memory":
+        return new MemoryCacheProvider(config, namespace);
+      // Future implementations can be added here
+      // case 'memcached':
+      //   return new MemcachedCacheProvider(config as MemcachedCacheConfig, namespace);
+      default:
+        throw new Error(`Unsupported cache provider type: ${config.type}`);
+    }
+  }
+  /**
+  * Create a cache from environment variables
+  */
+  static createCacheFromEnv(namespace = "default") {
+    const envType = process.env["CACHE_PROVIDER_TYPE"];
+    const type = envType === "memory" ? "memory" : "valkey";
+    const config = type === "valkey" ? {
+      type: "valkey",
+      url: process.env["VALKEY_URL"],
+      host: process.env["VALKEY_HOST"] || "localhost",
+      port: process.env["VALKEY_PORT"] ? parseInt(process.env["VALKEY_PORT"], 10) : 6379,
+      password: process.env["VALKEY_PASSWORD"],
+      db: process.env["VALKEY_DB"] ? parseInt(process.env["VALKEY_DB"], 10) : 0,
+      username: process.env["VALKEY_USERNAME"],
+      keyPrefix: process.env["CACHE_KEY_PREFIX"] || "cache",
+      defaultTTL: process.env["CACHE_DEFAULT_TTL"] ? parseInt(process.env["CACHE_DEFAULT_TTL"], 10) : 300,
+      enableLogging: process.env["CACHE_ENABLE_LOGGING"] === "true",
+      maxReconnectAttempts: process.env["VALKEY_MAX_RECONNECT_ATTEMPTS"] ? parseInt(process.env["VALKEY_MAX_RECONNECT_ATTEMPTS"], 10) : -1,
+      reconnectTimeWait: process.env["VALKEY_RECONNECT_TIME_WAIT"] ? parseInt(process.env["VALKEY_RECONNECT_TIME_WAIT"], 10) : 2e3,
+      connectionTimeout: process.env["VALKEY_CONNECTION_TIMEOUT"] ? parseInt(process.env["VALKEY_CONNECTION_TIMEOUT"], 10) : 1e4,
+      name: process.env["CACHE_CLIENT_NAME"] || `cache-${namespace}`,
+      cluster: _CacheFactory.parseBoolean(process.env["VALKEY_CLUSTER"] || process.env["CACHE_CLUSTER"]),
+      clusterNodes: _CacheFactory.parseClusterNodes(process.env["VALKEY_CLUSTER_NODES"] || process.env["CACHE_CLUSTER_NODES"])
+    } : {
+      type: "memory",
+      maxSize: process.env["CACHE_MAX_SIZE"] ? parseInt(process.env["CACHE_MAX_SIZE"], 10) : 1e3,
+      defaultTTL: process.env["CACHE_DEFAULT_TTL"] ? parseInt(process.env["CACHE_DEFAULT_TTL"], 10) : 300,
+      enableLogging: process.env["CACHE_ENABLE_LOGGING"] === "true",
+      keyPrefix: process.env["CACHE_KEY_PREFIX"] || "cache"
+    };
+    return _CacheFactory.createCache(config, namespace);
+  }
+  /**
+  * Get or create a singleton cache instance for a namespace
+  */
+  static getInstance(namespace = "default", config) {
+    const instanceKey = `${config?.type || "default"}:${namespace}`;
+    if (!_CacheFactory.instances.has(instanceKey)) {
+      const cache = config ? _CacheFactory.createCache(config, namespace) : _CacheFactory.createCacheFromEnv(namespace);
+      _CacheFactory.instances.set(instanceKey, cache);
+    }
+    return _CacheFactory.instances.get(instanceKey);
+  }
+  /**
+  * Close a specific cache instance
+  */
+  static async closeInstance(namespace) {
+    for (const [key, cache] of _CacheFactory.instances.entries()) {
+      if (key.endsWith(`:${namespace}`)) {
+        await cache.disconnect();
+        _CacheFactory.instances.delete(key);
+        logger.info("[CacheFactory] Closed cache instance", {
+          namespace
+        });
+      }
+    }
+  }
+  /**
+  * Close all cache instances
+  * Call this during application shutdown
+  */
+  static async closeAll() {
+    const promises = Array.from(_CacheFactory.instances.values()).map(async (cache) => cache.disconnect());
+    await Promise.all(promises);
+    _CacheFactory.instances.clear();
+    logger.info("[CacheFactory] All cache instances closed");
+  }
+  // ========================================================================
+  // Layer-Aware Factory Methods
+  // ========================================================================
+  /**
+  * Create a cache provider for a specific layer
+  *
+  * @param layer - Service layer ('wspace' or 'global')
+  * @param serviceName - Service name for identification
+  * @param namespace - Cache namespace (default: 'default')
+  * @returns Cache provider configured for the layer
+  *
+  * @example
+  * ```typescript
+  * const cache = CacheFactory.createCacheForLayer('wspace', 'wspace-tags-svc');
+  * await cache.connect();
+  * await cache.set('key', { data: 'value' });
+  * ```
+  */
+  static createCacheForLayer(layer, serviceName, namespace = "default") {
+    const envPrefix = layer.toUpperCase();
+    const defaults = DEFAULT_LAYER_RESOURCES[layer];
+    const url = process.env[`${envPrefix}_VALKEY_URL`] || process.env["VALKEY_URL"] || defaults.valkeyUrl;
+    const resolvedPort = _CacheFactory.resolvePort(process.env[`${envPrefix}_VALKEY_PORT`], process.env["VALKEY_PORT"]);
+    const config = {
+      type: "valkey",
+      url,
+      host: process.env[`${envPrefix}_VALKEY_HOST`] || process.env["VALKEY_HOST"] || "localhost",
+      port: resolvedPort,
+      password: process.env["VALKEY_PASSWORD"],
+      db: process.env["VALKEY_DB"] ? parseInt(process.env["VALKEY_DB"], 10) : 0,
+      username: process.env["VALKEY_USERNAME"],
+      keyPrefix: process.env["CACHE_KEY_PREFIX"] || `${layer}-cache`,
+      defaultTTL: process.env["CACHE_DEFAULT_TTL"] ? parseInt(process.env["CACHE_DEFAULT_TTL"], 10) : 300,
+      enableLogging: process.env["CACHE_ENABLE_LOGGING"] === "true",
+      maxReconnectAttempts: process.env["VALKEY_MAX_RECONNECT_ATTEMPTS"] ? parseInt(process.env["VALKEY_MAX_RECONNECT_ATTEMPTS"], 10) : -1,
+      reconnectTimeWait: process.env["VALKEY_RECONNECT_TIME_WAIT"] ? parseInt(process.env["VALKEY_RECONNECT_TIME_WAIT"], 10) : 2e3,
+      connectionTimeout: process.env["VALKEY_CONNECTION_TIMEOUT"] ? parseInt(process.env["VALKEY_CONNECTION_TIMEOUT"], 10) : 1e4,
+      name: serviceName,
+      cluster: _CacheFactory.parseBoolean(process.env[`${envPrefix}_VALKEY_CLUSTER`] || process.env["VALKEY_CLUSTER"] || process.env["CACHE_CLUSTER"]),
+      clusterNodes: _CacheFactory.parseClusterNodes(process.env[`${envPrefix}_VALKEY_CLUSTER_NODES`] || process.env["VALKEY_CLUSTER_NODES"] || process.env["CACHE_CLUSTER_NODES"])
+    };
+    logger.info("[CacheFactory] Creating layer cache", {
+      layer,
+      serviceName,
+      namespace,
+      url: config.url
+    });
+    return _CacheFactory.createCache(config, namespace);
+  }
+  /**
+  * Get or create a singleton cache instance for a layer
+  *
+  * @param layer - Service layer ('wspace' or 'global')
+  * @param serviceName - Service name for identification
+  * @param namespace - Cache namespace (default: 'default')
+  * @returns Singleton cache provider for the layer
+  */
+  static getInstanceForLayer(layer, serviceName, namespace = "default") {
+    const instanceKey = `${layer}:${serviceName}:${namespace}`;
+    if (!_CacheFactory.instances.has(instanceKey)) {
+      const cache = _CacheFactory.createCacheForLayer(layer, serviceName, namespace);
+      _CacheFactory.instances.set(instanceKey, cache);
+    }
+    return _CacheFactory.instances.get(instanceKey);
+  }
+};
+
+// src/cache/types/config.ts
+var CacheProviderType = /* @__PURE__ */ (function(CacheProviderType2) {
+  CacheProviderType2["VALKEY"] = "valkey";
+  CacheProviderType2["MEMORY"] = "memory";
+  CacheProviderType2["MEMCACHED"] = "memcached";
+  return CacheProviderType2;
+})({});
+
+// src/cache/index.ts
+function createCache(namespace = "default") {
+  return CacheFactory.createCacheFromEnv(namespace);
+}
+__name(createCache, "createCache");
+function getCache(namespace = "default", config) {
+  return CacheFactory.getInstance(namespace, config);
+}
+__name(getCache, "getCache");
+async function getValkeyClient(config) {
+  const glideModule = await import('@valkey/valkey-glide');
+  const GlideClient = glideModule.GlideClient || glideModule.default;
+  const valkeyConfig = config || {
+    type: CacheProviderType.VALKEY,
+    url: process.env["VALKEY_URL"],
+    host: process.env["VALKEY_HOST"] || "localhost",
+    port: process.env["VALKEY_PORT"] ? parseInt(process.env["VALKEY_PORT"], 10) : 6379,
+    password: process.env["VALKEY_PASSWORD"],
+    db: process.env["VALKEY_DB"] ? parseInt(process.env["VALKEY_DB"], 10) : 0,
+    username: process.env["VALKEY_USERNAME"]
+  };
+  let host = valkeyConfig.host || "localhost";
+  let port = valkeyConfig.port || 6379;
+  if (valkeyConfig.url) {
+    const url = new URL(valkeyConfig.url.replace("valkey://", "redis://"));
+    host = url.hostname;
+    port = parseInt(url.port || "6379", 10);
+  }
+  const createClient = GlideClient;
+  return createClient.createClient({
+    addresses: [
+      {
+        host,
+        port
+      }
+    ],
+    useTLS: valkeyConfig.useTLS,
+    credentials: valkeyConfig.password ? {
+      password: valkeyConfig.password,
+      username: valkeyConfig.username
+    } : void 0,
+    clientName: valkeyConfig.name || "valkey-glide-client",
+    readFrom: "primary"
+  });
+}
+__name(getValkeyClient, "getValkeyClient");
+async function closeAllCaches() {
+  await CacheFactory.closeAll();
+}
+__name(closeAllCaches, "closeAllCaches");
+
+export { CacheFactory, CacheProviderType, MemoryCacheProvider, ValkeyGlideProvider, cache_exports, closeAllCaches, createCache, getCache, getValkeyClient };
+//# sourceMappingURL=chunk-4XGGWW36.js.map
+//# sourceMappingURL=chunk-4XGGWW36.js.map