opencode-graphiti 0.0.0-development

package/script/src/services/redis-client.js

@@ -0,0 +1,943 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+const logger_js_1 = require("./logger.js");
+class InMemoryRedisStore {
+    constructor() {
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    ping() {
+        return Promise.resolve("PONG");
+    }
+    quit() {
+        return Promise.resolve("OK");
+    }
+    cleanup(key) {
+        const value = this.values.get(key);
+        if (!value?.expiresAt)
+            return;
+        if (value.expiresAt <= Date.now())
+            this.values.delete(key);
+    }
+    ensureList(key) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (existing) {
+            if (!Array.isArray(existing.value)) {
+                throw new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
+            }
+            return existing.value;
+        }
+        const list = [];
+        this.values.set(key, { value: list });
+        return list;
+    }
+    ensureHash(key) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (existing) {
+            if (!(existing.value instanceof Map)) {
+                throw new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
+            }
+            return existing.value;
+        }
+        const hash = new Map();
+        this.values.set(key, { value: hash });
+        return hash;
+    }
+    parseSetArgs(args) {
+        let onlyIfAbsent = false;
+        let ttlSeconds;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "NX") {
+                onlyIfAbsent = true;
+                continue;
+            }
+            if (arg === "EX") {
+                const next = args[index + 1];
+                if (typeof next !== "number") {
+                    throw new Error("ERR unsupported in-memory Redis SET arguments");
+                }
+                ttlSeconds = next;
+                index += 1;
+                continue;
+            }
+            throw new Error("ERR unsupported in-memory Redis SET arguments");
+        }
+        return { onlyIfAbsent, ttlSeconds };
+    }
+    lpush(key, value) {
+        const list = this.ensureList(key);
+        list.unshift(value);
+        return Promise.resolve(list.length);
+    }
+    rpush(key, value) {
+        const list = this.ensureList(key);
+        list.push(value);
+        return Promise.resolve(list.length);
+    }
+    lmove(source, destination, sourceSide, destinationSide) {
+        this.cleanup(source);
+        this.cleanup(destination);
+        const existing = this.values.get(source);
+        if (!existing || !Array.isArray(existing.value) || existing.value.length === 0) {
+            return Promise.resolve(null);
+        }
+        const sourceList = existing.value;
+        const value = sourceSide === "LEFT" ? sourceList.shift() : sourceList.pop();
+        if (value === undefined)
+            return Promise.resolve(null);
+        const destinationList = this.ensureList(destination);
+        if (destinationSide === "LEFT") {
+            destinationList.unshift(value);
+        }
+        else {
+            destinationList.push(value);
+        }
+        return Promise.resolve(value);
+    }
+    lrange(key, start, stop) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing || !Array.isArray(existing.value))
+            return Promise.resolve([]);
+        const list = existing.value;
+        const normalizeIndex = (index) => index < 0 ? Math.max(list.length + index, 0) : index;
+        const from = normalizeIndex(start);
+        const to = stop < 0 ? list.length + stop : stop;
+        return Promise.resolve(list.slice(from, to + 1));
+    }
+    llen(key) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        return Promise.resolve(existing && Array.isArray(existing.value) ? existing.value.length : 0);
+    }
+    lindex(key, index) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing || !Array.isArray(existing.value)) {
+            return Promise.resolve(null);
+        }
+        const list = existing.value;
+        const normalized = index < 0 ? list.length + index : index;
+        return Promise.resolve(list[normalized] ?? null);
+    }
+    lset(key, index, value) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing || !Array.isArray(existing.value)) {
+            return Promise.reject(new Error("ERR no such key"));
+        }
+        const list = existing.value;
+        const normalized = index < 0 ? list.length + index : index;
+        if (normalized < 0 || normalized >= list.length) {
+            return Promise.reject(new Error("ERR index out of range"));
+        }
+        list[normalized] = value;
+        return Promise.resolve();
+    }
+    ltrim(key, start, stop) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing || !Array.isArray(existing.value))
+            return Promise.resolve();
+        const list = existing.value;
+        const normalizeIndex = (index) => index < 0 ? Math.max(list.length + index, 0) : index;
+        const trimmed = list.slice(normalizeIndex(start), stop < 0 ? list.length + stop + 1 : stop + 1);
+        existing.value = trimmed;
+        return Promise.resolve();
+    }
+    get(key) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        return Promise.resolve(existing && typeof existing.value === "string" ? existing.value : null);
+    }
+    hset(key, values) {
+        const hash = this.ensureHash(key);
+        let added = 0;
+        for (const [field, value] of Object.entries(values)) {
+            if (!hash.has(field))
+                added += 1;
+            hash.set(field, value);
+        }
+        return Promise.resolve(added);
+    }
+    hgetall(key) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing)
+            return Promise.resolve({});
+        if (!(existing.value instanceof Map)) {
+            return Promise.reject(new Error("WRONGTYPE Operation against a key holding the wrong kind of value"));
+        }
+        return Promise.resolve(Object.fromEntries(existing.value.entries()));
+    }
+    set(key, value, ...args) {
+        this.cleanup(key);
+        const { onlyIfAbsent, ttlSeconds } = this.parseSetArgs(args);
+        if (onlyIfAbsent && this.values.has(key))
+            return Promise.resolve(null);
+        this.values.set(key, {
+            value,
+            expiresAt: ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined,
+        });
+        return Promise.resolve("OK");
+    }
+    expire(key, ttlSeconds) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing)
+            return Promise.resolve(0);
+        existing.expiresAt = Date.now() + ttlSeconds * 1000;
+        return Promise.resolve(1);
+    }
+    del(key) {
+        return Promise.resolve(this.values.delete(key) ? 1 : 0);
+    }
+    setIfAbsent(key, value, ttlSeconds) {
+        this.cleanup(key);
+        if (this.values.has(key))
+            return Promise.resolve(false);
+        this.values.set(key, {
+            value,
+            expiresAt: ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined,
+        });
+        return Promise.resolve(true);
+    }
+    deleteIfValue(key, expectedValue) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing || typeof existing.value !== "string") {
+            return Promise.resolve(false);
+        }
+        if (existing.value !== expectedValue)
+            return Promise.resolve(false);
+        this.values.delete(key);
+        return Promise.resolve(true);
+    }
+    compareAndExpire(key, expectedValue, ttlSeconds) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing || typeof existing.value !== "string") {
+            return Promise.resolve(false);
+        }
+        if (existing.value !== expectedValue)
+            return Promise.resolve(false);
+        existing.expiresAt = Date.now() + ttlSeconds * 1000;
+        return Promise.resolve(true);
+    }
+    snapshot(key) {
+        this.cleanup(key);
+        const existing = this.values.get(key);
+        if (!existing)
+            return { kind: "missing" };
+        const ttlSeconds = existing.expiresAt
+            ? Math.max(Math.ceil((existing.expiresAt - Date.now()) / 1000), 1)
+            : undefined;
+        if (typeof existing.value === "string") {
+            return { kind: "string", value: existing.value, ttlSeconds };
+        }
+        if (Array.isArray(existing.value)) {
+            return { kind: "list", values: [...existing.value], ttlSeconds };
+        }
+        return {
+            kind: "hash",
+            values: Object.fromEntries(existing.value.entries()),
+            ttlSeconds,
+        };
+    }
+}
+class RedisClient {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "memory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new InMemoryRedisStore()
+        });
+        Object.defineProperty(this, "hashFallbackKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "pendingFallbackReplays", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "runtimeListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakMap()
+        });
+        Object.defineProperty(this, "redis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "connected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "finalizingRuntime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "reconnectTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "connectAttempt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    async connect() {
+        this.closed = false;
+        await this.tryConnectOnce();
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async close() {
+        this.closed = true;
+        this.clearReconnectTimer();
+        const runtime = this.redis;
+        if (!runtime)
+            return;
+        this.detachRuntimeListeners(runtime);
+        try {
+            await runtime.quit();
+        }
+        finally {
+            this.redis = null;
+            this.connected = false;
+        }
+    }
+    getReconnectDelayMs() {
+        const baseDelay = this.options.reconnectBaseDelayMs ?? 1_000;
+        const maxDelay = this.options.reconnectMaxDelayMs ?? 30_000;
+        return Math.min(baseDelay * (2 ** Math.max(this.reconnectAttempts - 1, 0)), maxDelay);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer === null)
+            return;
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+    }
+    scheduleReconnect() {
+        if (this.closed || this.connected || this.reconnectTimer !== null)
+            return;
+        const delayMs = this.getReconnectDelayMs();
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.tryConnectOnce();
+        }, delayMs);
+    }
+    async createRuntime() {
+        if (this.options.runtimeFactory) {
+            return await this.options.runtimeFactory(this.options.endpoint);
+        }
+        const module = await Promise.resolve().then(() => __importStar(require("ioredis")));
+        const RedisCtor = module.default;
+        return new RedisCtor(this.options.endpoint, {
+            lazyConnect: true,
+            maxRetriesPerRequest: 1,
+            retryStrategy: () => null,
+        });
+    }
+    attachRuntimeListeners(runtime) {
+        const listeners = {
+            close: () => {
+                this.handleDisconnect(runtime);
+            },
+            end: () => {
+                this.handleDisconnect(runtime);
+            },
+            error: (error) => {
+                this.handleDisconnect(runtime, error);
+            },
+            ready: () => {
+                if (runtime !== this.redis || this.finalizingRuntime)
+                    return;
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                this.clearReconnectTimer();
+            },
+        };
+        this.runtimeListeners.set(runtime, listeners);
+        runtime.on?.("close", listeners.close);
+        runtime.on?.("end", listeners.end);
+        runtime.on?.("error", listeners.error);
+        runtime.on?.("ready", listeners.ready);
+    }
+    detachRuntimeListeners(runtime) {
+        const listeners = this.runtimeListeners.get(runtime);
+        if (!listeners)
+            return;
+        runtime.off?.("close", listeners.close);
+        runtime.off?.("end", listeners.end);
+        runtime.off?.("error", listeners.error);
+        runtime.off?.("ready", listeners.ready);
+        this.runtimeListeners.delete(runtime);
+    }
+    async replaceRuntime(runtime) {
+        if (this.closed) {
+            await this.disposeFailedRuntime(runtime);
+            this.connected = false;
+            return;
+        }
+        const previous = this.redis;
+        if (previous === runtime)
+            return;
+        this.redis = runtime;
+        this.connected = false;
+        this.finalizingRuntime = true;
+        try {
+            await this.replayPendingFallbackMutations(runtime);
+            this.connected = true;
+            this.reconnectAttempts = 0;
+            this.clearReconnectTimer();
+        }
+        catch (error) {
+            this.finalizingRuntime = false;
+            this.handleDisconnect(runtime, error);
+            return;
+        }
+        this.finalizingRuntime = false;
+        if (!previous)
+            return;
+        this.detachRuntimeListeners(previous);
+        try {
+            await previous.quit();
+        }
+        catch {
+            // Ignore teardown errors for stale runtimes.
+        }
+    }
+    async disposeFailedRuntime(runtime) {
+        this.detachRuntimeListeners(runtime);
+        try {
+            await runtime.quit();
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+    handleDisconnect(runtime, error) {
+        if (this.closed)
+            return;
+        if (runtime && runtime !== this.redis)
+            return;
+        if (error) {
+            logger_js_1.logger.warn("Redis hot tier unavailable; using in-memory fallback", error);
+        }
+        if (runtime && this.redis === runtime) {
+            this.redis = null;
+            this.detachRuntimeListeners(runtime);
+            void runtime.quit().catch(() => {
+                // Ignore teardown errors for disconnected runtimes.
+            });
+        }
+        this.connected = false;
+        this.scheduleReconnect();
+    }
+    async tryConnectOnce() {
+        if (this.closed)
+            return false;
+        if (this.connected && this.redis)
+            return true;
+        if (this.connectAttempt)
+            return await this.connectAttempt;
+        this.connectAttempt = (async () => {
+            let runtime = null;
+            try {
+                runtime = await this.createRuntime();
+                this.attachRuntimeListeners(runtime);
+                await runtime.connect?.();
+                await runtime.ping();
+                await this.replaceRuntime(runtime);
+                return true;
+            }
+            catch (error) {
+                if (runtime) {
+                    await this.disposeFailedRuntime(runtime);
+                }
+                this.redis = null;
+                this.connected = false;
+                this.reconnectAttempts += 1;
+                logger_js_1.logger.warn("Redis hot tier unavailable; using in-memory fallback", error);
+                this.scheduleReconnect();
+                return false;
+            }
+            finally {
+                this.connectAttempt = null;
+            }
+        })();
+        return await this.connectAttempt;
+    }
+    async useRuntime(operation, options) {
+        const runtime = this.redis;
+        if (this.connected && runtime) {
+            try {
+                return await operation(runtime);
+            }
+            catch (error) {
+                this.handleDisconnect(runtime, error);
+                if (options?.allowMemoryFallback === false)
+                    throw error;
+            }
+        }
+        if (options?.allowMemoryFallback === false) {
+            throw new Error("Redis hot tier unavailable for durable drain-state mutation");
+        }
+        return await operation(this.memory);
+    }
+    queuePendingFallbackReplay(replay) {
+        this.pendingFallbackReplays.push(replay);
+    }
+    async replayPendingFallbackMutations(runtime) {
+        while (this.pendingFallbackReplays.length > 0) {
+            const replay = this.pendingFallbackReplays[0];
+            await replay(runtime);
+            this.pendingFallbackReplays.shift();
+        }
+    }
+    queuePendingStringSnapshotReplay(key) {
+        this.queuePendingFallbackReplay(async (runtime) => {
+            this.hashFallbackKeys.delete(key);
+            const snapshot = this.memory.snapshot(key);
+            await runtime.del(key);
+            if (snapshot.kind === "missing")
+                return;
+            if (snapshot.kind !== "string")
+                return;
+            if (snapshot.ttlSeconds) {
+                await runtime.set(key, snapshot.value, "EX", snapshot.ttlSeconds);
+                return;
+            }
+            await runtime.set(key, snapshot.value);
+        });
+    }
+    queuePendingHashSnapshotReplay(key) {
+        this.queuePendingFallbackReplay(async (runtime) => {
+            if (!runtime.hset)
+                return;
+            const snapshot = this.memory.snapshot(key);
+            if (snapshot.kind !== "hash")
+                return;
+            await runtime.del(key);
+            this.hashFallbackKeys.delete(key);
+            await runtime.hset(key, snapshot.values);
+            if (snapshot.ttlSeconds)
+                await runtime.expire(key, snapshot.ttlSeconds);
+        });
+    }
+    isDurableDrainKey(key) {
+        return key.startsWith("drain:");
+    }
+    async replaceMemoryList(key, values, ttlSeconds) {
+        await this.memory.del(key);
+        for (const value of values) {
+            await this.memory.rpush(key, value);
+        }
+        if (ttlSeconds && values.length > 0) {
+            await this.memory.expire(key, ttlSeconds);
+        }
+    }
+    async syncNonDurableSourceListAfterLiveMove(key, side) {
+        const snapshot = this.memory.snapshot(key);
+        if (snapshot.kind !== "list")
+            return;
+        const values = side === "LEFT"
+            ? snapshot.values.slice(1)
+            : snapshot.values.slice(0, -1);
+        await this.replaceMemoryList(key, values, snapshot.ttlSeconds);
+    }
+    async syncNonDurableDestinationListAfterLiveMove(key, side, value) {
+        if (side === "LEFT") {
+            await this.memory.lpush(key, value);
+            return;
+        }
+        await this.memory.rpush(key, value);
+    }
+    async useMutationRuntime(keys, operation, onFallbackSuccess) {
+        return await this.useRuntime(async (runtime) => {
+            const result = await operation(runtime);
+            if (runtime === this.memory) {
+                await onFallbackSuccess?.(result);
+            }
+            return result;
+        }, {
+            allowMemoryFallback: !keys.some((key) => this.isDurableDrainKey(key)),
+        });
+    }
+    async prependToList(key, value, ttlSeconds) {
+        return await this.useMutationRuntime([key], async (runtime) => {
+            const length = await runtime.lpush(key, value);
+            if (ttlSeconds)
+                await runtime.expire(key, ttlSeconds);
+            if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                await this.memory.lpush(key, value);
+                if (ttlSeconds)
+                    await this.memory.expire(key, ttlSeconds);
+            }
+            return length;
+        }, () => {
+            this.queuePendingFallbackReplay(async (runtime) => {
+                await runtime.lpush(key, value);
+                if (ttlSeconds)
+                    await runtime.expire(key, ttlSeconds);
+            });
+        });
+    }
+    async appendToList(key, value, ttlSeconds) {
+        return await this.useMutationRuntime([key], async (runtime) => {
+            const length = await runtime.rpush(key, value);
+            if (ttlSeconds)
+                await runtime.expire(key, ttlSeconds);
+            if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                await this.memory.rpush(key, value);
+                if (ttlSeconds)
+                    await this.memory.expire(key, ttlSeconds);
+            }
+            return length;
+        }, () => {
+            this.queuePendingFallbackReplay(async (runtime) => {
+                await runtime.rpush(key, value);
+                if (ttlSeconds)
+                    await runtime.expire(key, ttlSeconds);
+            });
+        });
+    }
+    async getRecentList(key, limit) {
+        return await this.useRuntime((runtime) => runtime.lrange(key, 0, Math.max(limit - 1, 0)));
+    }
+    async getOldestList(key, limit) {
+        return await this.useRuntime(async (runtime) => {
+            const length = await runtime.llen(key);
+            if (length === 0)
+                return [];
+            const start = Math.max(length - limit, 0);
+            return await runtime.lrange(key, start, length - 1);
+        });
+    }
+    async getListRange(key, start, stop) {
+        return await this.useRuntime((runtime) => runtime.lrange(key, start, stop));
+    }
+    async getListItem(key, index) {
+        return await this.useRuntime((runtime) => runtime.lindex(key, index));
+    }
+    async setListItem(key, index, value) {
+        await this.useMutationRuntime([key], async (runtime) => {
+            await runtime.lset(key, index, value);
+            if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                await this.memory.lset(key, index, value);
+            }
+        }, () => {
+            this.queuePendingFallbackReplay(async (runtime) => {
+                await runtime.lset(key, index, value);
+            });
+        });
+    }
+    async getListLength(key) {
+        return await this.useRuntime((runtime) => runtime.llen(key));
+    }
+    async moveListItem(source, destination, sourceSide, destinationSide) {
+        return await this.useMutationRuntime([source, destination], async (runtime) => {
+            const sourceDurable = this.isDurableDrainKey(source);
+            const destinationDurable = this.isDurableDrainKey(destination);
+            const result = await runtime.lmove(source, destination, sourceSide, destinationSide);
+            if (result !== null && runtime !== this.memory) {
+                if (!sourceDurable) {
+                    await this.syncNonDurableSourceListAfterLiveMove(source, sourceSide);
+                }
+                if (!destinationDurable) {
+                    await this.syncNonDurableDestinationListAfterLiveMove(destination, destinationSide, result);
+                }
+            }
+            return result;
+        }, (result) => {
+            if (result === null)
+                return;
+            this.queuePendingFallbackReplay(async (runtime) => {
+                await runtime.lmove(source, destination, sourceSide, destinationSide);
+            });
+        });
+    }
+    async trimOldest(key, count) {
+        if (count <= 0)
+            return;
+        await this.useMutationRuntime([key], async (runtime) => {
+            const length = await runtime.llen(key);
+            if (length <= count) {
+                await runtime.del(key);
+                if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                    await this.memory.del(key);
+                }
+                return length > 0;
+            }
+            await runtime.ltrim(key, 0, length - count - 1);
+            if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                const memoryLength = await this.memory.llen(key);
+                if (memoryLength <= count) {
+                    await this.memory.del(key);
+                }
+                else {
+                    await this.memory.ltrim(key, 0, memoryLength - count - 1);
+                }
+            }
+            return true;
+        }, (changed) => {
+            if (!changed)
+                return;
+            this.queuePendingFallbackReplay(async (runtime) => {
+                const length = await runtime.llen(key);
+                if (length <= count) {
+                    await runtime.del(key);
+                    return;
+                }
+                await runtime.ltrim(key, 0, length - count - 1);
+            });
+        });
+    }
+    async getString(key) {
+        return await this.useRuntime((runtime) => runtime.get(key));
+    }
+    async setString(key, value, ttlSeconds) {
+        await this.useMutationRuntime([key], async (runtime) => {
+            if (ttlSeconds) {
+                await runtime.set(key, value, "EX", ttlSeconds);
+                if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                    this.hashFallbackKeys.delete(key);
+                    await this.memory.set(key, value, "EX", ttlSeconds);
+                }
+                return;
+            }
+            await runtime.set(key, value);
+            if (runtime !== this.memory && !this.isDurableDrainKey(key)) {
+                this.hashFallbackKeys.delete(key);
+                await this.memory.set(key, value);
+            }
+        }, () => {
+            this.queuePendingStringSnapshotReplay(key);
+        });
+    }
+    async setStringIfAbsent(key, value, ttlSeconds) {
+        return await this.useMutationRuntime([key], async (runtime) => {
+            if (runtime === this.memory) {
+                return await this.memory.setIfAbsent(key, value, ttlSeconds);
+            }
+            const result = ttlSeconds
+                ? await runtime.set(key, value, "NX", "EX", ttlSeconds)
+                : await runtime.set(key, value, "NX");
+            if (result === "OK" && !this.isDurableDrainKey(key)) {
+                this.hashFallbackKeys.delete(key);
+                if (ttlSeconds) {
+                    await this.memory.set(key, value, "EX", ttlSeconds);
+                }
+                else {
+                    await this.memory.set(key, value);
+                }
+            }
+            return result === "OK";
+        }, (acquired) => {
+            if (!acquired)
+                return;
+            this.queuePendingStringSnapshotReplay(key);
+        });
+    }
+    async touch(key, ttlSeconds) {
+        await this.useMutationRuntime([key], async (runtime) => {
+            const changed = await runtime.expire(key, ttlSeconds);
+            if (changed !== 0 && runtime !== this.memory &&
+                !this.isDurableDrainKey(key)) {
+                await this.memory.expire(key, ttlSeconds);
+            }
+            return changed;
+        }, (changed) => {
+            if (changed === 0)
+                return;
+            this.queuePendingFallbackReplay((runtime) => runtime.expire(key, ttlSeconds).then(() => undefined));
+        });
+    }
+    async getHashAll(key) {
+        return await this.useRuntime(async (runtime) => {
+            if (runtime === this.memory) {
+                return await this.memory.hgetall(key);
+            }
+            if (this.hashFallbackKeys.has(key)) {
+                const fallbackValues = await this.memory.hgetall(key);
+                if (!runtime.hgetall) {
+                    return fallbackValues;
+                }
+                const liveValues = await runtime.hgetall(key);
+                return {
+                    ...liveValues,
+                    ...fallbackValues,
+                };
+            }
+            return await runtime.hgetall?.(key) ?? {};
+        });
+    }
+    async setHashFields(key, values, ttlSeconds) {
+        const serialized = Object.fromEntries(Object.entries(values)
+            .filter(([, value]) => value !== undefined)
+            .map(([field, value]) => [field, String(value)]));
+        if (Object.keys(serialized).length === 0)
+            return;
+        await this.useMutationRuntime([key], async (runtime) => {
+            let ttlTarget = runtime;
+            if (runtime === this.memory) {
+                this.hashFallbackKeys.add(key);
+                await this.memory.hset(key, serialized);
+                ttlTarget = this.memory;
+            }
+            else if (runtime.hset) {
+                this.hashFallbackKeys.delete(key);
+                await runtime.hset(key, serialized);
+                if (!this.isDurableDrainKey(key)) {
+                    await this.memory.hset(key, serialized);
+                    if (ttlSeconds)
+                        await this.memory.expire(key, ttlSeconds);
+                }
+            }
+            else {
+                const existing = await runtime.get(key);
+                if (existing !== null) {
+                    throw new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
+                }
+                this.hashFallbackKeys.add(key);
+                await this.memory.hset(key, serialized);
+                ttlTarget = this.memory;
+            }
+            if (ttlSeconds)
+                await ttlTarget.expire(key, ttlSeconds);
+        }, () => {
+            this.queuePendingHashSnapshotReplay(key);
+        });
+    }
+    async compareAndTouch(key, expectedValue, ttlSeconds) {
+        return await this.useMutationRuntime([key], async (runtime) => {
+            if (runtime === this.memory) {
+                return await this.memory.compareAndExpire(key, expectedValue, ttlSeconds);
+            }
+            const extended = await runtime.eval?.("if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('EXPIRE', KEYS[1], ARGV[2]) else return 0 end", 1, key, expectedValue, String(ttlSeconds)) ?? 0;
+            return extended === 1;
+        }, (extended) => {
+            if (!extended)
+                return;
+            this.queuePendingFallbackReplay(async (runtime) => {
+                await runtime.eval?.("if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('EXPIRE', KEYS[1], ARGV[2]) else return 0 end", 1, key, expectedValue, String(ttlSeconds));
+            });
+        });
+    }
+    async deleteKey(key) {
+        await this.useMutationRuntime([key], async (runtime) => {
+            const deleted = await runtime.del(key);
+            if (deleted !== 0 && runtime !== this.memory &&
+                !this.isDurableDrainKey(key)) {
+                this.hashFallbackKeys.delete(key);
+                await this.memory.del(key);
+            }
+            return deleted;
+        }, (deleted) => {
+            if (deleted === 0)
+                return;
+            this.queuePendingFallbackReplay(async (runtime) => {
+                this.hashFallbackKeys.delete(key);
+                await runtime.del(key);
+            });
+        });
+    }
+    async deleteKeyIfValue(key, expectedValue) {
+        return await this.useMutationRuntime([key], async (runtime) => {
+            if (runtime === this.memory) {
+                return await this.memory.deleteIfValue(key, expectedValue);
+            }
+            const deleted = await runtime.eval?.("if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end", 1, key, expectedValue) ?? 0;
+            if (deleted === 1 && !this.isDurableDrainKey(key)) {
+                this.hashFallbackKeys.delete(key);
+                await this.memory.del(key);
+            }
+            return deleted === 1;
+        }, (deleted) => {
+            if (!deleted)
+                return;
+            this.queuePendingFallbackReplay(async (runtime) => {
+                this.hashFallbackKeys.delete(key);
+                await runtime.del(key);
+            });
+        });
+    }
+}
+exports.RedisClient = RedisClient;