@veryfront/ext-redis 0.1.1185 → 0.1.1189

package/esm/index.d.ts

@@ -3,9 +3,16 @@
  *
  * @module extensions/ext-redis
  */
+import "./_dnt.polyfills.js";
 import type { ExtensionFactory } from "veryfront/extensions/types";
 declare const extRedis: ExtensionFactory;
 export default extRedis;
+export { RedisMemory } from "./agent-memory.js";
+export { createRedisCacheAdministration } from "./cache-administration.js";
+export { RedisCacheBackend } from "./cache-backend.js";
+export { RedisRateLimitStore } from "./rate-limit-store.js";
+export { RedisCacheStore } from "./render-cache-store.js";
+export { startProxyRoutingInvalidationBus } from "./routing-invalidation-bus.js";
 export { createRedisRuntimeProvider } from "./redis-runtime-provider.js";
 export type { RedisClient, RedisClientOptions, RedisEventPublisherConfig, RedisEventPublisherImplementation, RedisRuntimeProvider, } from "veryfront/extensions/distributed";
 //# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAOnE,QAAA,MAAM,QAAQ,EAAE,gBAqCf,CAAC;AAEF,eAAe,QAAQ,CAAC;AACxB,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,yBAAyB,EACzB,iCAAiC,EACjC,oBAAoB,GACrB,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAOnE,QAAA,MAAM,QAAQ,EAAE,gBAqCf,CAAC;AAEF,eAAe,QAAQ,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,gCAAgC,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,yBAAyB,EACzB,iCAAiC,EACjC,oBAAoB,GACrB,MAAM,kCAAkC,CAAC"}

package/esm/index.js

@@ -3,6 +3,7 @@
  *
  * @module extensions/ext-redis
  */
+import "./_dnt.polyfills.js";
 import { RedisRuntimeProviderName, } from "veryfront/extensions/distributed";
 import { createRedisRuntimeProvider } from "./redis-runtime-provider.js";
 const extRedis = () => {
@@ -48,4 +49,10 @@ const extRedis = () => {
     };
 };
 export default extRedis;
+export { RedisMemory } from "./agent-memory.js";
+export { createRedisCacheAdministration } from "./cache-administration.js";
+export { RedisCacheBackend } from "./cache-backend.js";
+export { RedisRateLimitStore } from "./rate-limit-store.js";
+export { RedisCacheStore } from "./render-cache-store.js";
+export { startProxyRoutingInvalidationBus } from "./routing-invalidation-bus.js";
 export { createRedisRuntimeProvider } from "./redis-runtime-provider.js";

package/esm/rate-limit-store.d.ts

@@ -0,0 +1,40 @@
+import { type RateLimitEntry, type RateLimitStore } from "veryfront/extensions/distributed/rate-limit-support";
+/** Options accepted by redis rate limit. */
+export interface RedisRateLimitOptions {
+    url?: string;
+    keyPrefix?: string;
+    /** Maximum time allowed for loading and connecting the Redis client. */
+    connectTimeoutMs?: number;
+    /** Maximum time allowed for an individual Redis command. */
+    operationTimeoutMs?: number;
+}
+/** Implement redis rate limit store. */
+export declare class RedisRateLimitStore implements RateLimitStore {
+    private client;
+    private connectingClient;
+    private clientPromise;
+    private cancelPendingConnection;
+    private clientGeneration;
+    private readonly disconnectPromises;
+    private readonly disconnectedClients;
+    private readonly pendingDisconnectClients;
+    private readonly reportedClientErrors;
+    private readonly url?;
+    private readonly keyPrefix;
+    private readonly connectTimeoutMs;
+    private readonly operationTimeoutMs;
+    constructor(options?: RedisRateLimitOptions);
+    private ensureClient;
+    private invalidateClient;
+    private attachClientLifecycleHandlers;
+    private loadClientFactory;
+    private disconnectBestEffort;
+    private disconnectClient;
+    private withTimeout;
+    private connectClient;
+    private storageKey;
+    increment(key: string, windowMs: number): Promise<RateLimitEntry>;
+    reset(key: string): Promise<void>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=rate-limit-store.d.ts.map

package/esm/rate-limit-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit-store.d.ts","sourceRoot":"","sources":["../src/rate-limit-store.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,cAAc,EAGpB,MAAM,qDAAqD,CAAC;AAyC7D,4CAA4C;AAC5C,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,wCAAwC;AACxC,qBAAa,mBAAoB,YAAW,cAAc;IACxD,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,aAAa,CAAqC;IAC1D,OAAO,CAAC,uBAAuB,CAA6B;IAC5D,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6C;IAChF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA8B;IAClE,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAA0B;IACnE,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IACnE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAEhC,OAAO,GAAE,qBAA0B;IA0B/C,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,6BAA6B;YAoBvB,iBAAiB;YAIjB,oBAAoB;IAUlC,OAAO,CAAC,gBAAgB;YAmCV,WAAW;YAsBX,aAAa;IAgE3B,OAAO,CAAC,UAAU;IAIZ,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA6BjE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CA6B/B"}

package/esm/rate-limit-store.js

@@ -0,0 +1,306 @@
+import * as dntShim from "./_dnt.shims.js";
+import { createError, toError } from "veryfront/errors";
+import { serverLogger } from "veryfront/utils/logger";
+import { createClient } from "redis";
+import { MAX_TIMER_DELAY_MS, requireRateLimitKey, requireRateLimitWindowMs, } from "veryfront/extensions/distributed/rate-limit-support";
+const logger = serverLogger.component("redis-ratelimit");
+const DEFAULT_REDIS_CONNECT_TIMEOUT_MS = 5_000;
+const DEFAULT_REDIS_OPERATION_TIMEOUT_MS = 5_000;
+const INCREMENT_WITH_TTL_SCRIPT = `
+local count = redis.call("INCR", KEYS[1])
+local ttl = redis.call("PTTL", KEYS[1])
+if ttl < 0 then
+  redis.call("PEXPIRE", KEYS[1], ARGV[1])
+  ttl = tonumber(ARGV[1])
+end
+return { count, ttl }
+`;
+/** Implement redis rate limit store. */
+export class RedisRateLimitStore {
+    client = null;
+    connectingClient = null;
+    clientPromise = null;
+    cancelPendingConnection = null;
+    clientGeneration = 0;
+    disconnectPromises = new WeakMap();
+    disconnectedClients = new WeakSet();
+    pendingDisconnectClients = new Set();
+    reportedClientErrors = new WeakSet();
+    url;
+    keyPrefix;
+    connectTimeoutMs;
+    operationTimeoutMs;
+    constructor(options = {}) {
+        if (typeof options !== "object" ||
+            options === null ||
+            Array.isArray(options)) {
+            throw new TypeError("Redis rate limit options must be an object");
+        }
+        if (options.url !== undefined && typeof options.url !== "string") {
+            throw new TypeError("Redis rate limit url must be a string");
+        }
+        this.url = options.url;
+        this.connectTimeoutMs = requireTimeoutMs(options.connectTimeoutMs ?? DEFAULT_REDIS_CONNECT_TIMEOUT_MS, "connectTimeoutMs");
+        this.operationTimeoutMs = requireTimeoutMs(options.operationTimeoutMs ?? DEFAULT_REDIS_OPERATION_TIMEOUT_MS, "operationTimeoutMs");
+        this.keyPrefix = requireRateLimitKey(options.keyPrefix ?? "veryfront:ratelimit:", "Redis rate limit keyPrefix");
+    }
+    ensureClient() {
+        if (this.client)
+            return Promise.resolve(this.client);
+        if (this.clientPromise)
+            return this.clientPromise;
+        const generation = this.clientGeneration;
+        const pending = this.connectClient(generation).finally(() => {
+            if (this.clientPromise === pending)
+                this.clientPromise = null;
+        });
+        this.clientPromise = pending;
+        return pending;
+    }
+    invalidateClient(client, generation, disconnect) {
+        if (generation !== this.clientGeneration)
+            return;
+        if (this.client !== client)
+            return;
+        this.clientGeneration++;
+        this.client = null;
+        this.clientPromise = null;
+        if (disconnect) {
+            void this.disconnectBestEffort(client);
+        }
+    }
+    attachClientLifecycleHandlers(client, generation = this.clientGeneration) {
+        client.on?.("error", (err) => {
+            if (generation !== this.clientGeneration)
+                return;
+            if (!this.reportedClientErrors.has(client)) {
+                this.reportedClientErrors.add(client);
+                logger.error("client error", {
+                    errorName: err instanceof Error ? err.name : typeof err,
+                });
+            }
+            this.invalidateClient(client, generation, true);
+        });
+        client.on?.("end", () => {
+            this.invalidateClient(client, generation, false);
+        });
+    }
+    async loadClientFactory() {
+        return createClient;
+    }
+    async disconnectBestEffort(client) {
+        try {
+            await this.disconnectClient(client);
+        }
+        catch (error) {
+            logger.warn("client disconnect failed", {
+                errorName: error instanceof Error ? error.name : typeof error,
+            });
+        }
+    }
+    disconnectClient(client) {
+        if (this.disconnectedClients.has(client))
+            return Promise.resolve();
+        const existing = this.disconnectPromises.get(client);
+        if (existing)
+            return existing;
+        let resolveDisconnect;
+        let rejectDisconnect;
+        const pending = new Promise((resolve, reject) => {
+            resolveDisconnect = resolve;
+            rejectDisconnect = reject;
+        });
+        this.disconnectPromises.set(client, pending);
+        this.pendingDisconnectClients.add(client);
+        try {
+            Promise.resolve(client.disconnect()).then(() => {
+                this.disconnectPromises.delete(client);
+                this.pendingDisconnectClients.delete(client);
+                this.disconnectedClients.add(client);
+                resolveDisconnect();
+            }, (error) => {
+                this.disconnectPromises.delete(client);
+                rejectDisconnect(error);
+            });
+        }
+        catch (error) {
+            this.disconnectPromises.delete(client);
+            rejectDisconnect(error);
+        }
+        return pending;
+    }
+    async withTimeout(operation, timeoutMs, operationName, cancellation) {
+        let timeoutId;
+        const timeout = new Promise((_, reject) => {
+            timeoutId = dntShim.setTimeout(() => {
+                reject(createTimeoutError(operationName, timeoutMs));
+            }, timeoutMs);
+        });
+        try {
+            return await Promise.race(cancellation === undefined ? [operation, timeout] : [operation, timeout, cancellation]);
+        }
+        finally {
+            if (timeoutId !== undefined)
+                clearTimeout(timeoutId);
+        }
+    }
+    async connectClient(generation) {
+        const superseded = new Error("Redis rate limit client connection was superseded");
+        superseded.name = "AbortError";
+        let cancelConnection;
+        let cancelled = false;
+        const cancellation = new Promise((_, reject) => {
+            cancelConnection = () => {
+                if (cancelled)
+                    return;
+                cancelled = true;
+                reject(superseded);
+            };
+        });
+        this.cancelPendingConnection = cancelConnection;
+        let client;
+        try {
+            const createClient = await this.withTimeout(this.loadClientFactory(), this.connectTimeoutMs, "client loading", cancellation);
+            if (generation !== this.clientGeneration)
+                throw superseded;
+            client = createClient({
+                ...(this.url === undefined ? {} : { url: this.url }),
+                socket: {
+                    connectTimeout: this.connectTimeoutMs,
+                    reconnectStrategy: false,
+                },
+            });
+            this.connectingClient = client;
+            this.attachClientLifecycleHandlers(client, generation);
+            await this.withTimeout(client.connect(), this.connectTimeoutMs, "connection", cancellation);
+            if (this.connectingClient === client)
+                this.connectingClient = null;
+            if (generation !== this.clientGeneration) {
+                await this.disconnectBestEffort(client);
+                throw superseded;
+            }
+            this.client = client;
+            return client;
+        }
+        catch (error) {
+            if (client && this.connectingClient === client) {
+                this.connectingClient = null;
+            }
+            if (generation === this.clientGeneration)
+                this.clientGeneration++;
+            if (client)
+                await this.disconnectBestEffort(client);
+            throw error;
+        }
+        finally {
+            if (this.cancelPendingConnection === cancelConnection) {
+                this.cancelPendingConnection = null;
+            }
+        }
+    }
+    storageKey(key) {
+        return `${this.keyPrefix}${key}`;
+    }
+    async increment(key, windowMs) {
+        const normalizedKey = requireRateLimitKey(key);
+        const normalizedWindowMs = requireRateLimitWindowMs(windowMs);
+        const client = await this.ensureClient();
+        const generation = this.clientGeneration;
+        const redisKey = this.storageKey(normalizedKey);
+        let result;
+        try {
+            result = await this.withTimeout(client.eval(INCREMENT_WITH_TTL_SCRIPT, {
+                keys: [redisKey],
+                arguments: [String(normalizedWindowMs)],
+            }), this.operationTimeoutMs, "increment");
+        }
+        catch (error) {
+            if (isTimeoutError(error)) {
+                this.invalidateClient(client, generation, true);
+            }
+            throw error;
+        }
+        const [count, pttl] = parseIncrementResult(result);
+        const ttl = pttl > 0 ? requireRateLimitWindowMs(pttl) : normalizedWindowMs;
+        return { count, resetAt: Date.now() + ttl };
+    }
+    async reset(key) {
+        const client = await this.ensureClient();
+        const generation = this.clientGeneration;
+        try {
+            await this.withTimeout(client.del(this.storageKey(requireRateLimitKey(key))), this.operationTimeoutMs, "reset");
+        }
+        catch (error) {
+            if (isTimeoutError(error)) {
+                this.invalidateClient(client, generation, true);
+            }
+            throw error;
+        }
+    }
+    async destroy() {
+        const client = this.client;
+        const connectingClient = this.connectingClient;
+        const pending = this.clientPromise;
+        const cancelPendingConnection = this.cancelPendingConnection;
+        const clientsToDisconnect = new Set(this.pendingDisconnectClients);
+        if (client)
+            clientsToDisconnect.add(client);
+        if (connectingClient)
+            clientsToDisconnect.add(connectingClient);
+        this.clientGeneration++;
+        this.client = null;
+        this.connectingClient = null;
+        this.clientPromise = null;
+        this.cancelPendingConnection = null;
+        cancelPendingConnection?.();
+        let disconnectFailed = false;
+        let disconnectError;
+        await Promise.all([...clientsToDisconnect].map((clientToDisconnect) => this.disconnectClient(clientToDisconnect).catch((error) => {
+            disconnectFailed = true;
+            disconnectError ??= error;
+        })));
+        pending?.catch(() => { });
+        if (disconnectFailed)
+            throw disconnectError;
+    }
+}
+function requireTimeoutMs(value, name) {
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value <= 0 ||
+        value > MAX_TIMER_DELAY_MS) {
+        throw new RangeError(`Redis rate limit ${name} must be an integer between 1 and ${MAX_TIMER_DELAY_MS}`);
+    }
+    return value;
+}
+function createTimeoutError(operationName, timeoutMs) {
+    const error = new Error(`Redis rate limit ${operationName} timed out after ${timeoutMs}ms`);
+    error.name = "TimeoutError";
+    return error;
+}
+function isTimeoutError(error) {
+    return error instanceof Error && error.name === "TimeoutError";
+}
+function parseIncrementResult(result) {
+    if (!Array.isArray(result) || result.length < 2) {
+        throw toError(createError({
+            type: "config",
+            message: "Redis rate limit eval returned an invalid result.",
+        }));
+    }
+    const count = Number(result[0]);
+    const ttl = Number(result[1]);
+    if (!Number.isSafeInteger(count) || count < 1) {
+        throw toError(createError({
+            type: "config",
+            message: "Redis rate limit eval returned an invalid count.",
+        }));
+    }
+    if (!Number.isSafeInteger(ttl)) {
+        throw toError(createError({
+            type: "config",
+            message: "Redis rate limit eval returned an invalid TTL.",
+        }));
+    }
+    return [count, ttl];
+}

package/esm/redis-client-manager.d.ts

@@ -1,4 +1,5 @@
 import type { RedisClient, RedisClientOptions } from "veryfront/extensions/distributed";
+export type { RedisClient, RedisClientOptions } from "veryfront/extensions/distributed";
 /** Minimal `@redis/client` factory options used by this extension. */
 export interface RedisClientFactoryOptions {
     url?: string;
@@ -23,6 +24,7 @@ export interface RedisClientOpenLifecycle {
 export interface RedisClientManager {
     getClient(options?: RedisClientOptions): Promise<RedisClient>;
     disconnect(): Promise<void>;
+    isConfigured(options?: RedisClientOptions): boolean;
 }
 /** Internal handoff of a provisional client that still requires cleanup. */
 export declare function takeRedisClientSetupCleanupClient(error: unknown): RedisClient | undefined;
@@ -30,4 +32,10 @@ export declare function takeRedisClientSetupCleanupClient(error: unknown): Redis
 export declare function openRedisClient(options?: RedisClientOptions, dependencies?: RedisClientManagerDependencies, lifecycle?: RedisClientOpenLifecycle): Promise<RedisClient>;
 /** Create an isolated, concurrency-safe Redis client manager. */
 export declare function createRedisClientManager(dependencies?: RedisClientManagerDependencies): RedisClientManager;
+/** Acquire a connection from the extension-owned shared manager. */
+export declare function getRedisClient(options?: RedisClientOptions): Promise<RedisClient>;
+/** Disconnect the shared manager so the next call reconnects from a clean state. */
+export declare function disconnectRedisClient(): Promise<void>;
+/** Report whether the shared manager has an explicit Redis endpoint. */
+export declare function isRedisConfigured(options?: RedisClientOptions): boolean;
 //# sourceMappingURL=redis-client-manager.d.ts.map

package/esm/redis-client-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redis-client-manager.d.ts","sourceRoot":"","sources":["../src/redis-client-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAyBxF,sEAAsE;AACtE,MAAM,WAAW,yBAAyB;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE;QACP,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,iBAAiB,CAAC,EAAE,KAAK,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,WAAW,CAAC;AAErF,MAAM,WAAW,8BAA8B;IAC7C,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,eAAe,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;CACrE;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC9D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAeD,4EAA4E;AAC5E,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,CAKzF;AAuOD,qDAAqD;AACrD,wBAAsB,eAAe,CACnC,OAAO,GAAE,kBAAuB,EAChC,YAAY,GAAE,8BAAmC,EACjD,SAAS,GAAE,wBAA6B,GACvC,OAAO,CAAC,WAAW,CAAC,CA4DtB;AAOD,iEAAiE;AACjE,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,8BAAmC,GAChD,kBAAkB,CA6QpB"}
+{"version":3,"file":"redis-client-manager.d.ts","sourceRoot":"","sources":["../src/redis-client-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACxF,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAyBxF,sEAAsE;AACtE,MAAM,WAAW,yBAAyB;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE;QACP,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,iBAAiB,CAAC,EAAE,KAAK,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,WAAW,CAAC;AAErF,MAAM,WAAW,8BAA8B;IAC7C,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,eAAe,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;CACrE;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC9D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,YAAY,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC;CACrD;AAeD,4EAA4E;AAC5E,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,CAKzF;AAuOD,qDAAqD;AACrD,wBAAsB,eAAe,CACnC,OAAO,GAAE,kBAAuB,EAChC,YAAY,GAAE,8BAAmC,EACjD,SAAS,GAAE,wBAA6B,GACvC,OAAO,CAAC,WAAW,CAAC,CA4DtB;AAOD,iEAAiE;AACjE,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,8BAAmC,GAChD,kBAAkB,CAqRpB;AAID,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC,CAErF;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAErD;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAE3E"}

package/esm/redis-client-manager.js

@@ -531,5 +531,26 @@ export function createRedisClientManager(dependencies = {}) {
         disconnecting = tracked;
         return tracked;
     }
-    return { getClient, disconnect };
+    function isConfigured(options = {}) {
+        const capturedOptions = captureClientOptions(options);
+        const configured = capturedOptions.url ?? readEnv("REDIS_URL");
+        if (configured === undefined || configured.length === 0)
+            return false;
+        requireRedisUrl(configured);
+        return true;
+    }
+    return { getClient, disconnect, isConfigured };
+}
+const defaultManager = createRedisClientManager();
+/** Acquire a connection from the extension-owned shared manager. */
+export function getRedisClient(options = {}) {
+    return defaultManager.getClient(options);
+}
+/** Disconnect the shared manager so the next call reconnects from a clean state. */
+export function disconnectRedisClient() {
+    return defaultManager.disconnect();
+}
+/** Report whether the shared manager has an explicit Redis endpoint. */
+export function isRedisConfigured(options = {}) {
+    return defaultManager.isConfigured(options);
 }

package/esm/redis-runtime-provider.js

@@ -47,7 +47,7 @@ const CLIENT_METHODS = [
     "pExpire",
     "pTTL",
 ];
-const OPTIONAL_CLIENT_METHODS = ["ttl", "on"];
+const OPTIONAL_CLIENT_METHODS = ["ttl", "info", "on"];
 function readOptionalClientMethod(target, name) {
     let owner = target;
     const visited = new Set();

package/esm/render-cache-store.d.ts

@@ -0,0 +1,34 @@
+import { type CachePayload, type RenderCacheStore as CacheStore } from "veryfront/extensions/distributed/cache-support";
+import { type RedisClientManager } from "./redis-client-manager.js";
+export interface RedisCacheStoreOptions {
+    url?: string;
+    connectTimeoutMs?: number;
+    /** Canonical provider-neutral cache namespace. */
+    keyPrefix?: string;
+    /** TTL in seconds for cache entries (default: 3600 = 1 hour) */
+    ttlSeconds?: number;
+    /** Optional connection manager for embedding/tests. */
+    clientManager?: RedisClientManager;
+}
+export declare class RedisCacheStore implements CacheStore {
+    private readonly connectionOptions;
+    private readonly keyPrefix;
+    private readonly ttlSeconds;
+    private readonly clientManager;
+    constructor(options?: RedisCacheStoreOptions);
+    private ensureClient;
+    private storageKey;
+    private resetRedisConnection;
+    private resetAfterFailure;
+    private scanKeys;
+    private resolveRetentionTtlSeconds;
+    private deleteKeys;
+    private deleteRedisKey;
+    get(key: string): Promise<CachePayload | undefined>;
+    set(key: string, value: CachePayload): Promise<void>;
+    delete(key: string): Promise<void>;
+    deleteByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=render-cache-store.d.ts.map

package/esm/render-cache-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-cache-store.d.ts","sourceRoot":"","sources":["../src/render-cache-store.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EAIjB,KAAK,gBAAgB,IAAI,UAAU,EAGpC,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AAcnC,MAAM,WAAW,sBAAsB;IACrC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED,qBAAa,eAAgB,YAAW,UAAU;IAChD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsD;IACxF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;gBAEvC,OAAO,GAAE,sBAA2B;YAclC,YAAY;IAI1B,OAAO,CAAC,UAAU;YAIJ,oBAAoB;YAIpB,iBAAiB;YAQjB,QAAQ;IA4CtB,OAAO,CAAC,0BAA0B;YAYpB,UAAU;YAaV,cAAc;IAOtB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAiBnD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBpD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWlC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAa/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAYtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}