@ferricstore/ferricstore 0.11.11 → 0.12.0

package/dist/langgraph.js

@@ -0,0 +1,1252 @@
+// src/langgraph/checkpoint.ts
+import { createHash } from "crypto";
+import {
+  BaseCheckpointSaver,
+  copyCheckpoint
+} from "@langchain/langgraph";
+
+// src/agent-persistence/durability.ts
+import { randomUUID } from "crypto";
+import { setTimeout as delay } from "timers/promises";
+
+// src/errors.ts
+var FerricStoreError = class extends Error {
+  code = "ferricstore_error";
+  raw;
+  retryable;
+  safeToRetry;
+  retryAfterMs;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = new.target.name;
+    this.raw = options.raw;
+    this.retryable = options.retryable ?? structuredBooleanField(options.raw, "retryable");
+    this.safeToRetry = options.safeToRetry ?? structuredBooleanField(options.raw, "safe_to_retry");
+    this.retryAfterMs = options.retryAfterMs ?? structuredIntegerField(options.raw, "retry_after_ms");
+  }
+};
+var LockHeldError = class extends FerricStoreError {
+  code = "lock_held";
+};
+function structuredIntegerField(raw, name) {
+  const value = structuredField(raw, name);
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : void 0;
+  }
+  const text = binaryText(value);
+  return text == null ? void 0 : nonNegativeSafeIntegerText(text);
+}
+function structuredBooleanField(raw, name) {
+  const value = structuredField(raw, name);
+  if (typeof value === "boolean") return value;
+  const text = binaryText(value)?.toLowerCase();
+  if (text === "true" || text === "1") return true;
+  if (text === "false" || text === "0") return false;
+  return void 0;
+}
+function nonNegativeSafeIntegerText(value) {
+  if (!/^[0-9]+$/u.test(value)) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function structuredField(raw, name) {
+  if (raw instanceof Map) {
+    if (raw.has(name)) return raw.get(name);
+    for (const [key, value] of raw.entries()) {
+      if (binaryText(key) === name) return value;
+    }
+    return void 0;
+  }
+  if (typeof raw === "object" && raw != null && Object.hasOwn(raw, name)) {
+    return raw[name];
+  }
+  return void 0;
+}
+function binaryText(value) {
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) return Buffer.from(value).toString("utf8");
+  return void 0;
+}
+
+// src/agent-persistence/durability.ts
+var DEFAULT_LOCK_OPTIONS = {
+  lockRetryMs: 10,
+  lockTtlMs: 3e5,
+  lockWaitMs: 3e4
+};
+function normalizeKeyPrefix(value, defaultValue) {
+  const prefix = value.length === 0 ? defaultValue : value;
+  if (prefix.includes("\0")) throw new TypeError("keyPrefix must not contain NUL bytes");
+  const normalized = prefix.replace(/:+$/u, "");
+  if (normalized.length === 0) throw new TypeError("keyPrefix must contain a character other than ':'");
+  return normalized;
+}
+function positiveInteger(value, fallback, name) {
+  const normalized = value ?? fallback;
+  if (!Number.isSafeInteger(normalized) || normalized <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
+  return normalized;
+}
+function nonNegativeInteger(value, fallback, name) {
+  const normalized = value ?? fallback;
+  if (!Number.isSafeInteger(normalized) || normalized < 0) {
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  }
+  return normalized;
+}
+function textResponse(value, name) {
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) return Buffer.from(value).toString("utf8");
+  throw new TypeError(`FerricStore returned an invalid ${name}`);
+}
+function arrayResponse(value, name) {
+  if (!Array.isArray(value)) throw new TypeError(`FerricStore returned an invalid ${name}`);
+  return value;
+}
+function integerResponse(value, name) {
+  const parsed = typeof value === "number" ? value : Number(textResponse(value, name));
+  if (!Number.isSafeInteger(parsed)) throw new TypeError(`FerricStore returned an invalid ${name}`);
+  return parsed;
+}
+async function withMutationLocks(client, keys, operation, options = {}) {
+  const orderedKeys = [...new Set(keys)].sort();
+  if (orderedKeys.length === 0) return await operation();
+  const normalized = {
+    lockRetryMs: positiveInteger(options.lockRetryMs, DEFAULT_LOCK_OPTIONS.lockRetryMs, "lockRetryMs"),
+    lockTtlMs: positiveInteger(options.lockTtlMs, DEFAULT_LOCK_OPTIONS.lockTtlMs, "lockTtlMs"),
+    lockWaitMs: nonNegativeInteger(options.lockWaitMs, DEFAULT_LOCK_OPTIONS.lockWaitMs, "lockWaitMs")
+  };
+  const owner = randomUUID();
+  const acquired = [];
+  const deadline = performance.now() + normalized.lockWaitMs;
+  let primaryError;
+  let heartbeatError;
+  let releaseError;
+  let result;
+  let operationCompleted = false;
+  const heartbeatAbort = new AbortController();
+  try {
+    for (const key of orderedKeys) {
+      while (!await tryAcquireLock(client, key, owner, normalized.lockTtlMs)) {
+        if (performance.now() >= deadline) {
+          throw new Error(`timed out acquiring FerricStore lock ${JSON.stringify(key)}`);
+        }
+        await delay(normalized.lockRetryMs);
+      }
+      acquired.push(key);
+    }
+    const heartbeat = renewLocks(
+      client,
+      acquired,
+      owner,
+      normalized.lockTtlMs,
+      heartbeatAbort.signal,
+      (error) => {
+        heartbeatError ??= error;
+      }
+    );
+    try {
+      result = await operation();
+      operationCompleted = true;
+    } catch (error) {
+      primaryError = error;
+    } finally {
+      heartbeatAbort.abort();
+      await heartbeat;
+    }
+  } catch (error) {
+    primaryError ??= error;
+  } finally {
+    heartbeatAbort.abort();
+    for (const key of acquired.reverse()) {
+      try {
+        await client.command("UNLOCK", key, owner);
+      } catch (error) {
+        releaseError ??= error;
+      }
+    }
+  }
+  if (primaryError != null) throw errorObject(primaryError);
+  if (heartbeatError != null) throw errorObject(heartbeatError);
+  if (releaseError != null) throw errorObject(releaseError);
+  if (!operationCompleted) throw new Error("FerricStore mutation did not complete");
+  return result;
+}
+async function tryAcquireLock(client, key, owner, ttlMs) {
+  try {
+    const response = await client.command("LOCK", key, owner, ttlMs);
+    return response === true || response === "OK" || Buffer.isBuffer(response) && response.equals(Buffer.from("OK"));
+  } catch (error) {
+    if (error instanceof LockHeldError) return false;
+    throw error;
+  }
+}
+async function renewLocks(client, keys, owner, ttlMs, signal, onError) {
+  const intervalMs = Math.max(Math.floor(ttlMs / 3), 10);
+  const retryMs = Math.min(Math.max(Math.floor(intervalMs / 10), 10), 1e3);
+  const lastExtended = new Map(keys.map((key) => [key, performance.now()]));
+  let waitMs = intervalMs;
+  while (!signal.aborted) {
+    try {
+      await delay(waitMs, void 0, { signal });
+    } catch (error) {
+      if (signal.aborted) return;
+      onError(error);
+      return;
+    }
+    const now = performance.now();
+    let retry = false;
+    for (const key of keys) {
+      try {
+        const response = await client.command("EXTEND", key, owner, ttlMs);
+        if (integerResponse(response, "EXTEND response") !== 1) {
+          onError(new Error(`lost FerricStore lock ${JSON.stringify(key)} while mutating data`));
+          return;
+        }
+        lastExtended.set(key, now);
+      } catch (error) {
+        if (now - (lastExtended.get(key) ?? 0) >= ttlMs) {
+          onError(new Error(`lost FerricStore lock ${JSON.stringify(key)} while mutating data`, { cause: error }));
+          return;
+        }
+        retry = true;
+      }
+    }
+    waitMs = retry ? retryMs : intervalMs;
+  }
+}
+function errorObject(value) {
+  return value instanceof Error ? value : new Error("FerricStore mutation failed", { cause: value });
+}
+
+// src/langgraph/checkpoint.ts
+var FORMAT_VERSION = 1;
+var CHECKPOINT_FIELD_PREFIX = "checkpoint:";
+var WRITE_FIELD_PREFIX = "write:";
+var WRITES_INDEX = {
+  __error__: -1,
+  __interrupt__: -3,
+  __resume__: -4,
+  __scheduled__: -2
+};
+var FerricStoreSaver = class extends BaseCheckpointSaver {
+  client;
+  keyPrefix;
+  scanCount;
+  lockOptions;
+  constructor(client, options = {}) {
+    super(options.serde);
+    this.client = client;
+    this.keyPrefix = normalizeKeyPrefix(options.keyPrefix ?? "langgraph:checkpoint", "langgraph:checkpoint");
+    this.scanCount = positiveInteger(options.scanCount, 256, "scanCount");
+    this.lockOptions = {
+      lockRetryMs: options.lockRetryMs,
+      lockTtlMs: options.lockTtlMs,
+      lockWaitMs: options.lockWaitMs
+    };
+  }
+  async getTuple(config) {
+    const { checkpointNs, threadId } = identity(config);
+    const key = this.threadKey(threadId, checkpointNs);
+    let id = checkpointId(config);
+    let record;
+    if (id != null) {
+      record = await this.readRecord(key, id);
+    } else {
+      let offset = 0;
+      while (true) {
+        const values = arrayResponse(
+          await this.client.command("ZREVRANGE", this.checkpointIndexKey(key), offset, offset),
+          "ZREVRANGE checkpoint response"
+        );
+        if (values.length === 0) return void 0;
+        id = textResponse(values[0], "checkpoint ID");
+        record = await this.readRecord(key, id);
+        if (record != null) break;
+        offset += 1;
+      }
+    }
+    if (id == null || record == null) return void 0;
+    return await this.tupleFromRecord(key, record);
+  }
+  async *list(config, options = {}) {
+    const limit = options.limit;
+    if (limit != null && (!Number.isSafeInteger(limit) || limit < 0)) {
+      throw new TypeError("limit must be a non-negative safe integer");
+    }
+    if (limit === 0) return;
+    const beforeId = options.before == null ? void 0 : checkpointId(options.before);
+    const configurable = config.configurable;
+    const threadId = optionalText(configurable?.thread_id, "thread_id");
+    const expectedId = optionalText(configurable?.checkpoint_id ?? configurable?.thread_ts, "checkpoint_id");
+    const namespaceSpecified = configurable != null && Object.hasOwn(configurable, "checkpoint_ns");
+    const checkpointNs = namespaceSpecified ? requiredText(configurable?.checkpoint_ns, "checkpoint_ns", true) : void 0;
+    const matches = [];
+    if (threadId == null) {
+      await this.collectGlobal(matches, beforeId, expectedId, options.filter, limit);
+    } else {
+      const keys = checkpointNs == null ? await this.threadKeys(threadId) : [this.threadKey(threadId, checkpointNs)];
+      for (const key of keys) {
+        const ids = expectedId == null ? await this.checkpointIds(key) : [expectedId];
+        for (const id of ids) {
+          if (beforeId != null && id >= beforeId) continue;
+          const record = await this.readRecord(key, id);
+          if (record == null || !metadataMatches(record.metadata, options.filter)) continue;
+          matches.push({ key, record });
+        }
+      }
+      matches.sort((left, right) => right.record.checkpointId.localeCompare(left.record.checkpointId));
+      if (limit != null) matches.splice(limit);
+    }
+    for (const match of matches) yield await this.tupleFromRecord(match.key, match.record);
+  }
+  async put(config, checkpoint, metadata, _newVersions) {
+    void _newVersions;
+    const { checkpointNs, threadId } = identity(config);
+    if (typeof checkpoint.id !== "string" || checkpoint.id.length === 0) {
+      throw new TypeError("checkpoint.id must be a non-empty string");
+    }
+    const parentCheckpointId = checkpointId(config);
+    const record = {
+      checkpoint: copyCheckpoint(checkpoint),
+      checkpointId: checkpoint.id,
+      checkpointNs,
+      formatVersion: FORMAT_VERSION,
+      metadata,
+      ...parentCheckpointId == null ? {} : { parentCheckpointId },
+      threadId
+    };
+    const key = this.threadKey(threadId, checkpointNs);
+    await withMutationLocks(this.client, [this.threadLockKey(threadId)], async () => {
+      const locator = checkpointLocator(checkpoint.id, key);
+      await this.client.command("SADD", this.threadCatalogKey(threadId), key);
+      await this.client.command("ZADD", this.threadLocatorCatalogKey(threadId), 0, locator);
+      await this.client.command("ZADD", this.catalogKey(), 0, locator);
+      await this.client.command("ZADD", this.checkpointIndexKey(key), 0, checkpoint.id);
+      await this.client.command("HSET", key, checkpointField(checkpoint.id), await this.serialize(record));
+    }, this.lockOptions);
+    return checkpointConfig(threadId, checkpointNs, checkpoint.id);
+  }
+  async putWrites(config, writes, taskId) {
+    const { checkpointNs, threadId } = identity(config);
+    const id = checkpointId(config);
+    if (id == null) throw new TypeError("putWrites requires configurable.checkpoint_id");
+    if (typeof taskId !== "string" || taskId.length === 0) throw new TypeError("taskId must be non-empty text");
+    const snapshots = await Promise.all(writes.map(async ([channel, value], fallbackIndex) => {
+      if (typeof channel !== "string") throw new TypeError("pending-write channel must be text");
+      const index = WRITES_INDEX[channel] ?? fallbackIndex;
+      const record = {
+        channel,
+        formatVersion: FORMAT_VERSION,
+        index,
+        taskId,
+        value
+      };
+      return { index, value: await this.serialize(record) };
+    }));
+    const key = this.threadKey(threadId, checkpointNs);
+    await withMutationLocks(this.client, [this.threadLockKey(threadId)], async () => {
+      await this.client.command("SADD", this.threadCatalogKey(threadId), key);
+      for (const snapshot of snapshots) {
+        await this.client.command(
+          snapshot.index < 0 ? "HSET" : "HSETNX",
+          key,
+          writeField(id, taskId, snapshot.index),
+          snapshot.value
+        );
+      }
+    }, this.lockOptions);
+  }
+  async deleteThread(threadId) {
+    const normalized = requiredText(threadId, "threadId");
+    await withMutationLocks(this.client, [this.threadLockKey(normalized)], async () => {
+      for (const key of await this.threadKeys(normalized)) {
+        await this.client.command("DEL", key, this.checkpointIndexKey(key));
+      }
+      const locatorKey = this.threadLocatorCatalogKey(normalized);
+      while (true) {
+        const locators = arrayResponse(
+          await this.client.command("ZRANGE", locatorKey, 0, this.scanCount - 1),
+          "thread checkpoint locator response"
+        );
+        if (locators.length === 0) break;
+        await this.client.command("ZREM", this.catalogKey(), ...asArguments(locators));
+        await this.client.command("ZREM", locatorKey, ...asArguments(locators));
+      }
+      await this.client.command("DEL", this.threadCatalogKey(normalized), locatorKey);
+    }, this.lockOptions);
+  }
+  catalogKey() {
+    return `${this.keyPrefix}:checkpoints`;
+  }
+  threadCatalogKey(threadId) {
+    const digest = sha256(threadId);
+    return `${this.keyPrefix}:{lgt:${digest}}:namespaces`;
+  }
+  threadLocatorCatalogKey(threadId) {
+    return `${this.threadCatalogKey(threadId)}:checkpoint-locators`;
+  }
+  threadLockKey(threadId) {
+    return `${this.keyPrefix}:{lgt:${sha256(threadId)}}:mutation-lock`;
+  }
+  threadKey(threadId, checkpointNs) {
+    return `${this.keyPrefix}:{lg:${sha256(lengthPrefixed([threadId, checkpointNs]))}}:thread`;
+  }
+  checkpointIndexKey(threadKey) {
+    return `${threadKey}:checkpoint-index`;
+  }
+  async serialize(value) {
+    const [type, data] = await this.serde.dumpsTyped(value);
+    const typeBytes = Buffer.from(type, "utf8");
+    if (typeBytes.length > 65535) throw new TypeError("serialized LangGraph type name is too long");
+    const header = Buffer.allocUnsafe(2);
+    header.writeUInt16BE(typeBytes.length);
+    return Buffer.concat([header, typeBytes, Buffer.from(data)]);
+  }
+  async deserialize(value, name) {
+    if (!(typeof value === "string" || Buffer.isBuffer(value) || value instanceof Uint8Array)) {
+      throw new TypeError(`FerricStore returned a non-binary ${name}`);
+    }
+    const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : Buffer.from(value);
+    if (bytes.length < 2) throw new Error(`invalid FerricStore ${name}`);
+    const typeLength = bytes.readUInt16BE(0);
+    if (bytes.length < typeLength + 2) throw new Error(`truncated FerricStore ${name}`);
+    const type = bytes.subarray(2, typeLength + 2).toString("utf8");
+    return await this.serde.loadsTyped(type, bytes.subarray(typeLength + 2));
+  }
+  async readRecord(key, id) {
+    const value = await this.client.command("HGET", key, checkpointField(id));
+    if (value == null) return void 0;
+    const record = await this.deserialize(value, "LangGraph checkpoint record");
+    if (record.formatVersion !== FORMAT_VERSION || record.checkpointId !== id) {
+      throw new Error("unsupported or corrupt FerricStore LangGraph checkpoint record");
+    }
+    return record;
+  }
+  async pendingWrites(key, id) {
+    const fields = await this.scanHash(key, `${WRITE_FIELD_PREFIX}${encodeComponent(id)}:*`);
+    const records = await Promise.all(fields.map(async ([, value]) => await this.deserialize(value, "LangGraph pending write")));
+    for (const record of records) {
+      if (record.formatVersion !== FORMAT_VERSION) {
+        throw new Error("unsupported FerricStore LangGraph pending-write format");
+      }
+    }
+    records.sort((left, right) => left.taskId.localeCompare(right.taskId) || left.index - right.index);
+    return records.map((record) => [record.taskId, record.channel, record.value]);
+  }
+  async tupleFromRecord(key, record) {
+    return {
+      checkpoint: record.checkpoint,
+      config: checkpointConfig(record.threadId, record.checkpointNs, record.checkpointId),
+      metadata: record.metadata,
+      pendingWrites: await this.pendingWrites(key, record.checkpointId),
+      ...record.parentCheckpointId == null ? {} : { parentConfig: checkpointConfig(record.threadId, record.checkpointNs, record.parentCheckpointId) }
+    };
+  }
+  async scanHash(key, pattern) {
+    let cursor = 0;
+    const result = [];
+    do {
+      const response = arrayResponse(
+        await this.client.command("HSCAN", key, cursor, "MATCH", pattern, "COUNT", this.scanCount),
+        "HSCAN response"
+      );
+      if (response.length !== 2) throw new Error("FerricStore HSCAN response must contain cursor and items");
+      cursor = integerResponse(response[0], "HSCAN cursor");
+      const values = response[1];
+      if (values instanceof Map) {
+        result.push(...values.entries());
+      } else {
+        const flat = arrayResponse(values, "HSCAN items");
+        if (flat.length % 2 !== 0) throw new Error("FerricStore HSCAN returned an odd item count");
+        for (let index = 0; index < flat.length; index += 2) result.push([flat[index], flat[index + 1]]);
+      }
+    } while (cursor !== 0);
+    return result;
+  }
+  async threadKeys(threadId) {
+    const values = arrayResponse(
+      await this.client.command("SMEMBERS", this.threadCatalogKey(threadId)),
+      "thread checkpoint catalog response"
+    );
+    return values.map((value) => textResponse(value, "thread checkpoint key")).sort();
+  }
+  async checkpointIds(key) {
+    const values = arrayResponse(
+      await this.client.command("ZREVRANGE", this.checkpointIndexKey(key), 0, -1),
+      "checkpoint index response"
+    );
+    return values.map((value) => textResponse(value, "checkpoint ID"));
+  }
+  async collectGlobal(result, beforeId, expectedId, filter, limit) {
+    let offset = 0;
+    while (limit == null || result.length < limit) {
+      const values = arrayResponse(
+        await this.client.command("ZREVRANGE", this.catalogKey(), offset, offset + this.scanCount - 1),
+        "global checkpoint catalog response"
+      );
+      if (values.length === 0) break;
+      for (const value of values) {
+        const { checkpointId: id, threadKey: key } = decodeCheckpointLocator(value);
+        if (expectedId != null && id !== expectedId) continue;
+        if (beforeId != null && id >= beforeId) continue;
+        const record = await this.readRecord(key, id);
+        if (record == null || !metadataMatches(record.metadata, filter)) continue;
+        result.push({ key, record });
+        if (limit != null && result.length >= limit) break;
+      }
+      offset += values.length;
+      if (values.length < this.scanCount) break;
+    }
+  }
+};
+function identity(config) {
+  if (config.configurable == null || typeof config.configurable !== "object") {
+    throw new TypeError("LangGraph config must contain configurable.thread_id");
+  }
+  return {
+    checkpointNs: requiredText(config.configurable.checkpoint_ns ?? "", "checkpoint_ns", true),
+    threadId: requiredText(config.configurable.thread_id, "thread_id")
+  };
+}
+function checkpointId(config) {
+  return optionalText(config.configurable?.checkpoint_id ?? config.configurable?.thread_ts, "checkpoint_id");
+}
+function checkpointConfig(threadId, checkpointNs, id) {
+  return { configurable: { checkpoint_id: id, checkpoint_ns: checkpointNs, thread_id: threadId } };
+}
+function requiredText(value, name, allowEmpty = false) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
+    throw new TypeError(`${name} must be ${allowEmpty ? "text" : "non-empty text"}`);
+  }
+  return value;
+}
+function optionalText(value, name) {
+  if (value == null || value === "") return void 0;
+  return requiredText(value, name);
+}
+function metadataMatches(metadata, filter) {
+  return filter == null || Object.entries(filter).every(([key, value]) => {
+    const actual = Object.getOwnPropertyDescriptor(metadata, key)?.value;
+    return Object.is(actual, value);
+  });
+}
+function checkpointField(id) {
+  return `${CHECKPOINT_FIELD_PREFIX}${encodeComponent(id)}`;
+}
+function writeField(id, taskId, index) {
+  return `${WRITE_FIELD_PREFIX}${encodeComponent(id)}:${encodeComponent(taskId)}:${index}`;
+}
+function encodeComponent(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+function checkpointLocator(id, threadKey) {
+  return Buffer.concat([orderedText(id), Buffer.from(threadKey, "utf8")]);
+}
+function decodeCheckpointLocator(value) {
+  if (!(typeof value === "string" || Buffer.isBuffer(value) || value instanceof Uint8Array)) {
+    throw new TypeError("FerricStore returned a non-binary checkpoint locator");
+  }
+  const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : Buffer.from(value);
+  const decoded = decodeOrderedText(bytes, 0);
+  const threadKey = bytes.subarray(decoded.offset).toString("utf8");
+  if (threadKey.length === 0) throw new Error("FerricStore checkpoint locator has an empty thread key");
+  return { checkpointId: decoded.value, threadKey };
+}
+function orderedText(value) {
+  const output = [];
+  for (const byte of Buffer.from(value, "utf8")) {
+    if (byte === 0) output.push(0, 255);
+    else output.push(byte);
+  }
+  output.push(0, 0);
+  return Buffer.from(output);
+}
+function decodeOrderedText(bytes, start) {
+  const output = [];
+  let offset = start;
+  while (offset < bytes.length) {
+    const byte = bytes[offset];
+    if (byte == null) throw new Error("truncated FerricStore checkpoint locator");
+    offset += 1;
+    if (byte !== 0) {
+      output.push(byte);
+      continue;
+    }
+    const escaped = bytes[offset];
+    offset += 1;
+    if (escaped === 0) return { offset, value: Buffer.from(output).toString("utf8") };
+    if (escaped === 255) output.push(0);
+    else throw new Error("invalid FerricStore checkpoint locator escape");
+  }
+  throw new Error("unterminated FerricStore checkpoint locator");
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function lengthPrefixed(values) {
+  const parts = [];
+  for (const value of values) {
+    const payload = Buffer.from(value, "utf8");
+    const length = Buffer.allocUnsafe(8);
+    length.writeBigUInt64BE(BigInt(payload.length));
+    parts.push(length, payload);
+  }
+  return Buffer.concat(parts);
+}
+function asArguments(values) {
+  return values.map((value) => {
+    if (typeof value === "string" || typeof value === "number" || Buffer.isBuffer(value)) return value;
+    if (value instanceof Uint8Array) return Buffer.from(value);
+    throw new TypeError("FerricStore returned an invalid command argument");
+  });
+}
+
+// src/langgraph/store.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  BaseStore
+} from "@langchain/langgraph";
+var FORMAT_VERSION2 = 1;
+var ITEM_FIELD_PREFIX = "item:";
+var FerricStoreStore = class extends BaseStore {
+  client;
+  keyPrefix;
+  scanCount;
+  lockOptions;
+  constructor(client, options = {}) {
+    super();
+    this.client = client;
+    this.keyPrefix = normalizeKeyPrefix(options.keyPrefix ?? "langgraph:store", "langgraph:store");
+    this.scanCount = positiveInteger(options.scanCount, 256, "scanCount");
+    this.lockOptions = {
+      lockRetryMs: options.lockRetryMs,
+      lockTtlMs: options.lockTtlMs,
+      lockWaitMs: options.lockWaitMs
+    };
+  }
+  async batch(operations) {
+    if (!Array.isArray(operations)) throw new TypeError("operations must be an array");
+    const lockKeys = operations.filter(isPutOperation).map((operation) => {
+      validatePut(operation);
+      return this.itemLockKey(operation.namespace, operation.key);
+    });
+    return await withMutationLocks(this.client, lockKeys, async () => {
+      const results = [];
+      const puts = /* @__PURE__ */ new Map();
+      for (const operation of operations) {
+        if (isPutOperation(operation)) {
+          puts.set(JSON.stringify([operation.namespace, operation.key]), operation);
+          results.push(void 0);
+        } else if (isSearchOperation(operation)) {
+          results.push(await this.searchOperation(operation));
+        } else if (isGetOperation(operation)) {
+          results.push(await this.getOperation(operation));
+        } else if (isListNamespacesOperation(operation)) {
+          results.push(await this.listNamespacesOperation(operation));
+        } else {
+          throw new TypeError("unsupported LangGraph store operation");
+        }
+      }
+      for (const operation of puts.values()) await this.putOperation(operation);
+      return results;
+    }, this.lockOptions);
+  }
+  catalogKey() {
+    return `${this.keyPrefix}:namespaces`;
+  }
+  namespaceKey(namespace) {
+    return `${this.keyPrefix}:{lgs:${sha2562(namespaceIdentity(namespace))}}:namespace`;
+  }
+  itemLockKey(namespace, key) {
+    const keyBytes = Buffer.from(key, "utf8");
+    return `${this.keyPrefix}:{lgsi:${sha2562(Buffer.concat([
+      namespaceIdentity(namespace),
+      uint64(keyBytes.length),
+      keyBytes
+    ]))}}:mutation-lock`;
+  }
+  async getOperation(operation) {
+    validateNamespace(operation.namespace);
+    if (typeof operation.key !== "string") throw new TypeError("store key must be text");
+    const value = await this.client.command(
+      "HGET",
+      this.namespaceKey(operation.namespace),
+      itemField(operation.key)
+    );
+    return value == null ? null : decodeItem(value);
+  }
+  async putOperation(operation) {
+    validatePut(operation);
+    const namespaceKey = this.namespaceKey(operation.namespace);
+    const field = itemField(operation.key);
+    const locator = catalogMember(operation.namespace, operation.key);
+    if (operation.value == null) {
+      await this.client.command("HDEL", namespaceKey, field);
+      await this.client.command("ZREM", this.catalogKey(), locator);
+      return;
+    }
+    const storedValue = snapshotJsonValue(operation.value);
+    const existing = await this.client.command("HGET", namespaceKey, field);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const createdAt = existing == null ? now : decodeItemRecord(existing).createdAt;
+    const record = {
+      createdAt,
+      formatVersion: FORMAT_VERSION2,
+      key: operation.key,
+      namespace: [...operation.namespace],
+      updatedAt: now,
+      value: storedValue
+    };
+    await this.client.command("ZADD", this.catalogKey(), 0, locator);
+    await this.client.command("HSET", namespaceKey, field, encodeItem(record));
+  }
+  async searchOperation(operation) {
+    validateNamespacePrefix(operation.namespacePrefix);
+    if (operation.query != null) {
+      throw new Error(
+        "FerricStoreStore semantic query search is not configured; use metadata filters or a vector-enabled store"
+      );
+    }
+    const limit = normalizePageNumber(operation.limit, 10, "search limit");
+    const offset = normalizePageNumber(operation.offset, 0, "search offset");
+    if (limit === 0) return [];
+    const matches = [];
+    for await (const locator of this.catalogLocators()) {
+      if (!startsWithNamespace(locator.namespace, operation.namespacePrefix)) continue;
+      const item = await this.readCatalogItem(locator.namespace, locator.key);
+      if (item == null || !matchesFilter(item.value, operation.filter)) continue;
+      matches.push(item);
+      if (matches.length >= offset + limit) break;
+    }
+    return matches.slice(offset, offset + limit);
+  }
+  async listNamespacesOperation(operation) {
+    const limit = normalizePageNumber(operation.limit, 100, "namespace limit");
+    const offset = normalizePageNumber(operation.offset, 0, "namespace offset");
+    const maxDepth = operation.maxDepth == null ? void 0 : positiveInteger(operation.maxDepth, operation.maxDepth, "maxDepth");
+    if (limit === 0) return [];
+    const namespaces = /* @__PURE__ */ new Map();
+    for await (const locator of this.catalogLocators()) {
+      const item = await this.readCatalogItem(locator.namespace, locator.key);
+      if (item == null) continue;
+      if (!matchesConditions(item.namespace, operation.matchConditions)) continue;
+      const namespace = maxDepth == null ? item.namespace : item.namespace.slice(0, maxDepth);
+      namespaces.set(JSON.stringify(namespace), namespace);
+    }
+    return [...namespaces.values()].sort(compareNamespaces).slice(offset, offset + limit);
+  }
+  async readCatalogItem(namespace, key) {
+    const value = await this.client.command("HGET", this.namespaceKey(namespace), itemField(key));
+    return value == null ? null : decodeItem(value);
+  }
+  async *catalogLocators() {
+    let offset = 0;
+    while (true) {
+      const values = arrayResponse(
+        await this.client.command("ZRANGE", this.catalogKey(), offset, offset + this.scanCount - 1),
+        "LangGraph store catalog response"
+      );
+      if (values.length === 0) return;
+      for (const value of values) yield decodeCatalogMember(value);
+      offset += values.length;
+      if (values.length < this.scanCount) return;
+    }
+  }
+};
+function isPutOperation(operation) {
+  return "namespace" in operation && "key" in operation && "value" in operation;
+}
+function isGetOperation(operation) {
+  return "namespace" in operation && "key" in operation && !("value" in operation);
+}
+function isSearchOperation(operation) {
+  return "namespacePrefix" in operation;
+}
+function isListNamespacesOperation(operation) {
+  return !("namespace" in operation) && !("namespacePrefix" in operation);
+}
+function validatePut(operation) {
+  validateNamespace(operation.namespace);
+  if (typeof operation.key !== "string") throw new TypeError("store key must be text");
+  if (operation.value == null) return;
+  if (typeof operation.value !== "object" || Array.isArray(operation.value)) {
+    throw new TypeError("LangGraph store values must be JSON objects");
+  }
+  validateJson(operation.value, /* @__PURE__ */ new WeakSet());
+}
+function validateNamespace(namespace) {
+  if (!Array.isArray(namespace) || namespace.length === 0) {
+    throw new Error("namespace cannot be empty");
+  }
+  for (const label of namespace) {
+    if (typeof label !== "string" || label.length === 0 || label.includes(".")) {
+      throw new Error("namespace labels must be non-empty strings without periods");
+    }
+  }
+  if (namespace[0] === "langgraph") throw new Error('root namespace label cannot be "langgraph"');
+}
+function validateNamespacePrefix(namespace) {
+  if (!Array.isArray(namespace)) throw new TypeError("namespacePrefix must be an array");
+  if (namespace.length > 0) validateNamespace(namespace);
+}
+function validateJson(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (value === void 0) throw new TypeError("LangGraph store values must not contain undefined");
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("LangGraph store numbers must be finite");
+    return;
+  }
+  if (typeof value !== "object") throw new TypeError("LangGraph store values must be JSON serializable");
+  if (ancestors.has(value)) throw new TypeError("LangGraph store values must not be cyclic");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const keys = Reflect.ownKeys(value);
+      if (keys.length !== value.length + 1 || keys.some((key) => typeof key !== "string" || key !== "length" && !isArrayIndex(key, value.length))) {
+        throw new TypeError("LangGraph store arrays must not be sparse or customized");
+      }
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor == null || !descriptor.enumerable || !("value" in descriptor)) {
+          throw new TypeError("LangGraph store arrays contain an unsupported item");
+        }
+        validateJson(descriptor.value, ancestors);
+      }
+      return;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("LangGraph store values must contain only JSON objects");
+    }
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key !== "string") throw new TypeError("LangGraph store objects must not have symbol keys");
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor == null || !descriptor.enumerable || !("value" in descriptor)) {
+        throw new TypeError("LangGraph store objects contain an unsupported property");
+      }
+      validateJson(descriptor.value, ancestors);
+    }
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function snapshotJsonValue(value) {
+  validateJson(value, /* @__PURE__ */ new WeakSet());
+  return JSON.parse(JSON.stringify(value));
+}
+function encodeItem(record) {
+  return Buffer.from(JSON.stringify(record), "utf8");
+}
+function decodeItem(value) {
+  const record = decodeItemRecord(value);
+  return {
+    createdAt: new Date(record.createdAt),
+    key: record.key,
+    namespace: [...record.namespace],
+    updatedAt: new Date(record.updatedAt),
+    value: record.value
+  };
+}
+function decodeItemRecord(value) {
+  if (!(typeof value === "string" || Buffer.isBuffer(value) || value instanceof Uint8Array)) {
+    throw new TypeError("FerricStore returned a non-binary LangGraph store item");
+  }
+  const text = typeof value === "string" ? value : Buffer.from(value).toString("utf8");
+  let record;
+  try {
+    record = JSON.parse(text);
+  } catch (error) {
+    throw new Error("invalid FerricStore LangGraph store item", { cause: error });
+  }
+  if (record == null || typeof record !== "object" || record.formatVersion !== FORMAT_VERSION2 || typeof record.key !== "string" || !Array.isArray(record.namespace) || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string" || record.value == null || typeof record.value !== "object") {
+    throw new Error("unsupported or corrupt FerricStore LangGraph store item");
+  }
+  return record;
+}
+function matchesFilter(value, filter) {
+  return filter == null || Object.entries(filter).every(([key, expected]) => compareValue(value[key], expected));
+}
+function compareValue(value, expected) {
+  if (expected != null && typeof expected === "object" && !Array.isArray(expected)) {
+    const entries = Object.entries(expected);
+    if (entries.length > 0 && entries.every(([key]) => FILTER_OPERATORS.has(key))) {
+      return entries.every(([operator, operand]) => applyOperator(value, operator, operand));
+    }
+    return value != null && typeof value === "object" && !Array.isArray(value) && entries.every(([key, nested]) => compareValue(value[key], nested));
+  }
+  if (Array.isArray(expected)) {
+    return Array.isArray(value) && value.length === expected.length && value.every((item, index) => compareValue(item, expected[index]));
+  }
+  return Object.is(value, expected);
+}
+function applyOperator(value, operator, expected) {
+  switch (operator) {
+    case "$eq":
+      return Object.is(value, expected);
+    case "$ne":
+      return !Object.is(value, expected);
+    case "$gt":
+      return comparable(value, expected, (left, right) => left > right);
+    case "$gte":
+      return comparable(value, expected, (left, right) => left >= right);
+    case "$in":
+      return Array.isArray(expected) && expected.some((item) => Object.is(item, value));
+    case "$lt":
+      return comparable(value, expected, (left, right) => left < right);
+    case "$lte":
+      return comparable(value, expected, (left, right) => left <= right);
+    case "$nin":
+      return !Array.isArray(expected) || expected.every((item) => !Object.is(item, value));
+    default:
+      throw new Error(`unsupported filter operator: ${operator}`);
+  }
+}
+function comparable(value, expected, compare) {
+  try {
+    return compare(Number(value), Number(expected));
+  } catch {
+    return false;
+  }
+}
+var FILTER_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$gt", "$gte", "$in", "$lt", "$lte", "$ne", "$nin"]);
+function matchesConditions(namespace, conditions) {
+  return conditions == null || conditions.every((condition) => {
+    if (namespace.length < condition.path.length) return false;
+    const actual = condition.matchType === "prefix" ? namespace : [...namespace].reverse();
+    const pattern = condition.matchType === "prefix" ? condition.path : [...condition.path].reverse();
+    return pattern.every((component, index) => component === "*" || actual[index] === component);
+  });
+}
+function startsWithNamespace(namespace, prefix) {
+  return prefix.length <= namespace.length && prefix.every((value, index) => namespace[index] === value);
+}
+function normalizePageNumber(value, fallback, name) {
+  const normalized = value ?? fallback;
+  if (!Number.isSafeInteger(normalized) || normalized < 0) {
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  }
+  return normalized;
+}
+function compareNamespaces(left, right) {
+  const count = Math.min(left.length, right.length);
+  for (let index = 0; index < count; index += 1) {
+    const compared = (left[index] ?? "").localeCompare(right[index] ?? "");
+    if (compared !== 0) return compared;
+  }
+  return left.length - right.length;
+}
+function itemField(key) {
+  return `${ITEM_FIELD_PREFIX}${Buffer.from(key, "utf8").toString("base64url")}`;
+}
+function namespaceIdentity(namespace) {
+  return Buffer.concat(namespace.flatMap((component) => {
+    const payload = Buffer.from(component, "utf8");
+    return [uint64(payload.length), payload];
+  }));
+}
+function catalogMember(namespace, key) {
+  return Buffer.concat([
+    ...namespace.map(orderedText2),
+    Buffer.from([0, 0]),
+    orderedText2(key)
+  ]);
+}
+function decodeCatalogMember(value) {
+  if (!(typeof value === "string" || Buffer.isBuffer(value) || value instanceof Uint8Array)) {
+    throw new TypeError("FerricStore returned a non-binary LangGraph store locator");
+  }
+  const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : Buffer.from(value);
+  const namespace = [];
+  let offset = 0;
+  while (true) {
+    if (bytes[offset] === 0 && bytes[offset + 1] === 0) {
+      offset += 2;
+      break;
+    }
+    const decoded = decodeOrderedText2(bytes, offset);
+    namespace.push(decoded.value);
+    offset = decoded.offset;
+  }
+  const key = decodeOrderedText2(bytes, offset);
+  if (key.offset !== bytes.length || namespace.length === 0) {
+    throw new Error("invalid FerricStore LangGraph store locator");
+  }
+  return { key: key.value, namespace };
+}
+function orderedText2(value) {
+  const output = [];
+  for (const byte of Buffer.from(value, "utf8")) {
+    if (byte === 0) output.push(0, 255);
+    else output.push(byte);
+  }
+  output.push(0, 0);
+  return Buffer.from(output);
+}
+function decodeOrderedText2(bytes, start) {
+  const output = [];
+  let offset = start;
+  while (offset < bytes.length) {
+    const byte = bytes[offset];
+    if (byte == null) throw new Error("truncated FerricStore LangGraph store locator");
+    offset += 1;
+    if (byte !== 0) {
+      output.push(byte);
+      continue;
+    }
+    const escaped = bytes[offset];
+    offset += 1;
+    if (escaped === 0) return { offset, value: Buffer.from(output).toString("utf8") };
+    if (escaped === 255) output.push(0);
+    else throw new Error("invalid FerricStore LangGraph store locator escape");
+  }
+  throw new Error("unterminated FerricStore LangGraph store locator");
+}
+function uint64(value) {
+  const result = Buffer.allocUnsafe(8);
+  result.writeBigUInt64BE(BigInt(value));
+  return result;
+}
+function sha2562(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function isArrayIndex(key, length) {
+  if (!/^(?:0|[1-9]\d*)$/u.test(key)) return false;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0 && index < length;
+}
+
+// src/langgraph/flow.ts
+import { createHash as createHash3 } from "crypto";
+import { Command } from "@langchain/langgraph";
+
+// src/outcomes.ts
+var OUTCOME_BRAND = /* @__PURE__ */ Symbol("ferricstore.outcome");
+function transition(toState, options = {}) {
+  return brandOutcome({ ...options, kind: "transition", toState });
+}
+function complete(options = {}) {
+  return brandOutcome({ ...options, kind: "complete" });
+}
+function fail(options = {}) {
+  return brandOutcome({ ...options, kind: "fail" });
+}
+function brandOutcome(outcome) {
+  Object.defineProperty(outcome, "kind", {
+    configurable: false,
+    enumerable: true,
+    value: outcome.kind,
+    writable: false
+  });
+  if (outcome.kind === "transition") {
+    Object.defineProperty(outcome, "toState", {
+      configurable: false,
+      enumerable: true,
+      value: outcome.toState,
+      writable: false
+    });
+  }
+  Object.defineProperty(outcome, OUTCOME_BRAND, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+  return outcome;
+}
+
+// src/langgraph/flow.ts
+var LangGraphFlowContext = class {
+  flow;
+  threadId;
+  checkpointNs;
+  constructor(flow, threadId, checkpointNs) {
+    this.flow = flow;
+    this.threadId = threadId;
+    this.checkpointNs = checkpointNs;
+  }
+  get id() {
+    return this.flow.id;
+  }
+  get type() {
+    return this.flow.type;
+  }
+  get state() {
+    return this.flow.state;
+  }
+  get partitionKey() {
+    return this.flow.partitionKey;
+  }
+  get payload() {
+    return this.flow.payload;
+  }
+  get values() {
+    return this.flow.values;
+  }
+};
+var LangGraphFlowRun = class {
+  value;
+  threadId;
+  checkpointNs;
+  interrupts;
+  constructor(value, threadId, checkpointNs, interrupts2) {
+    this.value = value;
+    this.threadId = threadId;
+    this.checkpointNs = checkpointNs;
+    this.interrupts = interrupts2;
+  }
+  get interrupted() {
+    return this.interrupts.length > 0;
+  }
+  get interruptValues() {
+    return this.interrupts.map((item) => item != null && typeof item === "object" && "value" in item ? item.value : item);
+  }
+};
+var LangGraphFlow = class {
+  graph;
+  options;
+  constructor(graph, options = {}) {
+    if (options.onInterrupt != null && options.interruptState != null) {
+      throw new TypeError("onInterrupt and interruptState are mutually exclusive");
+    }
+    if (options.interruptState != null) requireText(options.interruptState, "interruptState");
+    this.graph = graph;
+    this.options = { ...options };
+  }
+  async config(flow, graphContext) {
+    const additional = await this.options.config?.(flow) ?? {};
+    const rawConfigurable = additional.configurable ?? {};
+    if (rawConfigurable == null || typeof rawConfigurable !== "object" || Array.isArray(rawConfigurable)) {
+      throw new TypeError("LangGraph config configurable must be an object");
+    }
+    const rawMetadata = additional.metadata ?? {};
+    if (rawMetadata == null || typeof rawMetadata !== "object" || Array.isArray(rawMetadata)) {
+      throw new TypeError("LangGraph config metadata must be an object");
+    }
+    const threadId = requireText(
+      await (this.options.threadId?.(flow) ?? defaultThreadId(flow)),
+      "threadId"
+    );
+    const checkpointNsOption = this.options.checkpointNs ?? "";
+    const checkpointNs = requireText(
+      await (typeof checkpointNsOption === "function" ? checkpointNsOption(flow) : checkpointNsOption),
+      "checkpointNs",
+      true
+    );
+    const context = graphContext === void 0 ? this.options.context == null ? new LangGraphFlowContext(flow, threadId, checkpointNs) : await this.options.context(flow) : graphContext;
+    return {
+      ...this.options.invokeOptions,
+      ...additional,
+      configurable: { ...rawConfigurable, checkpoint_ns: checkpointNs, thread_id: threadId },
+      context,
+      metadata: {
+        ...rawMetadata,
+        ferricflow_id: flow.id,
+        ferricflow_state: flow.logicalState,
+        ferricflow_type: flow.type
+      }
+    };
+  }
+  async invoke(flow, graphInput, graphContext) {
+    const config = await this.config(flow, graphContext);
+    let input = graphInput;
+    if (input === void 0) {
+      let hasCheckpoint = false;
+      if ((this.options.recoverExisting ?? true) && this.graph.getState != null) {
+        hasCheckpoint = snapshotHasCheckpoint(await this.graph.getState(config));
+      }
+      input = hasCheckpoint ? null : await (this.options.input?.(flow) ?? flow.payload);
+    }
+    const value = await this.graph.invoke(input, config);
+    const configurable = config.configurable;
+    return new LangGraphFlowRun(
+      value,
+      requireText(configurable?.thread_id, "thread_id"),
+      requireText(configurable?.checkpoint_ns ?? "", "checkpoint_ns", true),
+      interrupts(value)
+    );
+  }
+  async outcome(run, flow) {
+    const mapper = run.interrupted ? this.options.onInterrupt : this.options.onComplete;
+    if (mapper != null) return await mapper(run, flow);
+    const stateMeta = {
+      langgraph_checkpoint_ns: run.checkpointNs,
+      langgraph_interrupt_count: run.interrupts.length,
+      langgraph_interrupted: run.interrupted,
+      langgraph_thread_id: run.threadId
+    };
+    if (!run.interrupted) return complete({ result: run.value, stateMeta });
+    if (this.options.interruptState != null) {
+      return transition(this.options.interruptState, { stateMeta });
+    }
+    return fail({
+      error: {
+        checkpointNs: run.checkpointNs,
+        interruptCount: run.interrupts.length,
+        threadId: run.threadId,
+        type: "unhandled_langgraph_interrupt"
+      },
+      stateMeta
+    });
+  }
+  async handle(flow, graphInput, graphContext) {
+    return await this.outcome(await this.invoke(flow, graphInput, graphContext), flow);
+  }
+  async resume(flow, value, graphContext) {
+    return await this.handle(flow, new Command({ resume: value }), graphContext);
+  }
+  async handler(flow) {
+    return await this.handle(flow);
+  }
+};
+function interrupts(value) {
+  if (value == null || typeof value !== "object" || !("__interrupt__" in value)) return [];
+  const raw = value.__interrupt__;
+  if (raw == null) return [];
+  return Array.isArray(raw) ? raw : [raw];
+}
+function snapshotHasCheckpoint(snapshot) {
+  if (snapshot == null || typeof snapshot !== "object") return false;
+  const value = snapshot;
+  if (value.config != null && typeof value.config === "object") {
+    const configurable = value.config.configurable;
+    if (configurable != null && typeof configurable === "object" && typeof configurable.checkpoint_id === "string") return true;
+  }
+  return value.createdAt != null || value.metadata != null;
+}
+function defaultThreadId(flow) {
+  const identity2 = Buffer.concat([
+    identityComponent(flow.type),
+    identityComponent(flow.partitionKey),
+    identityComponent(flow.id)
+  ]);
+  return `ferricflow:${createHash3("sha256").update(identity2).digest("hex")}`;
+}
+function identityComponent(value) {
+  if (value == null) return Buffer.concat([Buffer.from("n"), uint642(0)]);
+  const payload = Buffer.from(value, "utf8");
+  return Buffer.concat([Buffer.from("s"), uint642(payload.length), payload]);
+}
+function uint642(value) {
+  const result = Buffer.allocUnsafe(8);
+  result.writeBigUInt64BE(BigInt(value));
+  return result;
+}
+function requireText(value, name, allowEmpty = false) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0 || value.includes("\0")) {
+    throw new TypeError(`${name} must be ${allowEmpty ? "text" : "non-empty text"} without NUL bytes`);
+  }
+  return value;
+}
+export {
+  FerricStoreSaver,
+  FerricStoreStore,
+  LangGraphFlow,
+  LangGraphFlowContext,
+  LangGraphFlowRun
+};
+//# sourceMappingURL=langgraph.js.map