// src/memory_lattice/DefaultMemorySaver.ts
import { MemorySaver } from "@langchain/langgraph";

// src/base/BaseLatticeManager.ts
var _BaseLatticeManager = class _BaseLatticeManager {
  /**
   * 受保护的构造函数，防止外部直接实例化
   */
  constructor() {
  }
  /**
   * 获取管理器实例（由子类实现）
   */
  static getInstance() {
    throw new Error("\u5FC5\u987B\u7531\u5B50\u7C7B\u5B9E\u73B0");
  }
  /**
   * 构造完整的键名，包含类型前缀和租户ID
   * @param tenantId 租户ID，全局共享使用 "default"
   * @param key 原始键名
   */
  getFullKey(tenantId, key) {
    return `${this.getLatticeType()}:${tenantId}:${key}`;
  }
  // ========== 带租户的新API ==========
  /**
   * 带租户的注册项目
   * @param tenantId 租户ID
   * @param key 项目键名（不含前缀）
   * @param item 项目实例
   */
  registerWithTenant(tenantId, key, item) {
    const fullKey = this.getFullKey(tenantId, key);
    if (_BaseLatticeManager.registry.has(fullKey)) {
      throw new Error(`\u9879\u76EE "${fullKey}" \u5DF2\u7ECF\u5B58\u5728\uFF0C\u65E0\u6CD5\u91CD\u590D\u6CE8\u518C`);
    }
    _BaseLatticeManager.registry.set(fullKey, item);
  }
  /**
   * 带租户的获取指定项目（同步）
   * @param tenantId 租户ID
   * @param key 项目键名（不含前缀）
   */
  getWithTenant(tenantId, key) {
    const fullKey = this.getFullKey(tenantId, key);
    return _BaseLatticeManager.registry.get(fullKey);
  }
  /**
   * 带租户的获取指定项目（异步，支持从store回退加载）
   * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
   * @param tenantId 租户ID
   * @param key 项目键名（不含前缀）
   * @returns 项目实例，如果未找到则返回undefined
   */
  async getOrLoadWithTenant(tenantId, key) {
    const item = this.getWithTenant(tenantId, key);
    if (item !== void 0) {
      return item;
    }
    if (this.loadItemFromStore) {
      const loadedItem = await this.loadItemFromStore(tenantId, key);
      if (loadedItem !== void 0) {
        this.registerWithTenant(tenantId, key, loadedItem);
        return loadedItem;
      }
    }
    return void 0;
  }
  /**
   * 带租户的检查项目是否存在（同步）
   * @param tenantId 租户ID
   * @param key 项目键名（不含前缀）
   */
  hasWithTenant(tenantId, key) {
    const fullKey = this.getFullKey(tenantId, key);
    return _BaseLatticeManager.registry.has(fullKey);
  }
  /**
   * 带租户的检查项目是否存在（异步，支持从store回退加载）
   * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
   * @param tenantId 租户ID
   * @param key 项目键名（不含前缀）
   * @returns 如果存在或能从store加载则返回true
   */
  async hasOrLoadWithTenant(tenantId, key) {
    if (this.hasWithTenant(tenantId, key)) {
      return true;
    }
    if (this.loadItemFromStore) {
      const loadedItem = await this.loadItemFromStore(tenantId, key);
      if (loadedItem !== void 0) {
        this.registerWithTenant(tenantId, key, loadedItem);
        return true;
      }
    }
    return false;
  }
  /**
   * 带租户的移除项目
   * @param tenantId 租户ID
   * @param key 项目键名（不含前缀）
   */
  removeWithTenant(tenantId, key) {
    const fullKey = this.getFullKey(tenantId, key);
    return _BaseLatticeManager.registry.delete(fullKey);
  }
  /**
   * 获取指定租户的所有项目
   * @param tenantId 租户ID
   */
  getAllByTenant(tenantId) {
    const prefix = `${this.getLatticeType()}:${tenantId}:`;
    const result = [];
    for (const [key, value] of _BaseLatticeManager.registry.entries()) {
      if (key.startsWith(prefix)) {
        result.push(value);
      }
    }
    return result;
  }
  /**
   * 清空指定租户的所有项目
   * @param tenantId 租户ID
   */
  clearByTenant(tenantId) {
    const prefix = `${this.getLatticeType()}:${tenantId}:`;
    const keysToDelete = [];
    for (const key of _BaseLatticeManager.registry.keys()) {
      if (key.startsWith(prefix)) {
        keysToDelete.push(key);
      }
    }
    for (const key of keysToDelete) {
      _BaseLatticeManager.registry.delete(key);
    }
  }
  // ========== 向后兼容的旧API（使用 default 租户） ==========
  /**
   * 注册项目（向后兼容，使用 "default" 租户）
   * @deprecated Use registerWithTenant(tenantId, key, item) instead
   * @param key 项目键名（不含前缀）
   * @param item 项目实例
   */
  register(key, item) {
    this.registerWithTenant("default", key, item);
  }
  /**
   * 获取指定项目（向后兼容，使用 "default" 租户）
   * @deprecated Use getWithTenant(tenantId, key) instead
   * @param key 项目键名（不含前缀）
   */
  get(key) {
    return this.getWithTenant("default", key);
  }
  /**
   * 获取所有当前类型的项目（向后兼容，包含所有租户）
   */
  getAll() {
    const prefix = `${this.getLatticeType()}:`;
    const result = [];
    for (const [key, value] of _BaseLatticeManager.registry.entries()) {
      if (key.startsWith(prefix)) {
        result.push(value);
      }
    }
    return result;
  }
  /**
   * 检查项目是否存在（向后兼容，使用 "default" 租户）
   * @deprecated Use hasWithTenant(tenantId, key) instead
   * @param key 项目键名（不含前缀）
   */
  has(key) {
    return this.hasWithTenant("default", key);
  }
  /**
   * 移除项目（向后兼容，使用 "default" 租户）
   * @deprecated Use removeWithTenant(tenantId, key) instead
   * @param key 项目键名（不含前缀）
   */
  remove(key) {
    return this.removeWithTenant("default", key);
  }
  /**
   * 清空当前类型的所有项目（向后兼容，包含所有租户）
   */
  clear() {
    const prefix = `${this.getLatticeType()}:`;
    const keysToDelete = [];
    for (const key of _BaseLatticeManager.registry.keys()) {
      if (key.startsWith(prefix)) {
        keysToDelete.push(key);
      }
    }
    for (const key of keysToDelete) {
      _BaseLatticeManager.registry.delete(key);
    }
  }
  /**
   * 获取当前类型的项目数量（向后兼容，包含所有租户）
   */
  count() {
    const prefix = `${this.getLatticeType()}:`;
    let count = 0;
    for (const key of _BaseLatticeManager.registry.keys()) {
      if (key.startsWith(prefix)) {
        count++;
      }
    }
    return count;
  }
  /**
   * 获取当前类型的项目键名列表（向后兼容，包含所有租户）
   * 返回格式: {tenantId}:{key}
   */
  keys() {
    const prefix = `${this.getLatticeType()}:`;
    const prefixLength = prefix.length;
    const result = [];
    for (const key of _BaseLatticeManager.registry.keys()) {
      if (key.startsWith(prefix)) {
        result.push(key.substring(prefixLength));
      }
    }
    return result;
  }
  /**
   * 获取当前类型的项目键名列表（仅指定租户，不含租户前缀）
   * @param tenantId 租户ID
   */
  keysByTenant(tenantId) {
    const prefix = `${this.getLatticeType()}:${tenantId}:`;
    const prefixLength = prefix.length;
    const result = [];
    for (const key of _BaseLatticeManager.registry.keys()) {
      if (key.startsWith(prefix)) {
        result.push(key.substring(prefixLength));
      }
    }
    return result;
  }
};
// 全局统一的Lattice注册表
_BaseLatticeManager.registry = /* @__PURE__ */ new Map();
var BaseLatticeManager = _BaseLatticeManager;

// src/memory_lattice/MemoryLatticeManager.ts
import { MemoryType } from "@axiom-lattice/protocols";
var _MemoryLatticeManager = class _MemoryLatticeManager extends BaseLatticeManager {
  /**
   * 私有构造函数，防止外部直接实例化
   */
  constructor() {
    super();
  }
  /**
   * 获取单例实例
   */
  static getInstance() {
    if (!_MemoryLatticeManager.instance) {
      _MemoryLatticeManager.instance = new _MemoryLatticeManager();
    }
    return _MemoryLatticeManager.instance;
  }
  /**
   * 获取Lattice类型
   */
  getLatticeType() {
    return "memory";
  }
  /**
   * 注册检查点保存器
   * @param key 保存器键名
   * @param saver 检查点保存器实例
   */
  registerCheckpointSaver(key, saver) {
    if (_MemoryLatticeManager.checkpointSavers.has(key)) {
      console.warn(`\u68C0\u67E5\u70B9\u4FDD\u5B58\u5668 "${key}" \u5DF2\u7ECF\u5B58\u5728\uFF0C\u5C06\u4F1A\u8986\u76D6\u65E7\u7684\u68C0\u67E5\u70B9\u4FDD\u5B58\u5668`);
    }
    _MemoryLatticeManager.checkpointSavers.set(key, saver);
  }
  /**
   * 获取检查点保存器
   * @param key 保存器键名
   */
  getCheckpointSaver(key) {
    const saver = _MemoryLatticeManager.checkpointSavers.get(key);
    if (!saver) {
      throw new Error(`\u68C0\u67E5\u70B9\u4FDD\u5B58\u5668 "${key}" \u4E0D\u5B58\u5728`);
    }
    return saver;
  }
  /**
   * 获取所有已注册的检查点保存器键名
   */
  getCheckpointSaverKeys() {
    return Array.from(_MemoryLatticeManager.checkpointSavers.keys());
  }
  /**
   * 检查检查点保存器是否存在
   * @param key 保存器键名
   */
  hasCheckpointSaver(key) {
    return _MemoryLatticeManager.checkpointSavers.has(key);
  }
  /**
   * 移除检查点保存器
   * @param key 保存器键名
   */
  removeCheckpointSaver(key) {
    return _MemoryLatticeManager.checkpointSavers.delete(key);
  }
};
// 检查点保存器注册表
_MemoryLatticeManager.checkpointSavers = /* @__PURE__ */ new Map();
var MemoryLatticeManager = _MemoryLatticeManager;
var getCheckpointSaver = (key) => MemoryLatticeManager.getInstance().getCheckpointSaver(key);
var registerCheckpointSaver = (key, saver) => MemoryLatticeManager.getInstance().registerCheckpointSaver(key, saver);

// src/memory_lattice/DefaultMemorySaver.ts
var memory = new MemorySaver();
registerCheckpointSaver("default", memory);

export {
  BaseLatticeManager,
  MemoryType,
  MemoryLatticeManager,
  getCheckpointSaver,
  registerCheckpointSaver
};
//# sourceMappingURL=chunk-C5HUS7YV.mjs.map