@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/coordination/redis-runtime.js

@@ -0,0 +1,698 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { createClient } from 'redis';
+import { StateLockTimeoutError } from '../state-lock.js';
+const DEFAULT_CONNECT_TIMEOUT_MS = 500;
+const DEFAULT_COMMAND_TIMEOUT_MS = 1_000;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_CACHE_TTL_MS = 300_000;
+const DEFAULT_LOCK_TTL_MS = 30_000;
+const DEFAULT_STREAM_MAX_LEN = 10_000;
+const DEFAULT_NAMESPACE = 'codesdd';
+const REDIS_SCHEMA_VERSION = 1;
+function parseBoolean(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'yes')
+        return true;
+    if (normalized === 'false' || normalized === '0' || normalized === 'no')
+        return false;
+    return undefined;
+}
+function parsePositiveInteger(value) {
+    if (value === undefined || value.trim() === '')
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseNonNegativeInteger(value) {
+    if (value === undefined || value.trim() === '')
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function envString(env, key) {
+    const value = env[key]?.trim();
+    return value ? value : undefined;
+}
+function normalizeFallback(value) {
+    if (value === 'filesystem' || value === 'none')
+        return value;
+    return undefined;
+}
+function normalizeNamespace(value) {
+    const namespace = value?.trim() || DEFAULT_NAMESPACE;
+    return namespace;
+}
+function validateNamespace(namespace) {
+    if (!/^[A-Za-z0-9:_-]{1,80}$/.test(namespace)) {
+        return 'Redis namespace must use only letters, numbers, colon, underscore, or hyphen and be at most 80 characters.';
+    }
+    return undefined;
+}
+export function redactRedisUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        const auth = parsed.username || parsed.password ? '[REDACTED]@' : '';
+        return `${parsed.protocol}//${auth}${parsed.host}${parsed.pathname}${parsed.search}${parsed.hash}`;
+    }
+    catch {
+        return '[REDACTED_REDIS_URL]';
+    }
+}
+export function sanitizeRedisError(error, config) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const redactedUrl = redactRedisUrl(config?.url);
+    let sanitized = raw;
+    if (config?.url) {
+        sanitized = sanitized.split(config.url).join(redactedUrl ?? '[REDACTED_REDIS_URL]');
+    }
+    sanitized = sanitized.replace(/redis(s)?:\/\/[^\s]+/giu, '[REDACTED_REDIS_URL]');
+    return sanitized;
+}
+export function hashRedisKey(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+export function buildRedisKey(config, projectFingerprint, domain, key) {
+    return [
+        config.namespace,
+        `v${REDIS_SCHEMA_VERSION}`,
+        projectFingerprint,
+        domain,
+        hashRedisKey(key),
+    ].join(':');
+}
+export function resolveRedisRuntimeConfig(env = process.env, globalConfig = {}) {
+    const redisConfig = globalConfig.redis ?? {};
+    const warnings = [];
+    const validationErrors = [];
+    const primaryEnvUrl = envString(env, 'CODESDD_REDIS_URL');
+    const fallbackEnvUrl = envString(env, 'REDIS_URL');
+    if (primaryEnvUrl && fallbackEnvUrl && primaryEnvUrl !== fallbackEnvUrl) {
+        validationErrors.push('CODESDD_REDIS_URL and REDIS_URL are both set with different values.');
+    }
+    const urlFromConfiguredEnv = redisConfig.url_env ? envString(env, redisConfig.url_env) : undefined;
+    const url = primaryEnvUrl || fallbackEnvUrl || urlFromConfiguredEnv || redisConfig.url?.trim() || undefined;
+    const enabledFromEnv = parseBoolean(env.CODESDD_REDIS_ENABLED);
+    const enabled = enabledFromEnv ?? redisConfig.enabled ?? Boolean(url);
+    const namespace = normalizeNamespace(envString(env, 'CODESDD_REDIS_NAMESPACE') || redisConfig.namespace);
+    const namespaceError = validateNamespace(namespace);
+    if (namespaceError)
+        validationErrors.push(namespaceError);
+    const tlsFromEnv = parseBoolean(env.CODESDD_REDIS_TLS);
+    const tls = tlsFromEnv ?? redisConfig.tls ?? Boolean(url?.startsWith('rediss://'));
+    const connectTimeoutMs = parsePositiveInteger(env.CODESDD_REDIS_CONNECT_TIMEOUT_MS) ??
+        redisConfig.connect_timeout_ms ??
+        DEFAULT_CONNECT_TIMEOUT_MS;
+    const commandTimeoutMs = parsePositiveInteger(env.CODESDD_REDIS_COMMAND_TIMEOUT_MS) ??
+        redisConfig.command_timeout_ms ??
+        DEFAULT_COMMAND_TIMEOUT_MS;
+    const maxRetries = parseNonNegativeInteger(env.CODESDD_REDIS_MAX_RETRIES) ??
+        redisConfig.max_retries ??
+        DEFAULT_MAX_RETRIES;
+    const fallback = normalizeFallback(env.CODESDD_REDIS_FALLBACK) ??
+        normalizeFallback(redisConfig.fallback) ??
+        'filesystem';
+    const cacheDefaultTtlMs = parsePositiveInteger(env.CODESDD_REDIS_CACHE_TTL_MS) ??
+        redisConfig.cache_default_ttl_ms ??
+        DEFAULT_CACHE_TTL_MS;
+    const lockTtlMs = parsePositiveInteger(env.CODESDD_REDIS_LOCK_TTL_MS) ??
+        redisConfig.lock_ttl_ms ??
+        DEFAULT_LOCK_TTL_MS;
+    const streamMaxLen = parsePositiveInteger(env.CODESDD_REDIS_STREAM_MAX_LEN) ??
+        redisConfig.stream_max_len ??
+        DEFAULT_STREAM_MAX_LEN;
+    if (url) {
+        try {
+            const parsed = new URL(url);
+            if (parsed.protocol !== 'redis:' && parsed.protocol !== 'rediss:') {
+                validationErrors.push('Redis URL scheme must be redis:// or rediss://.');
+            }
+        }
+        catch {
+            validationErrors.push('Redis URL is invalid.');
+        }
+    }
+    if (enabled && !url) {
+        warnings.push('Redis is enabled but no Redis URL is configured.');
+    }
+    return {
+        requested: Boolean(enabled || url),
+        enabled,
+        namespace,
+        url,
+        redactedUrl: redactRedisUrl(url),
+        tls,
+        connectTimeoutMs,
+        commandTimeoutMs,
+        maxRetries,
+        fallback,
+        cacheDefaultTtlMs,
+        lockTtlMs,
+        streamMaxLen,
+        validationErrors,
+        warnings,
+    };
+}
+export function resolveRedisBoundaryConfig(env = process.env, globalConfig = {}) {
+    return resolveRedisRuntimeConfig(env, globalConfig);
+}
+function defaultRedisClientCreator(config) {
+    if (!config.url) {
+        throw new Error('Redis URL is required to create a client.');
+    }
+    const socket = config.tls
+        ? {
+            tls: true,
+            connectTimeout: config.connectTimeoutMs,
+            socketTimeout: config.commandTimeoutMs,
+            reconnectStrategy: (retries) => retries >= config.maxRetries ? false : Math.min(50 * (retries + 1), 250),
+        }
+        : {
+            tls: false,
+            connectTimeout: config.connectTimeoutMs,
+            socketTimeout: config.commandTimeoutMs,
+            reconnectStrategy: (retries) => retries >= config.maxRetries ? false : Math.min(50 * (retries + 1), 250),
+        };
+    const client = createClient({
+        url: config.url,
+        socket,
+        disableOfflineQueue: true,
+    });
+    return client;
+}
+async function withTimeout(promise, timeoutMs, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export class RedisClientFactory {
+    config;
+    createClientImpl;
+    client;
+    lastError;
+    constructor(config, createClientImpl = defaultRedisClientCreator) {
+        this.config = config;
+        this.createClientImpl = createClientImpl;
+    }
+    async getClient() {
+        if (!this.config.url) {
+            throw new Error('Redis URL is not configured.');
+        }
+        if (this.client?.isReady) {
+            return this.client;
+        }
+        if (!this.client) {
+            const client = this.createClientImpl(this.config);
+            client.on?.('error', (error) => {
+                this.lastError = sanitizeRedisError(error, this.config);
+            });
+            this.client = client;
+        }
+        if (!this.client.isOpen && !this.client.isReady) {
+            await withTimeout(this.client.connect(), this.config.connectTimeoutMs, 'Redis connect');
+        }
+        return this.client;
+    }
+    async ping() {
+        const started = performance.now();
+        try {
+            const client = await this.getClient();
+            const response = await withTimeout(client.ping(), this.config.commandTimeoutMs, 'Redis ping');
+            return {
+                ok: response === 'PONG' || response.length > 0,
+                latencyMs: Math.round(performance.now() - started),
+                message: response,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                latencyMs: Math.round(performance.now() - started),
+                message: sanitizeRedisError(error, this.config),
+            };
+        }
+    }
+    async command(args) {
+        const client = await this.getClient();
+        return withTimeout(client.sendCommand(args), this.config.commandTimeoutMs, `Redis ${args[0] ?? 'command'}`);
+    }
+    async close() {
+        if (!this.client)
+            return;
+        const client = this.client;
+        this.client = undefined;
+        try {
+            if (client.close && (client.isOpen || client.isReady)) {
+                await client.close();
+                return;
+            }
+            client.destroy?.();
+        }
+        catch {
+            // Shutdown is best effort; connection errors are reported by the operation itself.
+        }
+    }
+    getLastError() {
+        return this.lastError;
+    }
+}
+export async function buildRedisOperationalReport(options = {}) {
+    const config = resolveRedisRuntimeConfig(options.env, options.globalConfig);
+    if (!config.requested) {
+        return {
+            requested: false,
+            namespace: config.namespace,
+            status: 'disabled',
+            fallback: config.fallback,
+            reason: 'Redis is optional and disabled; filesystem-first defaults are authoritative.',
+            validation_errors: [],
+            warnings: config.warnings,
+        };
+    }
+    if (config.validationErrors.length > 0) {
+        return {
+            requested: true,
+            namespace: config.namespace,
+            status: 'blocked',
+            fallback: config.fallback,
+            redacted_url: config.redactedUrl,
+            reason: 'Redis configuration is invalid and was blocked fail-closed.',
+            validation_errors: config.validationErrors,
+            warnings: config.warnings,
+        };
+    }
+    if (!config.url) {
+        return {
+            requested: true,
+            namespace: config.namespace,
+            status: config.fallback === 'none' ? 'blocked' : 'requested-unavailable',
+            fallback: config.fallback,
+            reason: config.fallback === 'none'
+                ? 'Redis is required but no Redis URL is configured.'
+                : 'Redis is requested but no Redis URL is configured; filesystem fallback remains active.',
+            validation_errors: [],
+            warnings: config.warnings,
+        };
+    }
+    const factory = new RedisClientFactory(config, options.createClient);
+    try {
+        const ping = await factory.ping();
+        if (!ping.ok) {
+            return {
+                requested: true,
+                namespace: config.namespace,
+                status: config.fallback === 'none' ? 'blocked' : 'requested-unavailable',
+                fallback: config.fallback,
+                redacted_url: config.redactedUrl,
+                latency_ms: ping.latencyMs,
+                reason: ping.message,
+                validation_errors: [],
+                warnings: config.warnings,
+            };
+        }
+        return {
+            requested: true,
+            namespace: config.namespace,
+            status: 'ready',
+            fallback: config.fallback,
+            redacted_url: config.redactedUrl,
+            latency_ms: ping.latencyMs,
+            reason: 'Redis ping succeeded.',
+            validation_errors: [],
+            warnings: config.warnings,
+        };
+    }
+    finally {
+        await factory.close();
+    }
+}
+function ttlSeconds(ttlMs) {
+    return String(Math.max(1, Math.ceil(ttlMs / 1000)));
+}
+function remainingTtlMs(expiresAt) {
+    if (!expiresAt)
+        return -1;
+    const parsed = Date.parse(expiresAt);
+    if (Number.isNaN(parsed))
+        return 0;
+    return Math.max(0, parsed - Date.now());
+}
+export class RedisCoordinationCache {
+    redis;
+    fallback;
+    projectFingerprint;
+    domain;
+    constructor(redis, fallback, projectFingerprint, domain = 'cache') {
+        this.redis = redis;
+        this.fallback = fallback;
+        this.projectFingerprint = projectFingerprint;
+        this.domain = domain;
+    }
+    async get(key) {
+        const fallbackValue = await this.fallback.get(key);
+        if (typeof fallbackValue !== 'undefined')
+            return fallbackValue;
+        try {
+            const redisKey = buildRedisKey(this.redis.config, this.projectFingerprint, this.domain, key);
+            const raw = await this.redis.command(['GET', redisKey]);
+            if (!raw)
+                return undefined;
+            const entry = JSON.parse(raw);
+            if (entry.schema_version !== REDIS_SCHEMA_VERSION)
+                return undefined;
+            const ttlMs = remainingTtlMs(entry.expires_at);
+            if (ttlMs === 0) {
+                await this.redis.command(['DEL', redisKey]);
+                return undefined;
+            }
+            await this.fallback.set(key, entry.value, ttlMs > 0 ? { ttlMs } : {});
+            return entry.value;
+        }
+        catch {
+            return this.fallback.get(key);
+        }
+    }
+    async set(key, value, options = {}) {
+        await this.fallback.set(key, value, options);
+        const ttlMs = options.ttlMs ?? this.redis.config.cacheDefaultTtlMs;
+        const entry = {
+            schema_version: REDIS_SCHEMA_VERSION,
+            value,
+            created_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + ttlMs).toISOString(),
+        };
+        try {
+            await this.redis.command(['SET', buildRedisKey(this.redis.config, this.projectFingerprint, this.domain, key), JSON.stringify(entry), 'EX', ttlSeconds(ttlMs)]);
+        }
+        catch {
+            // Redis is an acceleration tier; filesystem fallback already persisted the value.
+        }
+    }
+    async delete(key) {
+        await this.fallback.delete(key);
+        try {
+            await this.redis.command(['DEL', buildRedisKey(this.redis.config, this.projectFingerprint, this.domain, key)]);
+        }
+        catch {
+            // best effort
+        }
+    }
+    async clear() {
+        await this.fallback.clear();
+        await deleteKeysByPrefix(this.redis, `${this.redis.config.namespace}:v${REDIS_SCHEMA_VERSION}:${this.projectFingerprint}:${this.domain}:`);
+    }
+}
+export class RedisLockAdapter {
+    redis;
+    fallback;
+    projectFingerprint;
+    constructor(redis, fallback, projectFingerprint) {
+        this.redis = redis;
+        this.fallback = fallback;
+        this.projectFingerprint = projectFingerprint;
+    }
+    async withLock(scope, fn, options = {}) {
+        if (!this.redis.config.url || this.redis.config.validationErrors.length > 0) {
+            return this.fallback.withLock(scope, fn, options);
+        }
+        const token = randomUUID();
+        const ttlMs = options.staleMs ?? this.redis.config.lockTtlMs;
+        const timeoutMs = options.timeoutMs ?? 30_000;
+        const deadline = Date.now() + timeoutMs;
+        const key = buildRedisKey(this.redis.config, this.projectFingerprint, 'lock', scope);
+        const fencingKey = buildRedisKey(this.redis.config, this.projectFingerprint, 'fence', scope);
+        while (true) {
+            if (options.signal?.aborted) {
+                throw new StateLockTimeoutError(key);
+            }
+            try {
+                const response = await this.redis.command(['SET', key, token, 'PX', String(ttlMs), 'NX']);
+                if (response === 'OK') {
+                    await this.redis.command(['INCR', fencingKey]);
+                    try {
+                        return await fn();
+                    }
+                    finally {
+                        await this.release(key, token);
+                    }
+                }
+            }
+            catch {
+                if (this.redis.config.fallback === 'filesystem') {
+                    return this.fallback.withLock(scope, fn, options);
+                }
+                throw new StateLockTimeoutError(key);
+            }
+            if (Date.now() >= deadline) {
+                throw new StateLockTimeoutError(key);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    async extend(scope, ownerToken, ttlMs = this.redis.config.lockTtlMs) {
+        const key = buildRedisKey(this.redis.config, this.projectFingerprint, 'lock', scope);
+        const result = await this.redis.command([
+            'EVAL',
+            "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) else return 0 end",
+            '1',
+            key,
+            ownerToken,
+            String(ttlMs),
+        ]);
+        return Number(result) === 1;
+    }
+    async release(key, token) {
+        try {
+            await this.redis.command([
+                'EVAL',
+                "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end",
+                '1',
+                key,
+                token,
+            ]);
+        }
+        catch {
+            // Lock release is best effort after TTL; never expose Redis details here.
+        }
+    }
+}
+export class RedisQueueAdapter {
+    redis;
+    fallback;
+    projectFingerprint;
+    constructor(redis, fallback, projectFingerprint) {
+        this.redis = redis;
+        this.fallback = fallback;
+        this.projectFingerprint = projectFingerprint;
+    }
+    async enqueue(topic, item) {
+        try {
+            const key = buildRedisKey(this.redis.config, this.projectFingerprint, 'queue', topic);
+            await this.redis.command([
+                'XADD',
+                key,
+                'MAXLEN',
+                '~',
+                String(this.redis.config.streamMaxLen),
+                '*',
+                'payload',
+                JSON.stringify(item),
+            ]);
+        }
+        catch {
+            await this.fallback.enqueue(topic, item);
+        }
+    }
+    async dequeue(topic) {
+        try {
+            const key = buildRedisKey(this.redis.config, this.projectFingerprint, 'queue', topic);
+            const reply = await this.redis.command(['XREAD', 'COUNT', '1', 'STREAMS', key, '0']);
+            const parsed = parseFirstStreamPayload(reply);
+            if (!parsed)
+                return undefined;
+            await this.redis.command(['XDEL', key, parsed.id]);
+            return parsed.payload;
+        }
+        catch {
+            return this.fallback.dequeue(topic);
+        }
+    }
+    async size(topic) {
+        try {
+            const key = buildRedisKey(this.redis.config, this.projectFingerprint, 'queue', topic);
+            const size = await this.redis.command(['XLEN', key]);
+            return Number(size);
+        }
+        catch {
+            return this.fallback.size(topic);
+        }
+    }
+}
+export class RedisEventBusAdapter {
+    redis;
+    fallback;
+    projectFingerprint;
+    constructor(redis, fallback, projectFingerprint) {
+        this.redis = redis;
+        this.fallback = fallback;
+        this.projectFingerprint = projectFingerprint;
+    }
+    async publish(event) {
+        try {
+            const streamKey = buildRedisKey(this.redis.config, this.projectFingerprint, 'events', event.type);
+            const channelKey = `${this.redis.config.namespace}:events:${hashRedisKey(event.type)}`;
+            const payload = JSON.stringify(event);
+            await this.redis.command([
+                'XADD',
+                streamKey,
+                'MAXLEN',
+                '~',
+                String(this.redis.config.streamMaxLen),
+                '*',
+                'payload',
+                payload,
+            ]);
+            await this.redis.command(['PUBLISH', channelKey, payload]);
+        }
+        catch {
+            await this.fallback.publish(event);
+        }
+    }
+    async drain() {
+        try {
+            const prefix = `${this.redis.config.namespace}:v${REDIS_SCHEMA_VERSION}:${this.projectFingerprint}:events:`;
+            const keys = await scanKeysByPrefix(this.redis, prefix);
+            const events = [];
+            for (const key of keys) {
+                const reply = await this.redis.command(['XREAD', 'COUNT', '100', 'STREAMS', key, '0']);
+                const parsed = parseStreamPayloads(reply);
+                events.push(...parsed.map((entry) => entry.payload));
+                if (parsed.length > 0) {
+                    await this.redis.command(['XDEL', key, ...parsed.map((entry) => entry.id)]);
+                }
+            }
+            return events;
+        }
+        catch {
+            return this.fallback.drain();
+        }
+    }
+}
+export class RedisWorkDeduper {
+    redis;
+    projectFingerprint;
+    constructor(redis, projectFingerprint) {
+        this.redis = redis;
+        this.projectFingerprint = projectFingerprint;
+    }
+    async claim(key, ttlMs = this.redis.config.cacheDefaultTtlMs) {
+        const redisKey = buildRedisKey(this.redis.config, this.projectFingerprint, 'dedupe', key);
+        const result = await this.redis.command(['SET', redisKey, '1', 'PX', String(ttlMs), 'NX']);
+        return result === 'OK';
+    }
+}
+function parseFirstStreamPayload(reply) {
+    return parseStreamPayloads(reply)[0];
+}
+function parseStreamPayloads(reply) {
+    const entries = [];
+    const streamEntries = Array.isArray(reply)
+        ? reply.map((streamEntry) => (Array.isArray(streamEntry) ? streamEntry[1] : undefined))
+        : typeof reply === 'object' && reply !== null
+            ? Object.values(reply)
+            : [];
+    for (const stream of streamEntries) {
+        if (!Array.isArray(stream))
+            continue;
+        for (const entry of stream) {
+            const parsed = parseStreamEntryPayload(entry);
+            if (parsed)
+                entries.push(parsed);
+        }
+    }
+    return entries;
+}
+function parseStreamEntryPayload(entry) {
+    if (!Array.isArray(entry) || typeof entry[0] !== 'string' || !Array.isArray(entry[1]))
+        return undefined;
+    const fields = entry[1];
+    const payloadIndex = fields.findIndex((field) => field === 'payload');
+    if (payloadIndex < 0 || typeof fields[payloadIndex + 1] !== 'string')
+        return undefined;
+    return { id: entry[0], payload: JSON.parse(fields[payloadIndex + 1]) };
+}
+async function scanKeysByPrefix(redis, prefix) {
+    const keys = [];
+    let cursor = '0';
+    do {
+        const reply = await redis.command(['SCAN', cursor, 'MATCH', `${prefix}*`, 'COUNT', '100']);
+        cursor = String(reply[0] ?? '0');
+        if (Array.isArray(reply[1])) {
+            keys.push(...reply[1].filter((key) => typeof key === 'string'));
+        }
+    } while (cursor !== '0');
+    return keys;
+}
+export async function deleteKeysByPrefix(redis, prefix) {
+    const keys = await scanKeysByPrefix(redis, prefix);
+    if (keys.length === 0)
+        return 0;
+    const result = await redis.command(['DEL', ...keys]);
+    return Number(result);
+}
+export async function runRedisBenchmark(options) {
+    const config = resolveRedisRuntimeConfig(options.env, options.globalConfig);
+    const iterations = Math.max(1, Math.min(options.iterations ?? 10, 100));
+    if (!config.requested || config.validationErrors.length > 0 || !config.url) {
+        const report = await buildRedisOperationalReport(options);
+        return {
+            status: report.status,
+            namespace: report.namespace,
+            iterations,
+            reason: report.reason,
+        };
+    }
+    const factory = new RedisClientFactory(config, options.createClient);
+    const samples = [];
+    try {
+        for (let i = 0; i < iterations; i++) {
+            const key = buildRedisKey(config, 'benchmark', 'bench', String(i));
+            const started = performance.now();
+            await factory.command(['SET', key, '1', 'PX', '1000']);
+            await factory.command(['GET', key]);
+            samples.push(performance.now() - started);
+        }
+        samples.sort((a, b) => a - b);
+        return {
+            status: 'ready',
+            namespace: config.namespace,
+            iterations,
+            p50_ms: Math.round(percentile(samples, 0.5)),
+            p95_ms: Math.round(percentile(samples, 0.95)),
+            reason: 'Redis benchmark completed.',
+        };
+    }
+    finally {
+        await factory.close();
+    }
+}
+function percentile(values, quantile) {
+    if (values.length === 0)
+        return 0;
+    const index = Math.min(values.length - 1, Math.ceil(values.length * quantile) - 1);
+    return values[index];
+}
+//# sourceMappingURL=redis-runtime.js.map