@langchain/langgraph-checkpoint-redis 0.0.2 → 1.0.0

package/dist/index.cjs

@@ -1,703 +1,529 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisSaver = void 0;
-const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
-const redis_1 = require("redis");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __langchain_langgraph_checkpoint = require_rolldown_runtime.__toESM(require("@langchain/langgraph-checkpoint"));
+const redis = require_rolldown_runtime.__toESM(require("redis"));
+
+//#region src/index.ts
 const SCHEMAS = [
-    {
-        index: "checkpoints",
-        prefix: "checkpoint:",
-        schema: {
-            "$.thread_id": { type: "TAG", AS: "thread_id" },
-            "$.checkpoint_ns": { type: "TAG", AS: "checkpoint_ns" },
-            "$.checkpoint_id": { type: "TAG", AS: "checkpoint_id" },
-            "$.parent_checkpoint_id": { type: "TAG", AS: "parent_checkpoint_id" },
-            "$.checkpoint_ts": { type: "NUMERIC", AS: "checkpoint_ts" },
-            "$.has_writes": { type: "TAG", AS: "has_writes" },
-            "$.source": { type: "TAG", AS: "source" },
-            "$.step": { type: "NUMERIC", AS: "step" },
-        },
-    },
-    {
-        index: "checkpoint_blobs",
-        prefix: "checkpoint_blob:",
-        schema: {
-            "$.thread_id": { type: "TAG", AS: "thread_id" },
-            "$.checkpoint_ns": { type: "TAG", AS: "checkpoint_ns" },
-            "$.checkpoint_id": { type: "TAG", AS: "checkpoint_id" },
-            "$.channel": { type: "TAG", AS: "channel" },
-            "$.version": { type: "TAG", AS: "version" },
-            "$.type": { type: "TAG", AS: "type" },
-        },
-    },
-    {
-        index: "checkpoint_writes",
-        prefix: "checkpoint_write:",
-        schema: {
-            "$.thread_id": { type: "TAG", AS: "thread_id" },
-            "$.checkpoint_ns": { type: "TAG", AS: "checkpoint_ns" },
-            "$.checkpoint_id": { type: "TAG", AS: "checkpoint_id" },
-            "$.task_id": { type: "TAG", AS: "task_id" },
-            "$.idx": { type: "NUMERIC", AS: "idx" },
-            "$.channel": { type: "TAG", AS: "channel" },
-            "$.type": { type: "TAG", AS: "type" },
-        },
-    },
+	{
+		index: "checkpoints",
+		prefix: "checkpoint:",
+		schema: {
+			"$.thread_id": {
+				type: "TAG",
+				AS: "thread_id"
+			},
+			"$.checkpoint_ns": {
+				type: "TAG",
+				AS: "checkpoint_ns"
+			},
+			"$.checkpoint_id": {
+				type: "TAG",
+				AS: "checkpoint_id"
+			},
+			"$.parent_checkpoint_id": {
+				type: "TAG",
+				AS: "parent_checkpoint_id"
+			},
+			"$.checkpoint_ts": {
+				type: "NUMERIC",
+				AS: "checkpoint_ts"
+			},
+			"$.has_writes": {
+				type: "TAG",
+				AS: "has_writes"
+			},
+			"$.source": {
+				type: "TAG",
+				AS: "source"
+			},
+			"$.step": {
+				type: "NUMERIC",
+				AS: "step"
+			}
+		}
+	},
+	{
+		index: "checkpoint_blobs",
+		prefix: "checkpoint_blob:",
+		schema: {
+			"$.thread_id": {
+				type: "TAG",
+				AS: "thread_id"
+			},
+			"$.checkpoint_ns": {
+				type: "TAG",
+				AS: "checkpoint_ns"
+			},
+			"$.checkpoint_id": {
+				type: "TAG",
+				AS: "checkpoint_id"
+			},
+			"$.channel": {
+				type: "TAG",
+				AS: "channel"
+			},
+			"$.version": {
+				type: "TAG",
+				AS: "version"
+			},
+			"$.type": {
+				type: "TAG",
+				AS: "type"
+			}
+		}
+	},
+	{
+		index: "checkpoint_writes",
+		prefix: "checkpoint_write:",
+		schema: {
+			"$.thread_id": {
+				type: "TAG",
+				AS: "thread_id"
+			},
+			"$.checkpoint_ns": {
+				type: "TAG",
+				AS: "checkpoint_ns"
+			},
+			"$.checkpoint_id": {
+				type: "TAG",
+				AS: "checkpoint_id"
+			},
+			"$.task_id": {
+				type: "TAG",
+				AS: "task_id"
+			},
+			"$.idx": {
+				type: "NUMERIC",
+				AS: "idx"
+			},
+			"$.channel": {
+				type: "TAG",
+				AS: "channel"
+			},
+			"$.type": {
+				type: "TAG",
+				AS: "type"
+			}
+		}
+	}
 ];
-class RedisSaver extends langgraph_checkpoint_1.BaseCheckpointSaver {
-    client;
-    ttlConfig;
-    constructor(client, ttlConfig) {
-        super();
-        this.client = client;
-        this.ttlConfig = ttlConfig;
-    }
-    static async fromUrl(url, ttlConfig) {
-        const client = (0, redis_1.createClient)({ url });
-        await client.connect();
-        const saver = new RedisSaver(client, ttlConfig);
-        await saver.ensureIndexes();
-        return saver;
-    }
-    static async fromCluster(rootNodes, ttlConfig) {
-        const client = (0, redis_1.createCluster)({ rootNodes });
-        await client.connect();
-        const saver = new RedisSaver(client, ttlConfig);
-        await saver.ensureIndexes();
-        return saver;
-    }
-    async get(config) {
-        const tuple = await this.getTuple(config);
-        return tuple?.checkpoint;
-    }
-    async getTuple(config) {
-        const threadId = config.configurable?.thread_id;
-        const checkpointNs = config.configurable?.checkpoint_ns ?? "";
-        const checkpointId = config.configurable?.checkpoint_id;
-        if (!threadId) {
-            return undefined;
-        }
-        let key;
-        let jsonDoc;
-        if (checkpointId) {
-            // Get specific checkpoint
-            key = `checkpoint:${threadId}:${checkpointNs}:${checkpointId}`;
-            jsonDoc = (await this.client.json.get(key));
-        }
-        else {
-            // Get latest checkpoint - need to search
-            const pattern = `checkpoint:${threadId}:${checkpointNs}:*`;
-            // Use keys for simplicity - scan would be better for large datasets
-            const keys = await this.client.keys(pattern);
-            if (keys.length === 0) {
-                return undefined;
-            }
-            // Sort by key to get latest
-            keys.sort();
-            key = keys[keys.length - 1];
-            jsonDoc = (await this.client.json.get(key));
-        }
-        if (!jsonDoc) {
-            return undefined;
-        }
-        // Refresh TTL if configured
-        if (this.ttlConfig?.refreshOnRead && this.ttlConfig?.defaultTTL) {
-            await this.applyTTL(key);
-        }
-        // Load checkpoint with pending writes
-        const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
-        return this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
-    }
-    async put(config, checkpoint, metadata, newVersions) {
-        await this.ensureIndexes();
-        const threadId = config.configurable?.thread_id;
-        const checkpointNs = config.configurable?.checkpoint_ns ?? "";
-        const parentCheckpointId = config.configurable?.checkpoint_id;
-        if (!threadId) {
-            throw new Error("thread_id is required");
-        }
-        const checkpointId = checkpoint.id || (0, langgraph_checkpoint_1.uuid6)(0);
-        const key = `checkpoint:${threadId}:${checkpointNs}:${checkpointId}`;
-        // Copy checkpoint and filter channel_values to only include changed channels
-        const storedCheckpoint = (0, langgraph_checkpoint_1.copyCheckpoint)(checkpoint);
-        // If newVersions is provided and has keys, only store those channels that changed
-        // If newVersions is empty {}, store no channel values
-        // If newVersions is not provided (undefined), keep all channel_values as-is
-        if (storedCheckpoint.channel_values && newVersions !== undefined) {
-            if (Object.keys(newVersions).length === 0) {
-                // Empty newVersions means no channels changed - store empty channel_values
-                storedCheckpoint.channel_values = {};
-            }
-            else {
-                // Only store the channels that are in newVersions
-                const filteredChannelValues = {};
-                for (const channel of Object.keys(newVersions)) {
-                    if (channel in storedCheckpoint.channel_values) {
-                        filteredChannelValues[channel] =
-                            storedCheckpoint.channel_values[channel];
-                    }
-                }
-                storedCheckpoint.channel_values = filteredChannelValues;
-            }
-        }
-        // If newVersions is undefined, keep all channel_values as-is (for backward compatibility)
-        // Structure matching Python implementation
-        const jsonDoc = {
-            thread_id: threadId,
-            // Store empty namespace as "__empty__" for RediSearch compatibility
-            checkpoint_ns: checkpointNs === "" ? "__empty__" : checkpointNs,
-            checkpoint_id: checkpointId,
-            parent_checkpoint_id: parentCheckpointId || null,
-            checkpoint: storedCheckpoint,
-            metadata: metadata,
-            checkpoint_ts: Date.now(),
-            has_writes: "false",
-        };
-        // Store metadata fields at top-level for searching
-        this.addSearchableMetadataFields(jsonDoc, metadata);
-        // Use Redis JSON commands
-        await this.client.json.set(key, "$", jsonDoc);
-        // Apply TTL if configured
-        if (this.ttlConfig?.defaultTTL) {
-            await this.applyTTL(key);
-        }
-        return {
-            configurable: {
-                thread_id: threadId,
-                checkpoint_ns: checkpointNs,
-                checkpoint_id: checkpointId,
-            },
-        };
-    }
-    async *list(config, options) {
-        await this.ensureIndexes();
-        // If filter is provided (even if empty), use search functionality
-        if (options?.filter !== undefined) {
-            // Check if we have null values in the filter which RediSearch can't handle
-            const hasNullFilter = Object.values(options.filter).some((v) => v === null);
-            // Build search query
-            const queryParts = [];
-            // Add thread_id constraint if provided
-            if (config?.configurable?.thread_id) {
-                const threadId = config.configurable.thread_id.replace(/[-.@]/g, "\\$&");
-                queryParts.push(`(@thread_id:{${threadId}})`);
-            }
-            // Add checkpoint_ns constraint if provided
-            if (config?.configurable?.checkpoint_ns !== undefined) {
-                const checkpointNs = config.configurable.checkpoint_ns;
-                if (checkpointNs === "") {
-                    // Empty string needs special handling in RediSearch
-                    // We'll store it as "__empty__" in the index
-                    queryParts.push(`(@checkpoint_ns:{__empty__})`);
-                }
-                else {
-                    const escapedNs = checkpointNs.replace(/[-.@]/g, "\\$&");
-                    queryParts.push(`(@checkpoint_ns:{${escapedNs}})`);
-                }
-            }
-            // Skip metadata filters in search query when 'before' parameter is used
-            // We'll apply them after the before filtering to get correct results
-            if (!options?.before && options?.filter) {
-                // Add metadata filters (but skip null values)
-                for (const [key, value] of Object.entries(options.filter)) {
-                    if (value === undefined) {
-                        // Skip undefined filters
-                    }
-                    else if (value === null) {
-                        // Skip null values for RediSearch query, will handle in post-processing
-                    }
-                    else if (typeof value === "string") {
-                        // Don't escape, just wrap in braces for exact match
-                        queryParts.push(`(@${key}:{${value}})`);
-                    }
-                    else if (typeof value === "number") {
-                        queryParts.push(`(@${key}:[${value} ${value}])`);
-                    }
-                    else if (typeof value === "object" &&
-                        Object.keys(value).length === 0) {
-                        // Skip empty objects
-                    }
-                }
-            }
-            if (queryParts.length === 0) {
-                queryParts.push("*");
-            }
-            const query = queryParts.join(" ");
-            const limit = options?.limit ?? 10;
-            try {
-                // Fetch more results than the limit to handle post-filtering for 'before'
-                // When no thread_id is specified but 'before' is used, we need to fetch all results
-                const fetchLimit = options?.before && !config?.configurable?.thread_id
-                    ? 1000 // Fetch many results for global search with 'before' filtering
-                    : options?.before
-                        ? limit * 10
-                        : limit;
-                const results = await this.client.ft.search("checkpoints", query, {
-                    LIMIT: { from: 0, size: fetchLimit },
-                    SORTBY: { BY: "checkpoint_ts", DIRECTION: "DESC" },
-                });
-                let documents = results.documents;
-                let yieldedCount = 0;
-                for (const doc of documents) {
-                    if (yieldedCount >= limit)
-                        break;
-                    // Handle 'before' parameter - filter based on checkpoint_id comparison
-                    // UUID6 IDs are time-sortable, so string comparison works for ordering
-                    if (options?.before?.configurable?.checkpoint_id) {
-                        const currentCheckpointId = doc.value.checkpoint_id;
-                        const beforeCheckpointId = options.before.configurable.checkpoint_id;
-                        // Skip checkpoints that are not before the specified checkpoint
-                        if (currentCheckpointId >= beforeCheckpointId) {
-                            continue;
-                        }
-                    }
-                    const jsonDoc = doc.value;
-                    // Apply metadata filters manually (either for null filters or when before parameter was used)
-                    let matches = true;
-                    if ((hasNullFilter || options?.before) && options?.filter) {
-                        for (const [filterKey, filterValue] of Object.entries(options.filter)) {
-                            if (filterValue === null) {
-                                // Check if the field exists and is null in metadata
-                                // This should only match explicit null, not missing fields
-                                const metadataValue = jsonDoc.metadata?.[filterKey];
-                                if (metadataValue !== null) {
-                                    matches = false;
-                                    break;
-                                }
-                            }
-                            else if (filterValue !== undefined) {
-                                // Check other metadata values
-                                const metadataValue = jsonDoc.metadata?.[filterKey];
-                                // For objects, do deep equality check with deterministic key ordering
-                                if (typeof filterValue === "object" && filterValue !== null) {
-                                    if (deterministicStringify(metadataValue) !==
-                                        deterministicStringify(filterValue)) {
-                                        matches = false;
-                                        break;
-                                    }
-                                }
-                                else if (metadataValue !== filterValue) {
-                                    matches = false;
-                                    break;
-                                }
-                            }
-                        }
-                        if (!matches)
-                            continue;
-                    }
-                    // Load checkpoint with pending writes and migrate sends
-                    const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
-                    yield this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
-                    yieldedCount++;
-                }
-                // Search succeeded, return without falling through
-                return;
-            }
-            catch (error) {
-                if (error.message?.includes("no such index")) {
-                    // Index doesn't exist yet, fall through to regular listing
-                }
-                else {
-                    throw error;
-                }
-            }
-            // If search failed due to missing index, fall through to regular listing
-            if (config?.configurable?.thread_id) {
-                // Fall back to regular listing with manual filtering when thread_id is specified
-                const threadId = config.configurable.thread_id;
-                const checkpointNs = config.configurable.checkpoint_ns ?? "";
-                const pattern = `checkpoint:${threadId}:${checkpointNs}:*`;
-                // Use scan for better performance and cluster compatibility
-                // Use keys for simplicity - scan would be better for large datasets
-                const keys = await this.client.keys(pattern);
-                keys.sort().reverse();
-                let filteredKeys = keys;
-                // Handle 'before' parameter
-                if (options?.before?.configurable?.checkpoint_id) {
-                    const beforeThreadId = options.before.configurable.thread_id || threadId;
-                    const beforeCheckpointNs = options.before.configurable.checkpoint_ns ?? checkpointNs;
-                    const beforeKey = `checkpoint:${beforeThreadId}:${beforeCheckpointNs}:${options.before.configurable.checkpoint_id}`;
-                    const beforeIndex = keys.indexOf(beforeKey);
-                    if (beforeIndex > 0) {
-                        // Return all items that come after the found index (i.e., before in time)
-                        filteredKeys = keys.slice(beforeIndex + 1);
-                    }
-                    else if (beforeIndex === 0) {
-                        // Nothing before the first item (most recent)
-                        filteredKeys = [];
-                    }
-                    // If not found, return all
-                }
-                const limit = options?.limit ?? 10;
-                const limitedKeys = filteredKeys.slice(0, limit);
-                for (const key of limitedKeys) {
-                    const jsonDoc = (await this.client.json.get(key));
-                    if (jsonDoc) {
-                        // Check if metadata matches filter
-                        let matches = true;
-                        for (const [filterKey, filterValue] of Object.entries(options.filter)) {
-                            const metadataValue = jsonDoc.metadata?.[filterKey];
-                            if (filterValue === null) {
-                                if (metadataValue !== null) {
-                                    matches = false;
-                                    break;
-                                }
-                            }
-                            else if (metadataValue !== filterValue) {
-                                matches = false;
-                                break;
-                            }
-                        }
-                        if (!matches)
-                            continue;
-                        // Load checkpoint with pending writes and migrate sends
-                        const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
-                        yield this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
-                    }
-                }
-            }
-            else {
-                // Fall back to global search when thread_id is undefined
-                // This is needed for validation tests that search globally with 'before' parameter
-                const globalPattern = config?.configurable?.checkpoint_ns !== undefined
-                    ? `checkpoint:*:${config.configurable.checkpoint_ns === ""
-                        ? "__empty__"
-                        : config.configurable.checkpoint_ns}:*`
-                    : "checkpoint:*";
-                const allKeys = await this.client.keys(globalPattern);
-                const allDocuments = [];
-                // Load all matching documents
-                for (const key of allKeys) {
-                    const jsonDoc = (await this.client.json.get(key));
-                    if (jsonDoc) {
-                        allDocuments.push({ key, doc: jsonDoc });
-                    }
-                }
-                // Sort by timestamp (descending) to match the search behavior
-                allDocuments.sort((a, b) => b.doc.checkpoint_ts - a.doc.checkpoint_ts);
-                let yieldedCount = 0;
-                const limit = options?.limit ?? 10;
-                for (const { doc: jsonDoc } of allDocuments) {
-                    if (yieldedCount >= limit)
-                        break;
-                    // Handle 'before' parameter - filter based on checkpoint_id comparison
-                    if (options?.before?.configurable?.checkpoint_id) {
-                        const currentCheckpointId = jsonDoc.checkpoint_id;
-                        const beforeCheckpointId = options.before.configurable.checkpoint_id;
-                        // Skip checkpoints that are not before the specified checkpoint
-                        if (currentCheckpointId >= beforeCheckpointId) {
-                            continue;
-                        }
-                    }
-                    // Apply metadata filters manually
-                    let matches = true;
-                    if (options?.filter) {
-                        for (const [filterKey, filterValue] of Object.entries(options.filter)) {
-                            if (filterValue === null) {
-                                // Check if the field exists and is null in metadata
-                                const metadataValue = jsonDoc.metadata?.[filterKey];
-                                if (metadataValue !== null) {
-                                    matches = false;
-                                    break;
-                                }
-                            }
-                            else if (filterValue !== undefined) {
-                                // Check other metadata values
-                                const metadataValue = jsonDoc.metadata?.[filterKey];
-                                // For objects, do deep equality check with deterministic key ordering
-                                if (typeof filterValue === "object" && filterValue !== null) {
-                                    if (deterministicStringify(metadataValue) !==
-                                        deterministicStringify(filterValue)) {
-                                        matches = false;
-                                        break;
-                                    }
-                                }
-                                else if (metadataValue !== filterValue) {
-                                    matches = false;
-                                    break;
-                                }
-                            }
-                        }
-                        if (!matches)
-                            continue;
-                    }
-                    // Load checkpoint with pending writes and migrate sends
-                    const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
-                    yield this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
-                    yieldedCount++;
-                }
-            }
-            return;
-        }
-        // Regular listing without filter - use search with empty filter instead
-        // This ensures consistent behavior between filter={} and filter=undefined
-        const searchOptions = {
-            ...options,
-            filter: {},
-        };
-        // Delegate to the search path
-        yield* this.list(config, searchOptions);
-        return;
-    }
-    async putWrites(config, writes, taskId) {
-        await this.ensureIndexes();
-        const threadId = config.configurable?.thread_id;
-        const checkpointNs = config.configurable?.checkpoint_ns ?? "";
-        const checkpointId = config.configurable?.checkpoint_id;
-        if (!threadId || !checkpointId) {
-            throw new Error("thread_id and checkpoint_id are required");
-        }
-        // Collect write keys for sorted set tracking
-        const writeKeys = [];
-        // Use high-resolution timestamp to ensure unique ordering across putWrites calls
-        const baseTimestamp = performance.now() * 1000; // Microsecond precision
-        // Store each write as a separate indexed JSON document
-        for (let idx = 0; idx < writes.length; idx++) {
-            const [channel, value] = writes[idx];
-            const writeKey = `checkpoint_write:${threadId}:${checkpointNs}:${checkpointId}:${taskId}:${idx}`;
-            writeKeys.push(writeKey);
-            const writeDoc = {
-                thread_id: threadId,
-                checkpoint_ns: checkpointNs,
-                checkpoint_id: checkpointId,
-                task_id: taskId,
-                idx: idx,
-                channel: channel,
-                type: typeof value === "object" ? "json" : "string",
-                value: value,
-                timestamp: baseTimestamp,
-                global_idx: baseTimestamp + idx, // Add microseconds for sub-millisecond ordering
-            };
-            await this.client.json.set(writeKey, "$", writeDoc);
-        }
-        // Register write keys in sorted set for efficient retrieval
-        if (writeKeys.length > 0) {
-            const zsetKey = `write_keys_zset:${threadId}:${checkpointNs}:${checkpointId}`;
-            // Use timestamp + idx for scoring to maintain correct order
-            const zaddArgs = {};
-            writeKeys.forEach((key, idx) => {
-                zaddArgs[key] = baseTimestamp + idx;
-            });
-            await this.client.zAdd(zsetKey, Object.entries(zaddArgs).map(([key, score]) => ({ score, value: key })));
-            // Apply TTL to write keys and zset if configured
-            if (this.ttlConfig?.defaultTTL) {
-                // Apply TTL to write keys and zset
-                await this.applyTTL(...writeKeys, zsetKey);
-            }
-        }
-        // Update checkpoint to indicate it has writes
-        const checkpointKey = `checkpoint:${threadId}:${checkpointNs}:${checkpointId}`;
-        const checkpointExists = await this.client.exists(checkpointKey);
-        if (checkpointExists) {
-            // Get the current document and update it
-            const currentDoc = (await this.client.json.get(checkpointKey));
-            if (currentDoc) {
-                currentDoc.has_writes = "true";
-                await this.client.json.set(checkpointKey, "$", currentDoc);
-            }
-        }
-    }
-    async deleteThread(threadId) {
-        // Delete checkpoints
-        const checkpointPattern = `checkpoint:${threadId}:*`;
-        // Use scan for better performance and cluster compatibility
-        // Use keys for simplicity - scan would be better for large datasets
-        const checkpointKeys = await this.client.keys(checkpointPattern);
-        if (checkpointKeys.length > 0) {
-            await this.client.del(checkpointKeys);
-        }
-        // Delete writes
-        const writesPattern = `writes:${threadId}:*`;
-        // Use scan for better performance and cluster compatibility
-        // Use keys for simplicity - scan would be better for large datasets
-        const writesKeys = await this.client.keys(writesPattern);
-        if (writesKeys.length > 0) {
-            await this.client.del(writesKeys);
-        }
-    }
-    async end() {
-        await this.client.quit();
-    }
-    // Helper method to load channel blobs (simplified - no blob support for now)
-    // private async loadChannelBlobs(
-    //   checkpoint: Checkpoint & { channel_blobs?: any }
-    // ): Promise<Checkpoint> {
-    //   // Since we're not using blobs anymore, just return the checkpoint as-is
-    //   return checkpoint;
-    // }
-    // Helper method to load pending writes
-    async loadPendingWrites(threadId, checkpointNs, checkpointId) {
-        // Search for all write documents for this checkpoint
-        const pattern = `checkpoint_write:${threadId}:${checkpointNs}:${checkpointId}:*`;
-        const writeKeys = await this.client.keys(pattern);
-        if (writeKeys.length === 0) {
-            return undefined;
-        }
-        const writeDocuments = [];
-        for (const writeKey of writeKeys) {
-            const writeDoc = (await this.client.json.get(writeKey));
-            if (writeDoc) {
-                writeDocuments.push(writeDoc);
-            }
-        }
-        // Sort by global_idx (which represents insertion order across all putWrites calls)
-        // This matches how SQLite would naturally order by insertion time + idx
-        writeDocuments.sort((a, b) => (a.global_idx || 0) - (b.global_idx || 0));
-        const pendingWrites = [];
-        for (const writeDoc of writeDocuments) {
-            pendingWrites.push([writeDoc.task_id, writeDoc.channel, writeDoc.value]);
-        }
-        return pendingWrites;
-    }
-    // Helper method to load checkpoint with pending writes
-    async loadCheckpointWithWrites(jsonDoc) {
-        // Load checkpoint directly from JSON
-        const checkpoint = { ...jsonDoc.checkpoint };
-        // Migrate pending sends ONLY for OLD checkpoint versions (v < 4) with parents
-        // Modern checkpoints (v >= 4) should NEVER have pending sends migrated
-        if (checkpoint.v < 4 && jsonDoc.parent_checkpoint_id != null) {
-            // Convert back from "__empty__" to empty string for migration
-            const actualNs = jsonDoc.checkpoint_ns === "__empty__" ? "" : jsonDoc.checkpoint_ns;
-            await this.migratePendingSends(checkpoint, jsonDoc.thread_id, actualNs, jsonDoc.parent_checkpoint_id);
-        }
-        // Load this checkpoint's own pending writes (but don't migrate them)
-        let pendingWrites;
-        if (jsonDoc.has_writes === "true") {
-            // Convert back from "__empty__" to empty string for key lookup
-            const actualNs = jsonDoc.checkpoint_ns === "__empty__" ? "" : jsonDoc.checkpoint_ns;
-            pendingWrites = await this.loadPendingWrites(jsonDoc.thread_id, actualNs, jsonDoc.checkpoint_id);
-        }
-        return { checkpoint, pendingWrites };
-    }
-    // Migrate pending sends from parent checkpoint (matches SQLite implementation)
-    async migratePendingSends(checkpoint, threadId, checkpointNs, parentCheckpointId) {
-        // Load pending writes from parent checkpoint that have TASKS channel
-        const parentWrites = await this.loadPendingWrites(threadId, checkpointNs, parentCheckpointId);
-        if (!parentWrites || parentWrites.length === 0) {
-            return;
-        }
-        // Filter for TASKS channel writes only
-        const taskWrites = parentWrites.filter(([, channel]) => channel === langgraph_checkpoint_1.TASKS);
-        if (taskWrites.length === 0) {
-            return;
-        }
-        // Collect all task values in order
-        const allTasks = [];
-        for (const [, , value] of taskWrites) {
-            allTasks.push(value);
-        }
-        // Add pending sends to checkpoint
-        checkpoint.channel_values ??= {};
-        checkpoint.channel_values[langgraph_checkpoint_1.TASKS] = allTasks;
-        // Add to versions (matches SQLite logic)
-        checkpoint.channel_versions[langgraph_checkpoint_1.TASKS] =
-            Object.keys(checkpoint.channel_versions).length > 0
-                ? (0, langgraph_checkpoint_1.maxChannelVersion)(...Object.values(checkpoint.channel_versions))
-                : 1;
-    }
-    // Helper method to create checkpoint tuple from json document
-    createCheckpointTuple(jsonDoc, checkpoint, pendingWrites) {
-        // Convert back from "__empty__" to empty string
-        const checkpointNs = jsonDoc.checkpoint_ns === "__empty__" ? "" : jsonDoc.checkpoint_ns;
-        return {
-            config: {
-                configurable: {
-                    thread_id: jsonDoc.thread_id,
-                    checkpoint_ns: checkpointNs,
-                    checkpoint_id: jsonDoc.checkpoint_id,
-                },
-            },
-            checkpoint,
-            metadata: jsonDoc.metadata,
-            parentConfig: jsonDoc.parent_checkpoint_id
-                ? {
-                    configurable: {
-                        thread_id: jsonDoc.thread_id,
-                        checkpoint_ns: checkpointNs,
-                        checkpoint_id: jsonDoc.parent_checkpoint_id,
-                    },
-                }
-                : undefined,
-            pendingWrites,
-        };
-    }
-    // Helper method to add searchable metadata fields
-    addSearchableMetadataFields(jsonDoc, metadata) {
-        if (!metadata)
-            return;
-        // Add common searchable fields at top level
-        if ("source" in metadata) {
-            jsonDoc.source = metadata.source;
-        }
-        if ("step" in metadata) {
-            jsonDoc.step = metadata.step;
-        }
-        if ("writes" in metadata) {
-            // Writes field needs to be JSON stringified for TAG search
-            jsonDoc.writes =
-                typeof metadata.writes === "object"
-                    ? JSON.stringify(metadata.writes)
-                    : metadata.writes;
-        }
-        if ("score" in metadata) {
-            jsonDoc.score = metadata.score;
-        }
-    }
-    // Helper method to apply TTL to keys
-    async applyTTL(...keys) {
-        if (!this.ttlConfig?.defaultTTL)
-            return;
-        const ttlSeconds = Math.floor(this.ttlConfig.defaultTTL * 60);
-        const results = await Promise.allSettled(keys.map((key) => this.client.expire(key, ttlSeconds)));
-        // Log any failures but don't throw - TTL is best effort
-        for (let i = 0; i < results.length; i++) {
-            if (results[i].status === "rejected") {
-                console.warn(`Failed to set TTL for key ${keys[i]}:`, results[i].reason);
-            }
-        }
-    }
-    async ensureIndexes() {
-        for (const schema of SCHEMAS) {
-            try {
-                // Try to create the index
-                await this.client.ft.create(schema.index, schema.schema, {
-                    ON: "JSON",
-                    PREFIX: schema.prefix,
-                });
-            }
-            catch (error) {
-                // Ignore if index already exists
-                if (!error.message?.includes("Index already exists")) {
-                    console.error(`Failed to create index ${schema.index}:`, error.message);
-                }
-            }
-        }
-    }
-}
-exports.RedisSaver = RedisSaver;
-// Helper function for deterministic object comparison
+var RedisSaver = class RedisSaver extends __langchain_langgraph_checkpoint.BaseCheckpointSaver {
+	client;
+	ttlConfig;
+	constructor(client, ttlConfig) {
+		super();
+		this.client = client;
+		this.ttlConfig = ttlConfig;
+	}
+	static async fromUrl(url, ttlConfig) {
+		const client = (0, redis.createClient)({ url });
+		await client.connect();
+		const saver = new RedisSaver(client, ttlConfig);
+		await saver.ensureIndexes();
+		return saver;
+	}
+	static async fromCluster(rootNodes, ttlConfig) {
+		const client = (0, redis.createCluster)({ rootNodes });
+		await client.connect();
+		const saver = new RedisSaver(client, ttlConfig);
+		await saver.ensureIndexes();
+		return saver;
+	}
+	async get(config) {
+		const tuple = await this.getTuple(config);
+		return tuple?.checkpoint;
+	}
+	async getTuple(config) {
+		const threadId = config.configurable?.thread_id;
+		const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+		const checkpointId = config.configurable?.checkpoint_id;
+		if (!threadId) return void 0;
+		let key;
+		let jsonDoc;
+		if (checkpointId) {
+			key = `checkpoint:${threadId}:${checkpointNs}:${checkpointId}`;
+			jsonDoc = await this.client.json.get(key);
+		} else {
+			const pattern = `checkpoint:${threadId}:${checkpointNs}:*`;
+			const keys = await this.client.keys(pattern);
+			if (keys.length === 0) return void 0;
+			keys.sort();
+			key = keys[keys.length - 1];
+			jsonDoc = await this.client.json.get(key);
+		}
+		if (!jsonDoc) return void 0;
+		if (this.ttlConfig?.refreshOnRead && this.ttlConfig?.defaultTTL) await this.applyTTL(key);
+		const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
+		return this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
+	}
+	async put(config, checkpoint, metadata, newVersions) {
+		await this.ensureIndexes();
+		const threadId = config.configurable?.thread_id;
+		const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+		const parentCheckpointId = config.configurable?.checkpoint_id;
+		if (!threadId) throw new Error("thread_id is required");
+		const checkpointId = checkpoint.id || (0, __langchain_langgraph_checkpoint.uuid6)(0);
+		const key = `checkpoint:${threadId}:${checkpointNs}:${checkpointId}`;
+		const storedCheckpoint = (0, __langchain_langgraph_checkpoint.copyCheckpoint)(checkpoint);
+		if (storedCheckpoint.channel_values && newVersions !== void 0) if (Object.keys(newVersions).length === 0) storedCheckpoint.channel_values = {};
+		else {
+			const filteredChannelValues = {};
+			for (const channel of Object.keys(newVersions)) if (channel in storedCheckpoint.channel_values) filteredChannelValues[channel] = storedCheckpoint.channel_values[channel];
+			storedCheckpoint.channel_values = filteredChannelValues;
+		}
+		const jsonDoc = {
+			thread_id: threadId,
+			checkpoint_ns: checkpointNs === "" ? "__empty__" : checkpointNs,
+			checkpoint_id: checkpointId,
+			parent_checkpoint_id: parentCheckpointId || null,
+			checkpoint: storedCheckpoint,
+			metadata,
+			checkpoint_ts: Date.now(),
+			has_writes: "false"
+		};
+		this.addSearchableMetadataFields(jsonDoc, metadata);
+		await this.client.json.set(key, "$", jsonDoc);
+		if (this.ttlConfig?.defaultTTL) await this.applyTTL(key);
+		return { configurable: {
+			thread_id: threadId,
+			checkpoint_ns: checkpointNs,
+			checkpoint_id: checkpointId
+		} };
+	}
+	async *list(config, options) {
+		await this.ensureIndexes();
+		if (options?.filter !== void 0) {
+			const hasNullFilter = Object.values(options.filter).some((v) => v === null);
+			const queryParts = [];
+			if (config?.configurable?.thread_id) {
+				const threadId = config.configurable.thread_id.replace(/[-.@]/g, "\\$&");
+				queryParts.push(`(@thread_id:{${threadId}})`);
+			}
+			if (config?.configurable?.checkpoint_ns !== void 0) {
+				const checkpointNs = config.configurable.checkpoint_ns;
+				if (checkpointNs === "") queryParts.push(`(@checkpoint_ns:{__empty__})`);
+				else {
+					const escapedNs = checkpointNs.replace(/[-.@]/g, "\\$&");
+					queryParts.push(`(@checkpoint_ns:{${escapedNs}})`);
+				}
+			}
+			if (!options?.before && options?.filter) {
+				for (const [key, value] of Object.entries(options.filter)) if (value === void 0) {} else if (value === null) {} else if (typeof value === "string") queryParts.push(`(@${key}:{${value}})`);
+				else if (typeof value === "number") queryParts.push(`(@${key}:[${value} ${value}])`);
+				else if (typeof value === "object" && Object.keys(value).length === 0) {}
+			}
+			if (queryParts.length === 0) queryParts.push("*");
+			const query = queryParts.join(" ");
+			const limit = options?.limit ?? 10;
+			try {
+				const fetchLimit = options?.before && !config?.configurable?.thread_id ? 1e3 : options?.before ? limit * 10 : limit;
+				const results = await this.client.ft.search("checkpoints", query, {
+					LIMIT: {
+						from: 0,
+						size: fetchLimit
+					},
+					SORTBY: {
+						BY: "checkpoint_ts",
+						DIRECTION: "DESC"
+					}
+				});
+				let documents = results.documents;
+				let yieldedCount = 0;
+				for (const doc of documents) {
+					if (yieldedCount >= limit) break;
+					if (options?.before?.configurable?.checkpoint_id) {
+						const currentCheckpointId = doc.value.checkpoint_id;
+						const beforeCheckpointId = options.before.configurable.checkpoint_id;
+						if (currentCheckpointId >= beforeCheckpointId) continue;
+					}
+					const jsonDoc = doc.value;
+					let matches = true;
+					if ((hasNullFilter || options?.before) && options?.filter) {
+						for (const [filterKey, filterValue] of Object.entries(options.filter)) if (filterValue === null) {
+							const metadataValue = jsonDoc.metadata?.[filterKey];
+							if (metadataValue !== null) {
+								matches = false;
+								break;
+							}
+						} else if (filterValue !== void 0) {
+							const metadataValue = jsonDoc.metadata?.[filterKey];
+							if (typeof filterValue === "object" && filterValue !== null) {
+								if (deterministicStringify(metadataValue) !== deterministicStringify(filterValue)) {
+									matches = false;
+									break;
+								}
+							} else if (metadataValue !== filterValue) {
+								matches = false;
+								break;
+							}
+						}
+						if (!matches) continue;
+					}
+					const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
+					yield this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
+					yieldedCount++;
+				}
+				return;
+			} catch (error) {
+				if (error.message?.includes("no such index")) {} else throw error;
+			}
+			if (config?.configurable?.thread_id) {
+				const threadId = config.configurable.thread_id;
+				const checkpointNs = config.configurable.checkpoint_ns ?? "";
+				const pattern = `checkpoint:${threadId}:${checkpointNs}:*`;
+				const keys = await this.client.keys(pattern);
+				keys.sort().reverse();
+				let filteredKeys = keys;
+				if (options?.before?.configurable?.checkpoint_id) {
+					const beforeThreadId = options.before.configurable.thread_id || threadId;
+					const beforeCheckpointNs = options.before.configurable.checkpoint_ns ?? checkpointNs;
+					const beforeKey = `checkpoint:${beforeThreadId}:${beforeCheckpointNs}:${options.before.configurable.checkpoint_id}`;
+					const beforeIndex = keys.indexOf(beforeKey);
+					if (beforeIndex > 0) filteredKeys = keys.slice(beforeIndex + 1);
+					else if (beforeIndex === 0) filteredKeys = [];
+				}
+				const limit$1 = options?.limit ?? 10;
+				const limitedKeys = filteredKeys.slice(0, limit$1);
+				for (const key of limitedKeys) {
+					const jsonDoc = await this.client.json.get(key);
+					if (jsonDoc) {
+						let matches = true;
+						for (const [filterKey, filterValue] of Object.entries(options.filter)) {
+							const metadataValue = jsonDoc.metadata?.[filterKey];
+							if (filterValue === null) {
+								if (metadataValue !== null) {
+									matches = false;
+									break;
+								}
+							} else if (metadataValue !== filterValue) {
+								matches = false;
+								break;
+							}
+						}
+						if (!matches) continue;
+						const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
+						yield this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
+					}
+				}
+			} else {
+				const globalPattern = config?.configurable?.checkpoint_ns !== void 0 ? `checkpoint:*:${config.configurable.checkpoint_ns === "" ? "__empty__" : config.configurable.checkpoint_ns}:*` : "checkpoint:*";
+				const allKeys = await this.client.keys(globalPattern);
+				const allDocuments = [];
+				for (const key of allKeys) {
+					const jsonDoc = await this.client.json.get(key);
+					if (jsonDoc) allDocuments.push({
+						key,
+						doc: jsonDoc
+					});
+				}
+				allDocuments.sort((a, b) => b.doc.checkpoint_ts - a.doc.checkpoint_ts);
+				let yieldedCount = 0;
+				const limit$1 = options?.limit ?? 10;
+				for (const { doc: jsonDoc } of allDocuments) {
+					if (yieldedCount >= limit$1) break;
+					if (options?.before?.configurable?.checkpoint_id) {
+						const currentCheckpointId = jsonDoc.checkpoint_id;
+						const beforeCheckpointId = options.before.configurable.checkpoint_id;
+						if (currentCheckpointId >= beforeCheckpointId) continue;
+					}
+					let matches = true;
+					if (options?.filter) {
+						for (const [filterKey, filterValue] of Object.entries(options.filter)) if (filterValue === null) {
+							const metadataValue = jsonDoc.metadata?.[filterKey];
+							if (metadataValue !== null) {
+								matches = false;
+								break;
+							}
+						} else if (filterValue !== void 0) {
+							const metadataValue = jsonDoc.metadata?.[filterKey];
+							if (typeof filterValue === "object" && filterValue !== null) {
+								if (deterministicStringify(metadataValue) !== deterministicStringify(filterValue)) {
+									matches = false;
+									break;
+								}
+							} else if (metadataValue !== filterValue) {
+								matches = false;
+								break;
+							}
+						}
+						if (!matches) continue;
+					}
+					const { checkpoint, pendingWrites } = await this.loadCheckpointWithWrites(jsonDoc);
+					yield this.createCheckpointTuple(jsonDoc, checkpoint, pendingWrites);
+					yieldedCount++;
+				}
+			}
+			return;
+		}
+		const searchOptions = {
+			...options,
+			filter: {}
+		};
+		yield* this.list(config, searchOptions);
+	}
+	async putWrites(config, writes, taskId) {
+		await this.ensureIndexes();
+		const threadId = config.configurable?.thread_id;
+		const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+		const checkpointId = config.configurable?.checkpoint_id;
+		if (!threadId || !checkpointId) throw new Error("thread_id and checkpoint_id are required");
+		const writeKeys = [];
+		const baseTimestamp = performance.now() * 1e3;
+		for (let idx = 0; idx < writes.length; idx++) {
+			const [channel, value] = writes[idx];
+			const writeKey = `checkpoint_write:${threadId}:${checkpointNs}:${checkpointId}:${taskId}:${idx}`;
+			writeKeys.push(writeKey);
+			const writeDoc = {
+				thread_id: threadId,
+				checkpoint_ns: checkpointNs,
+				checkpoint_id: checkpointId,
+				task_id: taskId,
+				idx,
+				channel,
+				type: typeof value === "object" ? "json" : "string",
+				value,
+				timestamp: baseTimestamp,
+				global_idx: baseTimestamp + idx
+			};
+			await this.client.json.set(writeKey, "$", writeDoc);
+		}
+		if (writeKeys.length > 0) {
+			const zsetKey = `write_keys_zset:${threadId}:${checkpointNs}:${checkpointId}`;
+			const zaddArgs = {};
+			writeKeys.forEach((key, idx) => {
+				zaddArgs[key] = baseTimestamp + idx;
+			});
+			await this.client.zAdd(zsetKey, Object.entries(zaddArgs).map(([key, score]) => ({
+				score,
+				value: key
+			})));
+			if (this.ttlConfig?.defaultTTL) await this.applyTTL(...writeKeys, zsetKey);
+		}
+		const checkpointKey = `checkpoint:${threadId}:${checkpointNs}:${checkpointId}`;
+		const checkpointExists = await this.client.exists(checkpointKey);
+		if (checkpointExists) {
+			const currentDoc = await this.client.json.get(checkpointKey);
+			if (currentDoc) {
+				currentDoc.has_writes = "true";
+				await this.client.json.set(checkpointKey, "$", currentDoc);
+			}
+		}
+	}
+	async deleteThread(threadId) {
+		const checkpointPattern = `checkpoint:${threadId}:*`;
+		const checkpointKeys = await this.client.keys(checkpointPattern);
+		if (checkpointKeys.length > 0) await this.client.del(checkpointKeys);
+		const writesPattern = `writes:${threadId}:*`;
+		const writesKeys = await this.client.keys(writesPattern);
+		if (writesKeys.length > 0) await this.client.del(writesKeys);
+	}
+	async end() {
+		await this.client.quit();
+	}
+	async loadPendingWrites(threadId, checkpointNs, checkpointId) {
+		const pattern = `checkpoint_write:${threadId}:${checkpointNs}:${checkpointId}:*`;
+		const writeKeys = await this.client.keys(pattern);
+		if (writeKeys.length === 0) return void 0;
+		const writeDocuments = [];
+		for (const writeKey of writeKeys) {
+			const writeDoc = await this.client.json.get(writeKey);
+			if (writeDoc) writeDocuments.push(writeDoc);
+		}
+		writeDocuments.sort((a, b) => (a.global_idx || 0) - (b.global_idx || 0));
+		const pendingWrites = [];
+		for (const writeDoc of writeDocuments) pendingWrites.push([
+			writeDoc.task_id,
+			writeDoc.channel,
+			writeDoc.value
+		]);
+		return pendingWrites;
+	}
+	async loadCheckpointWithWrites(jsonDoc) {
+		const checkpoint = { ...jsonDoc.checkpoint };
+		if (checkpoint.v < 4 && jsonDoc.parent_checkpoint_id != null) {
+			const actualNs = jsonDoc.checkpoint_ns === "__empty__" ? "" : jsonDoc.checkpoint_ns;
+			await this.migratePendingSends(checkpoint, jsonDoc.thread_id, actualNs, jsonDoc.parent_checkpoint_id);
+		}
+		let pendingWrites;
+		if (jsonDoc.has_writes === "true") {
+			const actualNs = jsonDoc.checkpoint_ns === "__empty__" ? "" : jsonDoc.checkpoint_ns;
+			pendingWrites = await this.loadPendingWrites(jsonDoc.thread_id, actualNs, jsonDoc.checkpoint_id);
+		}
+		return {
+			checkpoint,
+			pendingWrites
+		};
+	}
+	async migratePendingSends(checkpoint, threadId, checkpointNs, parentCheckpointId) {
+		const parentWrites = await this.loadPendingWrites(threadId, checkpointNs, parentCheckpointId);
+		if (!parentWrites || parentWrites.length === 0) return;
+		const taskWrites = parentWrites.filter(([, channel]) => channel === __langchain_langgraph_checkpoint.TASKS);
+		if (taskWrites.length === 0) return;
+		const allTasks = [];
+		for (const [, , value] of taskWrites) allTasks.push(value);
+		checkpoint.channel_values ??= {};
+		checkpoint.channel_values[__langchain_langgraph_checkpoint.TASKS] = allTasks;
+		checkpoint.channel_versions[__langchain_langgraph_checkpoint.TASKS] = Object.keys(checkpoint.channel_versions).length > 0 ? (0, __langchain_langgraph_checkpoint.maxChannelVersion)(...Object.values(checkpoint.channel_versions)) : 1;
+	}
+	createCheckpointTuple(jsonDoc, checkpoint, pendingWrites) {
+		const checkpointNs = jsonDoc.checkpoint_ns === "__empty__" ? "" : jsonDoc.checkpoint_ns;
+		return {
+			config: { configurable: {
+				thread_id: jsonDoc.thread_id,
+				checkpoint_ns: checkpointNs,
+				checkpoint_id: jsonDoc.checkpoint_id
+			} },
+			checkpoint,
+			metadata: jsonDoc.metadata,
+			parentConfig: jsonDoc.parent_checkpoint_id ? { configurable: {
+				thread_id: jsonDoc.thread_id,
+				checkpoint_ns: checkpointNs,
+				checkpoint_id: jsonDoc.parent_checkpoint_id
+			} } : void 0,
+			pendingWrites
+		};
+	}
+	addSearchableMetadataFields(jsonDoc, metadata) {
+		if (!metadata) return;
+		if ("source" in metadata) jsonDoc.source = metadata.source;
+		if ("step" in metadata) jsonDoc.step = metadata.step;
+		if ("writes" in metadata) jsonDoc.writes = typeof metadata.writes === "object" ? JSON.stringify(metadata.writes) : metadata.writes;
+		if ("score" in metadata) jsonDoc.score = metadata.score;
+	}
+	async applyTTL(...keys) {
+		if (!this.ttlConfig?.defaultTTL) return;
+		const ttlSeconds = Math.floor(this.ttlConfig.defaultTTL * 60);
+		const results = await Promise.allSettled(keys.map((key) => this.client.expire(key, ttlSeconds)));
+		for (let i = 0; i < results.length; i++) if (results[i].status === "rejected") console.warn(`Failed to set TTL for key ${keys[i]}:`, results[i].reason);
+	}
+	async ensureIndexes() {
+		for (const schema of SCHEMAS) try {
+			await this.client.ft.create(schema.index, schema.schema, {
+				ON: "JSON",
+				PREFIX: schema.prefix
+			});
+		} catch (error) {
+			if (!error.message?.includes("Index already exists")) console.error(`Failed to create index ${schema.index}:`, error.message);
+		}
+	}
+};
 function deterministicStringify(obj) {
-    if (obj === null || typeof obj !== "object") {
-        return JSON.stringify(obj);
-    }
-    if (Array.isArray(obj)) {
-        return JSON.stringify(obj.map((item) => deterministicStringify(item)));
-    }
-    const sortedObj = {};
-    const sortedKeys = Object.keys(obj).sort();
-    for (const key of sortedKeys) {
-        sortedObj[key] = obj[key];
-    }
-    return JSON.stringify(sortedObj, (_, value) => {
-        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-            const sorted = {};
-            const keys = Object.keys(value).sort();
-            for (const k of keys) {
-                sorted[k] = value[k];
-            }
-            return sorted;
-        }
-        return value;
-    });
+	if (obj === null || typeof obj !== "object") return JSON.stringify(obj);
+	if (Array.isArray(obj)) return JSON.stringify(obj.map((item) => deterministicStringify(item)));
+	const sortedObj = {};
+	const sortedKeys = Object.keys(obj).sort();
+	for (const key of sortedKeys) sortedObj[key] = obj[key];
+	return JSON.stringify(sortedObj, (_, value) => {
+		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+			const sorted = {};
+			const keys = Object.keys(value).sort();
+			for (const k of keys) sorted[k] = value[k];
+			return sorted;
+		}
+		return value;
+	});
 }
-//# sourceMappingURL=index.js.map
+
+//#endregion
+exports.RedisSaver = RedisSaver;
+//# sourceMappingURL=index.cjs.map