@byteplus-iga-pages/agent 0.0.0-stage → 1.0.3

package/dist/cjs/store/langgraph.js

@@ -0,0 +1,581 @@
+"use strict";
+(function() {
+    exports.ids = [
+        "120"
+    ];
+    exports.modules = {
+        "../store/src/langgraph.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                createCheckpointer: ()=>createCheckpointer,
+                IgaCheckpointSaver: ()=>IgaCheckpointSaver
+            });
+            var external_node_crypto_ = __webpack_require__("node:crypto");
+            const langgraph_checkpoint_namespaceObject = require("@langchain/langgraph-checkpoint");
+            var errors = __webpack_require__("../store/src/errors.ts");
+            var runtime_data_plane = __webpack_require__("../store/src/runtime-data-plane.ts");
+            const LANGGRAPH_RPC_NAMES = {
+                putCheckpoint: "langgraph_put_checkpoint",
+                getCheckpoint: "langgraph_get_checkpoint",
+                listCheckpoints: "langgraph_list_checkpoints",
+                putWrites: "langgraph_put_writes",
+                getDeltaHistory: "langgraph_get_delta_history",
+                deleteThread: "langgraph_delete_thread"
+            };
+            function rpcOperation(name, params) {
+                return (client)=>client.rpc(name, params);
+            }
+            class LangGraphCheckpointRepository {
+                async putCheckpoint(record) {
+                    const result = await this.execute({
+                        operationName: "store.langgraph.putCheckpoint",
+                        retryOnUnauthorized: true,
+                        retryOnNetworkError: true,
+                        operation: rpcOperation(LANGGRAPH_RPC_NAMES.putCheckpoint, {
+                            p_thread_id: record.threadId,
+                            p_checkpoint_ns: record.checkpointNamespace,
+                            p_checkpoint_id: record.checkpointId,
+                            p_parent_checkpoint_id: record.parentCheckpointId,
+                            p_checkpoint: record.checkpoint,
+                            p_metadata: record.metadata,
+                            p_blobs: record.blobs
+                        })
+                    });
+                    return result.data;
+                }
+                async getCheckpoint(input) {
+                    const result = await this.execute({
+                        operationName: "store.langgraph.getCheckpoint",
+                        retryOnUnauthorized: true,
+                        retryOnNetworkError: true,
+                        operation: rpcOperation(LANGGRAPH_RPC_NAMES.getCheckpoint, {
+                            p_thread_id: input.threadId,
+                            p_checkpoint_ns: input.checkpointNamespace,
+                            p_checkpoint_id: input.checkpointId
+                        })
+                    });
+                    return result.data;
+                }
+                async listCheckpoints(query) {
+                    const result = await this.execute({
+                        operationName: "store.langgraph.listCheckpoints",
+                        retryOnUnauthorized: true,
+                        retryOnNetworkError: true,
+                        operation: rpcOperation(LANGGRAPH_RPC_NAMES.listCheckpoints, {
+                            p_thread_id: query.threadId,
+                            p_checkpoint_ns: query.checkpointNamespace,
+                            p_checkpoint_id: query.checkpointId,
+                            p_metadata: query.metadata,
+                            p_before_checkpoint_id: query.beforeCheckpointId,
+                            p_limit: query.limit,
+                            p_result_format: "array"
+                        })
+                    });
+                    return result.data;
+                }
+                async putWrites(record) {
+                    const result = await this.execute({
+                        operationName: "store.langgraph.putWrites",
+                        retryOnUnauthorized: true,
+                        retryOnNetworkError: true,
+                        operation: rpcOperation(LANGGRAPH_RPC_NAMES.putWrites, {
+                            p_thread_id: record.threadId,
+                            p_checkpoint_ns: record.checkpointNamespace,
+                            p_checkpoint_id: record.checkpointId,
+                            p_task_id: record.taskId,
+                            p_writes: record.writes
+                        })
+                    });
+                    return result.data;
+                }
+                async getDeltaHistory(input) {
+                    const result = await this.execute({
+                        operationName: "store.langgraph.getDeltaHistory",
+                        retryOnUnauthorized: true,
+                        retryOnNetworkError: true,
+                        operation: rpcOperation(LANGGRAPH_RPC_NAMES.getDeltaHistory, {
+                            p_thread_id: input.threadId,
+                            p_checkpoint_ns: input.checkpointNamespace,
+                            p_checkpoint_id: input.checkpointId,
+                            p_channels: input.channels
+                        })
+                    });
+                    return result.data;
+                }
+                async deleteThread(threadId) {
+                    const result = await this.execute({
+                        operationName: "store.langgraph.deleteThread",
+                        retryOnUnauthorized: true,
+                        retryOnNetworkError: true,
+                        operation: rpcOperation(LANGGRAPH_RPC_NAMES.deleteThread, {
+                            p_thread_id: threadId
+                        })
+                    });
+                    return result.data;
+                }
+                constructor(execute = runtime_data_plane.G){
+                    this.execute = execute;
+                }
+            }
+            const langGraphCheckpointRepository = new LangGraphCheckpointRepository();
+            const VERSION_PREFIX_PATTERN = /^(\d+)(?:-|$)/;
+            const VERSION_WIDTH = 20;
+            function jsonObject(value, field) {
+                try {
+                    return requireRecord(JSON.parse(JSON.stringify(value)));
+                } catch  {
+                    invalid(`${field} must serialize to a JSON object`);
+                }
+            }
+            function invalid(message) {
+                throw new errors.A("BadRequest", message);
+            }
+            function internal() {
+                throw new errors.A("UnknownError", "Store returned invalid data");
+            }
+            function requireRecord(value) {
+                if (null === value || "object" != typeof value || Array.isArray(value)) internal();
+                return value;
+            }
+            function requireArray(value) {
+                if (!Array.isArray(value)) internal();
+                return value;
+            }
+            function requireString(value, allowEmpty = false) {
+                if ("string" != typeof value || !allowEmpty && 0 === value.length) internal();
+                return value;
+            }
+            function requireNullableString(value) {
+                if (null === value) return null;
+                return requireString(value, true);
+            }
+            function requireConversationId(value) {
+                if ("string" != typeof value || 0 === value.length) invalid("configurable.thread_id must be a non-empty conversationId string");
+                if (Buffer.byteLength(value, "utf8") > 256) invalid("configurable.thread_id must not exceed 256 UTF-8 bytes");
+                return value;
+            }
+            function optionalConversationId(value) {
+                return void 0 === value ? null : requireConversationId(value);
+            }
+            function requireNamespace(value) {
+                if (void 0 === value) return "";
+                if ("string" != typeof value) invalid("configurable.checkpoint_ns must be a string");
+                return value;
+            }
+            function optionalNamespace(value) {
+                if (null == value) return null;
+                if ("string" != typeof value) invalid("configurable.checkpoint_ns must be a string");
+                return value;
+            }
+            function optionalIdentifier(value, field) {
+                if (null == value || "" === value) return null;
+                if ("string" != typeof value) invalid(`${field} must be a string`);
+                return value;
+            }
+            function stringIdentifier(value, field) {
+                if ("string" != typeof value) invalid(`${field} must be a string`);
+                return value;
+            }
+            function normalizeVersions(value, field) {
+                if (null === value || "object" != typeof value || Array.isArray(value)) invalid(`${field} must be an object`);
+                const normalized = {};
+                for (const [key, version] of Object.entries(value)){
+                    if ("string" != typeof version && "number" != typeof version || "number" == typeof version && !Number.isFinite(version)) invalid(`${field} contains an invalid channel version`);
+                    Object.defineProperty(normalized, key, {
+                        value: version,
+                        enumerable: true,
+                        writable: true,
+                        configurable: true
+                    });
+                }
+                return normalized;
+            }
+            function normalizeVersionsSeen(value) {
+                if (null === value || "object" != typeof value || Array.isArray(value)) invalid("checkpoint.versions_seen must be an object");
+                const normalized = {};
+                for (const [node, versions] of Object.entries(value))Object.defineProperty(normalized, node, {
+                    value: normalizeVersions(versions, `checkpoint.versions_seen.${node}`),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true
+                });
+                return normalized;
+            }
+            function toBase64(value) {
+                return Buffer.from(value).toString("base64");
+            }
+            function fromBase64(value) {
+                if ("string" != typeof value) internal();
+                return Buffer.from(value, "base64");
+            }
+            function parseBlob(value) {
+                const row = requireRecord(value);
+                const type = requireString(row.type);
+                const blobBase64 = row.blob_base64;
+                if ("empty" === type && null !== blobBase64 || "empty" !== type && "string" != typeof blobBase64) internal();
+                return {
+                    channel: requireString(row.channel, true),
+                    version: requireString(row.version, true),
+                    type,
+                    blob_base64: blobBase64
+                };
+            }
+            function parseWrite(value) {
+                const row = requireRecord(value);
+                if (!Number.isInteger(row.idx)) internal();
+                return {
+                    task_id: requireString(row.task_id, true),
+                    idx: row.idx,
+                    channel: requireString(row.channel, true),
+                    type: requireString(row.type),
+                    blob_base64: requireString(row.blob_base64, true)
+                };
+            }
+            function parseCheckpointRow(value) {
+                const row = requireRecord(value);
+                return {
+                    thread_id: requireString(row.thread_id),
+                    checkpoint_ns: requireString(row.checkpoint_ns, true),
+                    checkpoint_id: requireString(row.checkpoint_id, true),
+                    parent_checkpoint_id: requireNullableString(row.parent_checkpoint_id),
+                    checkpoint: requireRecord(row.checkpoint),
+                    metadata: requireRecord(row.metadata),
+                    blobs: requireArray(row.blobs).map(parseBlob),
+                    writes: requireArray(row.writes).map(parseWrite),
+                    pending_sends: requireArray(row.pending_sends ?? []).map(parseWrite)
+                };
+            }
+            function parseDeltaHistory(value) {
+                return requireArray(value).map((item)=>{
+                    const row = requireRecord(item);
+                    if (!Number.isInteger(row.depth) || row.depth < 1) internal();
+                    return {
+                        depth: row.depth,
+                        checkpoint_id: requireString(row.checkpoint_id, true),
+                        parent_checkpoint_id: requireNullableString(row.parent_checkpoint_id),
+                        blobs: requireArray(row.blobs).map(parseBlob),
+                        writes: requireArray(row.writes).map(parseWrite)
+                    };
+                });
+            }
+            function outputConfig(threadId, checkpointNamespace, checkpointId) {
+                return {
+                    configurable: {
+                        thread_id: threadId,
+                        checkpoint_ns: checkpointNamespace,
+                        checkpoint_id: checkpointId
+                    }
+                };
+            }
+            class IgaCheckpointSaver extends langgraph_checkpoint_namespaceObject.BaseCheckpointSaver {
+                async get(config) {
+                    return (await this.getTuple(config))?.checkpoint;
+                }
+                async getTuple(config) {
+                    const configurable = config.configurable ?? {};
+                    if (void 0 === configurable.thread_id) return;
+                    const threadId = requireConversationId(configurable.thread_id);
+                    if (null === configurable.checkpoint_ns) return;
+                    const checkpointNamespace = requireNamespace(configurable.checkpoint_ns);
+                    const checkpointId = optionalIdentifier(configurable.checkpoint_id, "configurable.checkpoint_id");
+                    const raw = await langGraphCheckpointRepository.getCheckpoint({
+                        threadId,
+                        checkpointNamespace,
+                        checkpointId
+                    });
+                    if (null === raw) return;
+                    return this.materializeTuple(parseCheckpointRow(raw), "getTuple");
+                }
+                async *list(config, options = {}) {
+                    const configurable = config?.configurable ?? {};
+                    const threadId = optionalConversationId(configurable.thread_id);
+                    const checkpointNamespace = optionalNamespace(configurable.checkpoint_ns);
+                    const checkpointId = optionalIdentifier(configurable.checkpoint_id, "configurable.checkpoint_id");
+                    const beforeId = options.before?.configurable?.checkpoint_id;
+                    if (null === beforeId) return;
+                    const beforeCheckpointId = void 0 === beforeId ? null : stringIdentifier(beforeId, "before.configurable.checkpoint_id");
+                    const limit = void 0 === options.limit ? null : Number.parseInt(String(options.limit), 10);
+                    if (null !== limit && (!Number.isSafeInteger(limit) || limit < 0)) invalid("list limit must be a non-negative integer");
+                    if (0 === limit) return;
+                    const metadata = null == options.filter ? null : jsonObject(options.filter, "checkpoint metadata filter");
+                    const raw = await langGraphCheckpointRepository.listCheckpoints({
+                        threadId,
+                        checkpointNamespace,
+                        checkpointId,
+                        metadata,
+                        beforeCheckpointId,
+                        limit
+                    });
+                    for (const row of requireArray(raw))yield await this.materializeTuple(parseCheckpointRow(row), "list");
+                }
+                async put(config, checkpoint, metadata, newVersions) {
+                    const configurable = config.configurable ?? {};
+                    const threadId = requireConversationId(configurable.thread_id);
+                    const checkpointNamespace = requireNamespace(configurable.checkpoint_ns);
+                    const checkpointId = stringIdentifier(checkpoint.id, "checkpoint.id");
+                    const parentCheckpointId = null == configurable.checkpoint_id ? null : stringIdentifier(configurable.checkpoint_id, "configurable.checkpoint_id");
+                    if ("number" != typeof checkpoint.v || !Number.isFinite(checkpoint.v)) invalid("checkpoint.v must be a finite number");
+                    if ("string" != typeof checkpoint.ts) invalid("checkpoint.ts must be a string");
+                    const channelVersions = normalizeVersions(checkpoint.channel_versions, "checkpoint.channel_versions");
+                    const versionsSeen = normalizeVersionsSeen(checkpoint.versions_seen);
+                    const { channel_values: _values, ...checkpointFields } = checkpoint;
+                    const header = jsonObject({
+                        ...checkpointFields,
+                        channel_versions: channelVersions,
+                        versions_seen: versionsSeen
+                    }, "checkpoint");
+                    const normalizedNewVersions = normalizeVersions(newVersions, "newVersions");
+                    const channelValues = checkpoint.channel_values ?? {};
+                    const blobs = await Promise.all(Object.entries(normalizedNewVersions).map(async ([channel, version])=>{
+                        if (!(channel in channelValues)) return {
+                            channel,
+                            version: String(version),
+                            type: "empty",
+                            blob_base64: null
+                        };
+                        const [type, bytes] = await this.dumpValue(channelValues[channel], "put");
+                        return {
+                            channel,
+                            version: String(version),
+                            type,
+                            blob_base64: toBase64(bytes)
+                        };
+                    }));
+                    await langGraphCheckpointRepository.putCheckpoint({
+                        threadId,
+                        checkpointNamespace,
+                        checkpointId,
+                        parentCheckpointId,
+                        checkpoint: header,
+                        metadata: await this.dumpMetadata(metadata),
+                        blobs
+                    });
+                    return outputConfig(threadId, checkpointNamespace, checkpointId);
+                }
+                async putWrites(config, writes, taskId) {
+                    const configurable = config.configurable ?? {};
+                    const threadId = requireConversationId(configurable.thread_id);
+                    const checkpointNamespace = requireNamespace(configurable.checkpoint_ns);
+                    const checkpointId = stringIdentifier(configurable.checkpoint_id, "configurable.checkpoint_id");
+                    stringIdentifier(taskId, "taskId");
+                    const materialized = await Promise.all(writes.map(async ([channel, value], index)=>{
+                        if ("string" != typeof channel) invalid("pending write channel must be a string");
+                        const [type, bytes] = await this.dumpValue(value, "putWrites");
+                        return {
+                            idx: langgraph_checkpoint_namespaceObject.WRITES_IDX_MAP[channel] ?? index,
+                            channel,
+                            type,
+                            blob_base64: toBase64(bytes)
+                        };
+                    }));
+                    await langGraphCheckpointRepository.putWrites({
+                        threadId,
+                        checkpointNamespace,
+                        checkpointId,
+                        taskId,
+                        writes: materialized
+                    });
+                }
+                async deleteThread(threadId) {
+                    await langGraphCheckpointRepository.deleteThread(requireConversationId(threadId));
+                }
+                async getDeltaChannelHistory(options) {
+                    if (0 === options.channels.length) return {};
+                    if (options.channels.includes(langgraph_checkpoint_namespaceObject.TASKS)) return super.getDeltaChannelHistory(options);
+                    const configurable = options.config.configurable ?? {};
+                    if (void 0 === configurable.thread_id) return Object.fromEntries(options.channels.map((channel)=>[
+                            channel,
+                            {
+                                writes: []
+                            }
+                        ]));
+                    const threadId = requireConversationId(configurable.thread_id);
+                    if (null === configurable.checkpoint_ns) return Object.fromEntries(options.channels.map((channel)=>[
+                            channel,
+                            {
+                                writes: []
+                            }
+                        ]));
+                    const checkpointNamespace = requireNamespace(configurable.checkpoint_ns);
+                    const checkpointId = optionalIdentifier(configurable.checkpoint_id, "configurable.checkpoint_id");
+                    const channels = [
+                        ...new Set(options.channels)
+                    ];
+                    if (channels.some((channel)=>"string" != typeof channel)) invalid("delta-history channels must be strings");
+                    const chain = parseDeltaHistory(await langGraphCheckpointRepository.getDeltaHistory({
+                        threadId,
+                        checkpointNamespace,
+                        checkpointId,
+                        channels
+                    }));
+                    const collected = new Map(channels.map((channel)=>[
+                            channel,
+                            []
+                        ]));
+                    const seeds = new Map();
+                    const remaining = new Set(channels);
+                    for (const ancestor of chain){
+                        if (0 === remaining.size) break;
+                        const writesByChannel = new Map();
+                        for (const write of ancestor.writes){
+                            if (!remaining.has(write.channel)) continue;
+                            const block = writesByChannel.get(write.channel) ?? [];
+                            block.push([
+                                write.task_id,
+                                write.channel,
+                                await this.loadValue(write.type, write.blob_base64, "getDeltaChannelHistory")
+                            ]);
+                            writesByChannel.set(write.channel, block);
+                        }
+                        for (const [channel, block] of writesByChannel){
+                            block.sort((a, b)=>a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+                            collected.get(channel)?.push(block);
+                        }
+                        for (const blob of ancestor.blobs)if (remaining.has(blob.channel) && "empty" !== blob.type) {
+                            seeds.set(blob.channel, await this.loadValue(blob.type, blob.blob_base64, "getDeltaChannelHistory"));
+                            remaining.delete(blob.channel);
+                        }
+                    }
+                    const result = {};
+                    for (const channel of channels){
+                        const history = {
+                            writes: (collected.get(channel) ?? []).reverse().flat()
+                        };
+                        if (seeds.has(channel)) history.seed = seeds.get(channel);
+                        result[channel] = history;
+                    }
+                    return result;
+                }
+                getNextVersion(current) {
+                    if ("number" == typeof current) {
+                        if (!Number.isFinite(current) || current + 1 <= current) invalid("current channel version is invalid");
+                        return current + 1;
+                    }
+                    let next = 1n;
+                    if (void 0 !== current) {
+                        const match = VERSION_PREFIX_PATTERN.exec(current);
+                        if (!match) invalid("current channel version is invalid");
+                        next = BigInt(match[1]) + 1n;
+                    }
+                    return `${next.toString().padStart(VERSION_WIDTH, "0")}-${(0, external_node_crypto_.randomUUID)()}`;
+                }
+                async dumpMetadata(metadata) {
+                    const [, bytes] = await this.dumpValue(metadata, "put");
+                    try {
+                        return requireRecord(JSON.parse(new TextDecoder().decode(bytes).replace(/\0/g, "")));
+                    } catch  {
+                        throw new errors.A("BadRequest", "Checkpoint metadata could not be serialized");
+                    }
+                }
+                async loadMetadata(metadata, operation) {
+                    try {
+                        const [type, bytes] = await this.serde.dumpsTyped(metadata);
+                        return await this.serde.loadsTyped(type, bytes);
+                    } catch  {
+                        throw new errors.A("UnknownError", "Stored checkpoint metadata could not be deserialized");
+                    }
+                }
+                async dumpValue(value, operation) {
+                    try {
+                        const [type, bytes] = await this.serde.dumpsTyped(value);
+                        if (!type || "string" != typeof type || !(bytes instanceof Uint8Array)) throw new Error("Invalid serializer result");
+                        return [
+                            type,
+                            bytes
+                        ];
+                    } catch  {
+                        throw new errors.A("BadRequest", "Checkpoint value could not be serialized");
+                    }
+                }
+                async loadValue(type, value, operation) {
+                    try {
+                        if ("string" != typeof value || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value.replace(/\s/g, ""))) throw new Error("Invalid encoded checkpoint value");
+                        return await this.serde.loadsTyped(type, fromBase64(value));
+                    } catch  {
+                        throw new errors.A("UnknownError", "Stored checkpoint value could not be deserialized");
+                    }
+                }
+                async materializeTuple(row, operation) {
+                    const checkpointHeader = requireRecord(row.checkpoint);
+                    if ("number" != typeof checkpointHeader.v || checkpointHeader.id !== row.checkpoint_id || "string" != typeof checkpointHeader.ts) internal();
+                    const channelVersions = {
+                        ...requireRecord(checkpointHeader.channel_versions)
+                    };
+                    const versionsSeen = requireRecord(checkpointHeader.versions_seen);
+                    const channelValues = {};
+                    for (const blob of row.blobs)if ("empty" !== blob.type) Object.defineProperty(channelValues, blob.channel, {
+                        value: await this.loadValue(blob.type, blob.blob_base64, operation),
+                        enumerable: true,
+                        writable: true,
+                        configurable: true
+                    });
+                    if (checkpointHeader.v < 4 && null !== row.parent_checkpoint_id && row.pending_sends?.length) {
+                        const sends = await Promise.all(row.pending_sends.map((write)=>this.loadValue(write.type, write.blob_base64, operation)));
+                        try {
+                            const [type, bytes] = await this.serde.dumpsTyped(sends);
+                            channelValues[langgraph_checkpoint_namespaceObject.TASKS] = await this.serde.loadsTyped(type, bytes);
+                        } catch  {
+                            throw new errors.A("UnknownError", "Stored checkpoint sends could not be deserialized");
+                        }
+                        const versions = Object.values(channelVersions);
+                        channelVersions[langgraph_checkpoint_namespaceObject.TASKS] = versions.length ? (0, langgraph_checkpoint_namespaceObject.maxChannelVersion)(...versions) : this.getNextVersion(void 0);
+                    }
+                    const pendingWrites = [];
+                    for (const write of row.writes)pendingWrites.push([
+                        write.task_id,
+                        write.channel,
+                        await this.loadValue(write.type, write.blob_base64, operation)
+                    ]);
+                    const tuple = {
+                        config: outputConfig(row.thread_id, row.checkpoint_ns, row.checkpoint_id),
+                        checkpoint: {
+                            ...checkpointHeader,
+                            v: checkpointHeader.v,
+                            id: row.checkpoint_id,
+                            ts: checkpointHeader.ts,
+                            channel_values: channelValues,
+                            channel_versions: channelVersions,
+                            versions_seen: versionsSeen
+                        },
+                        metadata: await this.loadMetadata(row.metadata, operation),
+                        pendingWrites,
+                        parentConfig: void 0
+                    };
+                    if (row.parent_checkpoint_id) tuple.parentConfig = outputConfig(row.thread_id, row.checkpoint_ns, row.parent_checkpoint_id);
+                    return tuple;
+                }
+                constructor(serde){
+                    super(serde);
+                }
+            }
+            function createCheckpointer(serde) {
+                return new IgaCheckpointSaver(serde);
+            }
+        },
+        "node:crypto" (module) {
+            module.exports = require("node:crypto");
+        }
+    };
+    var __webpack_require__ = require("../runtime.js");
+    __webpack_require__.C(exports);
+    var __webpack_exec__ = function(moduleId) {
+        return __webpack_require__(__webpack_require__.s = moduleId);
+    };
+    var __webpack_exports__ = __webpack_require__.X(0, [
+        "504",
+        "808",
+        "82",
+        "951"
+    ], function() {
+        return __webpack_exec__("../store/src/langgraph.ts");
+    });
+    exports.IgaCheckpointSaver = __webpack_exports__.IgaCheckpointSaver;
+    exports.createCheckpointer = __webpack_exports__.createCheckpointer;
+    for(var __rspack_i in __webpack_exports__)if (-1 === [
+        "IgaCheckpointSaver",
+        "createCheckpointer"
+    ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+    Object.defineProperty(exports, '__esModule', {
+        value: true
+    });
+})();