@langchain/langgraph 1.3.7 → 1.4.0

package/dist/channels/base.cjs

@@ -1,6 +1,14 @@
+const require_constants = require("../constants.cjs");
 const require_errors = require("../errors.cjs");
 let _langchain_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
 //#region src/channels/base.ts
+/**
+* Structural check for a {@link DeltaChannel} without importing it (avoids an
+* import cycle: `delta.ts` imports `base.ts`).
+*/
+function isDeltaChannel(channel) {
+	return channel != null && channel.lc_graph_name === "DeltaChannel";
+}
 function isBaseChannel(obj) {
 	return obj != null && obj.lg_is_channel === true;
 }
@@ -78,15 +86,45 @@ function emptyChannels(channels, checkpoint) {
 	Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });
 	return newChannels;
 }
+/**
+* Return the set of {@link DeltaChannel} names that should snapshot now.
+*
+* A channel snapshots when EITHER its accumulated update count reaches
+* `snapshotFrequency` OR the total supersteps since its last snapshot reaches
+* `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT`. Pure predicate — no mutation.
+*/
+function deltaChannelsToSnapshot(channels, countersSinceDeltaSnapshot) {
+	const result = /* @__PURE__ */ new Set();
+	const maxSupersteps = require_constants.getDeltaMaxSuperstepsSinceSnapshot();
+	for (const name in channels) {
+		if (!Object.prototype.hasOwnProperty.call(channels, name)) continue;
+		const ch = channels[name];
+		if (!isDeltaChannel(ch) || !ch.isAvailable()) continue;
+		const [updates, supersteps] = countersSinceDeltaSnapshot[name] ?? [0, 0];
+		if (updates >= ch.snapshotFrequency || supersteps >= maxSupersteps) result.add(name);
+	}
+	return result;
+}
 function createCheckpoint(checkpoint, channels, step, options) {
+	const channelsToSnapshot = options?.channelsToSnapshot ?? /* @__PURE__ */ new Set();
+	const { updatedChannels, getNextVersion } = options ?? {};
 	let values;
+	let channelVersions = checkpoint.channel_versions;
 	if (channels === void 0) values = checkpoint.channel_values;
 	else {
 		values = {};
+		channelVersions = { ...checkpoint.channel_versions };
 		for (const k in channels) {
 			if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;
+			const channel = channels[k];
+			if (channelsToSnapshot.has(k)) {
+				if (getNextVersion !== void 0 && (updatedChannels === void 0 || !updatedChannels.has(k))) channelVersions[k] = getNextVersion(channelVersions[k]);
+				values[k] = new _langchain_langgraph_checkpoint.DeltaSnapshot(channel.get());
+				continue;
+			}
+			if (isDeltaChannel(channel)) continue;
 			try {
-				values[k] = channels[k].checkpoint();
+				values[k] = channel.checkpoint();
 			} catch (error) {
 				if (error.name === require_errors.EmptyChannelError.unminifiable_name) {} else throw error;
 			}
@@ -97,15 +135,53 @@ function createCheckpoint(checkpoint, channels, step, options) {
 		id: options?.id ?? (0, _langchain_langgraph_checkpoint.uuid6)(step),
 		ts: (/* @__PURE__ */ new Date()).toISOString(),
 		channel_values: values,
-		channel_versions: checkpoint.channel_versions,
+		channel_versions: channelVersions,
 		versions_seen: checkpoint.versions_seen
 	};
 }
+/**
+* Hydrate channels from a checkpoint, reconstructing any {@link DeltaChannel}
+* whose value is absent from `channel_values` by replaying ancestor writes.
+*
+* For most channels (and for delta channels with a {@link DeltaSnapshot} or a
+* migrated plain value in `channel_values`), {@link emptyChannels} is
+* sufficient and no saver access is required. When a delta channel is absent
+* from `channel_values`, an ancestor walk via `saver.getDeltaChannelHistory`
+* finds the nearest seed and accumulates the writes between it and the
+* target. All delta channels needing replay are batched into a single saver
+* call.
+*/
+async function channelsFromCheckpoint(specs, checkpoint, options) {
+	const channels = emptyChannels(specs, checkpoint);
+	const { saver, config } = options ?? {};
+	const filteredSpecs = getOnlyChannels(specs);
+	const deltaKeys = [];
+	for (const k in filteredSpecs) {
+		if (!Object.prototype.hasOwnProperty.call(filteredSpecs, k)) continue;
+		if (isDeltaChannel(filteredSpecs[k]) && !Object.prototype.hasOwnProperty.call(checkpoint.channel_values, k)) deltaKeys.push(k);
+	}
+	if (deltaKeys.length === 0 || saver === void 0 || config === void 0) return channels;
+	const histories = await saver.getDeltaChannelHistory({
+		config,
+		channels: deltaKeys
+	});
+	for (const k of deltaKeys) {
+		const history = histories[k];
+		if (history === void 0) continue;
+		const replayCh = filteredSpecs[k].fromCheckpoint(history.seed);
+		replayCh.replayWrites(history.writes);
+		channels[k] = replayCh;
+	}
+	return channels;
+}
 //#endregion
 exports.BaseChannel = BaseChannel;
+exports.channelsFromCheckpoint = channelsFromCheckpoint;
 exports.createCheckpoint = createCheckpoint;
+exports.deltaChannelsToSnapshot = deltaChannelsToSnapshot;
 exports.emptyChannels = emptyChannels;
 exports.getOnlyChannels = getOnlyChannels;
 exports.isBaseChannel = isBaseChannel;
+exports.isDeltaChannel = isDeltaChannel;
 
 //# sourceMappingURL=base.cjs.map

package/dist/channels/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["EmptyChannelError"],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n} from \"@langchain/langgraph-checkpoint\";\nimport { EmptyChannelError } from \"../errors.js\";\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown,\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Used to determine if two channels with the same key are semantically equivalent.\n   * Subclasses should override this method to provide a meaningful comparison.\n   *\n   * @param {BaseChannel} other - The other channel to compare with.\n   * @returns {boolean} True if the channels are equal, false otherwise.\n   */\n  equals(other: BaseChannel): boolean {\n    return this === other;\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: { id?: string }\n): Checkpoint {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      try {\n        values[k] = channels[k].checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: checkpoint.channel_versions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n"],"mappings":";;;AAOA,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAASA,eAAAA,kBAAkB,kBACnC,QAAO;AAET,SAAM;;;;;;;;;;;CAYV,OAAO,OAA6B;AAClC,SAAO,SAAS;;;AAIpB,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAI;AACJ,KAAI,aAAa,KAAA,EACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG,YAAY;YAE7B,OAAY;AACnB,QAAI,MAAM,SAASA,eAAAA,kBAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,OAAA,GAAA,gCAAA,OAAY,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}
+{"version":3,"file":"base.cjs","names":["EmptyChannelError","getDeltaMaxSuperstepsSinceSnapshot","DeltaSnapshot"],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n  DeltaSnapshot,\n  type BaseCheckpointSaver,\n  type DeltaChannelHistory,\n} from \"@langchain/langgraph-checkpoint\";\nimport type { RunnableConfig } from \"@langchain/core/runnables\";\nimport { EmptyChannelError } from \"../errors.js\";\nimport { getDeltaMaxSuperstepsSinceSnapshot } from \"../constants.js\";\n\n/**\n * Structural check for a {@link DeltaChannel} without importing it (avoids an\n * import cycle: `delta.ts` imports `base.ts`).\n */\nexport function isDeltaChannel(channel: BaseChannel): boolean {\n  return channel != null && channel.lc_graph_name === \"DeltaChannel\";\n}\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown,\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Used to determine if two channels with the same key are semantically equivalent.\n   * Subclasses should override this method to provide a meaningful comparison.\n   *\n   * @param {BaseChannel} other - The other channel to compare with.\n   * @returns {boolean} True if the channels are equal, false otherwise.\n   */\n  equals(other: BaseChannel): boolean {\n    return this === other;\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\n/**\n * Minimal structural view of a {@link DeltaChannel}, used by helpers in this\n * module that must not import the concrete class (import-cycle avoidance).\n */\ninterface DeltaChannelLike extends BaseChannel {\n  snapshotFrequency: number;\n  replayWrites(writes: DeltaChannelHistory[\"writes\"]): void;\n}\n\n/**\n * Return the set of {@link DeltaChannel} names that should snapshot now.\n *\n * A channel snapshots when EITHER its accumulated update count reaches\n * `snapshotFrequency` OR the total supersteps since its last snapshot reaches\n * `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT`. Pure predicate — no mutation.\n */\nexport function deltaChannelsToSnapshot(\n  channels: Record<string, BaseChannel>,\n  countersSinceDeltaSnapshot: Record<string, [number, number]>\n): Set<string> {\n  const result = new Set<string>();\n  const maxSupersteps = getDeltaMaxSuperstepsSinceSnapshot();\n  for (const name in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, name)) continue;\n    const ch = channels[name];\n    if (!isDeltaChannel(ch) || !ch.isAvailable()) continue;\n    const [updates, supersteps] = countersSinceDeltaSnapshot[name] ?? [0, 0];\n    if (\n      updates >= (ch as DeltaChannelLike).snapshotFrequency ||\n      supersteps >= maxSupersteps\n    ) {\n      result.add(name);\n    }\n  }\n  return result;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: {\n    id?: string;\n    channelsToSnapshot?: Set<string>;\n    updatedChannels?: Set<string>;\n    getNextVersion?: (current: number | string | undefined) => number | string;\n  }\n): Checkpoint {\n  const channelsToSnapshot = options?.channelsToSnapshot ?? new Set<string>();\n  const { updatedChannels, getNextVersion } = options ?? {};\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  let channelVersions: Record<string, number | string> =\n    checkpoint.channel_versions;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    channelVersions = { ...checkpoint.channel_versions };\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      const channel = channels[k];\n      if (channelsToSnapshot.has(k)) {\n        // Snapshot a DeltaChannel: store the materialized value directly. In\n        // exit/deferred modes the channel may have reached its snapshot\n        // threshold over several supersteps without the LAST superstep\n        // writing to it, so its version wouldn't be bumped by applyWrites —\n        // bump it here so the saver includes the snapshot blob.\n        if (\n          getNextVersion !== undefined &&\n          (updatedChannels === undefined || !updatedChannels.has(k))\n        ) {\n          channelVersions[k] = getNextVersion(channelVersions[k]);\n        }\n        values[k] = new DeltaSnapshot(channel.get());\n        continue;\n      }\n      if (isDeltaChannel(channel)) {\n        // Omitted from channel_values; reconstructed from ancestor writes.\n        continue;\n      }\n      try {\n        values[k] = channel.checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: channelVersions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n\n/**\n * Hydrate channels from a checkpoint, reconstructing any {@link DeltaChannel}\n * whose value is absent from `channel_values` by replaying ancestor writes.\n *\n * For most channels (and for delta channels with a {@link DeltaSnapshot} or a\n * migrated plain value in `channel_values`), {@link emptyChannels} is\n * sufficient and no saver access is required. When a delta channel is absent\n * from `channel_values`, an ancestor walk via `saver.getDeltaChannelHistory`\n * finds the nearest seed and accumulates the writes between it and the\n * target. All delta channels needing replay are batched into a single saver\n * call.\n */\nexport async function channelsFromCheckpoint<\n  Cc extends Record<string, BaseChannel>,\n>(\n  specs: Cc,\n  checkpoint: ReadonlyCheckpoint,\n  options?: { saver?: BaseCheckpointSaver; config?: RunnableConfig }\n): Promise<Cc> {\n  const channels = emptyChannels(specs, checkpoint);\n  const { saver, config } = options ?? {};\n\n  const filteredSpecs = getOnlyChannels(specs);\n  const deltaKeys: string[] = [];\n  for (const k in filteredSpecs) {\n    if (!Object.prototype.hasOwnProperty.call(filteredSpecs, k)) continue;\n    if (\n      isDeltaChannel(filteredSpecs[k]) &&\n      !Object.prototype.hasOwnProperty.call(checkpoint.channel_values, k)\n    ) {\n      deltaKeys.push(k);\n    }\n  }\n\n  if (deltaKeys.length === 0 || saver === undefined || config === undefined) {\n    return channels;\n  }\n\n  const histories = await saver.getDeltaChannelHistory({\n    config,\n    channels: deltaKeys,\n  });\n  for (const k of deltaKeys) {\n    const history = histories[k];\n    if (history === undefined) continue;\n    const replayCh = filteredSpecs[k].fromCheckpoint(\n      history.seed\n    ) as unknown as DeltaChannelLike;\n    replayCh.replayWrites(history.writes);\n    (channels as Record<string, BaseChannel>)[k] = replayCh;\n  }\n  return channels;\n}\n"],"mappings":"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"}

package/dist/channels/base.d.cts

@@ -1,6 +1,12 @@
-import { Checkpoint, ReadonlyCheckpoint } from "@langchain/langgraph-checkpoint";
+import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint } from "@langchain/langgraph-checkpoint";
+import { RunnableConfig } from "@langchain/core/runnables";
 
 //#region src/channels/base.d.ts
+/**
+ * Structural check for a {@link DeltaChannel} without importing it (avoids an
+ * import cycle: `delta.ts` imports `base.ts`).
+ */
+declare function isDeltaChannel(channel: BaseChannel): boolean;
 /** @internal */
 declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {
   ValueType: ValueType;
@@ -80,9 +86,36 @@ declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, Ch
   equals(other: BaseChannel): boolean;
 }
 declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;
+/**
+ * Return the set of {@link DeltaChannel} names that should snapshot now.
+ *
+ * A channel snapshots when EITHER its accumulated update count reaches
+ * `snapshotFrequency` OR the total supersteps since its last snapshot reaches
+ * `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT`. Pure predicate — no mutation.
+ */
+declare function deltaChannelsToSnapshot(channels: Record<string, BaseChannel>, countersSinceDeltaSnapshot: Record<string, [number, number]>): Set<string>;
 declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {
   id?: string;
+  channelsToSnapshot?: Set<string>;
+  updatedChannels?: Set<string>;
+  getNextVersion?: (current: number | string | undefined) => number | string;
 }): Checkpoint;
+/**
+ * Hydrate channels from a checkpoint, reconstructing any {@link DeltaChannel}
+ * whose value is absent from `channel_values` by replaying ancestor writes.
+ *
+ * For most channels (and for delta channels with a {@link DeltaSnapshot} or a
+ * migrated plain value in `channel_values`), {@link emptyChannels} is
+ * sufficient and no saver access is required. When a delta channel is absent
+ * from `channel_values`, an ancestor walk via `saver.getDeltaChannelHistory`
+ * finds the nearest seed and accumulates the writes between it and the
+ * target. All delta channels needing replay are batched into a single saver
+ * call.
+ */
+declare function channelsFromCheckpoint<Cc extends Record<string, BaseChannel>>(specs: Cc, checkpoint: ReadonlyCheckpoint, options?: {
+  saver?: BaseCheckpointSaver;
+  config?: RunnableConfig;
+}): Promise<Cc>;
 //#endregion
-export { BaseChannel, createCheckpoint, emptyChannels };
+export { BaseChannel, channelsFromCheckpoint, createCheckpoint, deltaChannelsToSnapshot, emptyChannels, isDeltaChannel };
 //# sourceMappingURL=base.d.cts.map

package/dist/channels/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/channels/base.ts"],"mappings":";;;;uBAYsB,WAAA;EAKpB,SAAA,EAAW,SAAA;EAEX,UAAA,EAAY,UAAA;EAFD;;;EAAA,SAOF,aAAA;EAoCO;EAjChB,aAAA;EA0Fc;;;;;;;;EAAA,SAhFL,cAAA,CAAe,UAAA,GAAa,cAAA;EAlBzB;;;;;;;;;;;;;EAAA,SAiCH,MAAA,CAAO,MAAA,EAAQ,UAAA;EAmCxB;;;;;;EAAA,SA3BS,GAAA,CAAA,GAAO,SAAA;EAgFF;;;;;;EAAA,SAxEL,UAAA,CAAA,GAAc,cAAA;EA2EtB;;;;;;;EAlED,OAAA,CAAA;EAiEY;;;;;AAcd;EArEE,MAAA,CAAA;EAqE8B;;;;;EA5D9B,WAAA,CAAA;EAiEW;;;;;;;;EA5CX,MAAA,CAAO,KAAA,EAAO,WAAA;AAAA;AAAA,iBAuBA,aAAA,YAAyB,MAAA,SAAe,WAAA,EAAA,CACtD,QAAA,EAAU,EAAA,EACV,UAAA,EAAY,kBAAA,GACX,EAAA;AAAA,iBAaa,gBAAA,WAAA,CACd,UAAA,EAAY,kBAAA,EACZ,QAAA,EAAU,MAAA,SAAe,WAAA,CAAY,SAAA,gBACrC,IAAA,UACA,OAAA;EAAY,EAAA;AAAA,IACX,UAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/channels/base.ts"],"mappings":";;;;;;AAgBA;;iBAAgB,cAAA,CAAe,OAAA,EAAS,WAAA;;uBASlB,WAAA;EAKpB,SAAA,EAAW,SAAA;EAEX,UAAA,EAAY,UAAA;EAFD;;;EAAA,SAOF,aAAA;EAoCO;EAjChB,aAAA;EA0Fc;;;;;;;;EAAA,SAhFL,cAAA,CAAe,UAAA,GAAa,cAAA;EAlBzB;;;;;;;;;;;;;EAAA,SAiCH,MAAA,CAAO,MAAA,EAAQ,UAAA;EAmCxB;;;;;;EAAA,SA3BS,GAAA,CAAA,GAAO,SAAA;EAgFF;;;;;;EAAA,SAxEL,UAAA,CAAA,GAAc,cAAA;EA2EtB;;;;;;;EAlED,OAAA,CAAA;EAiEY;;;;;AA8Bd;EArFE,MAAA,CAAA;;;;;;EASA,WAAA,CAAA;EA+EI;;;;;;;;EA1DJ,MAAA,CAAO,KAAA,EAAO,WAAA;AAAA;AAAA,iBAuBA,aAAA,YAAyB,MAAA,SAAe,WAAA,EAAA,CACtD,QAAA,EAAU,EAAA,EACV,UAAA,EAAY,kBAAA,GACX,EAAA;;;;;;;;iBA6Ba,uBAAA,CACd,QAAA,EAAU,MAAA,SAAe,WAAA,GACzB,0BAAA,EAA4B,MAAA,6BAC3B,GAAA;AAAA,iBAkBa,gBAAA,WAAA,CACd,UAAA,EAAY,kBAAA,EACZ,QAAA,EAAU,MAAA,SAAe,WAAA,CAAY,SAAA,gBACrC,IAAA,UACA,OAAA;EACE,EAAA;EACA,kBAAA,GAAqB,GAAA;EACrB,eAAA,GAAkB,GAAA;EAClB,cAAA,IAAkB,OAAA;AAAA,IAEnB,UAAA;;;;;;;;;;;;;iBAqEmB,sBAAA,YACT,MAAA,SAAe,WAAA,EAAA,CAE1B,KAAA,EAAO,EAAA,EACP,UAAA,EAAY,kBAAA,EACZ,OAAA;EAAY,KAAA,GAAQ,mBAAA;EAAqB,MAAA,GAAS,cAAA;AAAA,IACjD,OAAA,CAAQ,EAAA"}

package/dist/channels/base.d.ts

@@ -1,6 +1,12 @@
-import { Checkpoint, ReadonlyCheckpoint } from "@langchain/langgraph-checkpoint";
+import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint } from "@langchain/langgraph-checkpoint";
+import { RunnableConfig } from "@langchain/core/runnables";
 
 //#region src/channels/base.d.ts
+/**
+ * Structural check for a {@link DeltaChannel} without importing it (avoids an
+ * import cycle: `delta.ts` imports `base.ts`).
+ */
+declare function isDeltaChannel(channel: BaseChannel): boolean;
 /** @internal */
 declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {
   ValueType: ValueType;
@@ -80,9 +86,36 @@ declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, Ch
   equals(other: BaseChannel): boolean;
 }
 declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;
+/**
+ * Return the set of {@link DeltaChannel} names that should snapshot now.
+ *
+ * A channel snapshots when EITHER its accumulated update count reaches
+ * `snapshotFrequency` OR the total supersteps since its last snapshot reaches
+ * `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT`. Pure predicate — no mutation.
+ */
+declare function deltaChannelsToSnapshot(channels: Record<string, BaseChannel>, countersSinceDeltaSnapshot: Record<string, [number, number]>): Set<string>;
 declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {
   id?: string;
+  channelsToSnapshot?: Set<string>;
+  updatedChannels?: Set<string>;
+  getNextVersion?: (current: number | string | undefined) => number | string;
 }): Checkpoint;
+/**
+ * Hydrate channels from a checkpoint, reconstructing any {@link DeltaChannel}
+ * whose value is absent from `channel_values` by replaying ancestor writes.
+ *
+ * For most channels (and for delta channels with a {@link DeltaSnapshot} or a
+ * migrated plain value in `channel_values`), {@link emptyChannels} is
+ * sufficient and no saver access is required. When a delta channel is absent
+ * from `channel_values`, an ancestor walk via `saver.getDeltaChannelHistory`
+ * finds the nearest seed and accumulates the writes between it and the
+ * target. All delta channels needing replay are batched into a single saver
+ * call.
+ */
+declare function channelsFromCheckpoint<Cc extends Record<string, BaseChannel>>(specs: Cc, checkpoint: ReadonlyCheckpoint, options?: {
+  saver?: BaseCheckpointSaver;
+  config?: RunnableConfig;
+}): Promise<Cc>;
 //#endregion
-export { BaseChannel, createCheckpoint, emptyChannels };
+export { BaseChannel, channelsFromCheckpoint, createCheckpoint, deltaChannelsToSnapshot, emptyChannels, isDeltaChannel };
 //# sourceMappingURL=base.d.ts.map

package/dist/channels/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/channels/base.ts"],"mappings":";;;;uBAYsB,WAAA;EAKpB,SAAA,EAAW,SAAA;EAEX,UAAA,EAAY,UAAA;EAFD;;;EAAA,SAOF,aAAA;EAoCO;EAjChB,aAAA;EA0Fc;;;;;;;;EAAA,SAhFL,cAAA,CAAe,UAAA,GAAa,cAAA;EAlBzB;;;;;;;;;;;;;EAAA,SAiCH,MAAA,CAAO,MAAA,EAAQ,UAAA;EAmCxB;;;;;;EAAA,SA3BS,GAAA,CAAA,GAAO,SAAA;EAgFF;;;;;;EAAA,SAxEL,UAAA,CAAA,GAAc,cAAA;EA2EtB;;;;;;;EAlED,OAAA,CAAA;EAiEY;;;;;AAcd;EArEE,MAAA,CAAA;EAqE8B;;;;;EA5D9B,WAAA,CAAA;EAiEW;;;;;;;;EA5CX,MAAA,CAAO,KAAA,EAAO,WAAA;AAAA;AAAA,iBAuBA,aAAA,YAAyB,MAAA,SAAe,WAAA,EAAA,CACtD,QAAA,EAAU,EAAA,EACV,UAAA,EAAY,kBAAA,GACX,EAAA;AAAA,iBAaa,gBAAA,WAAA,CACd,UAAA,EAAY,kBAAA,EACZ,QAAA,EAAU,MAAA,SAAe,WAAA,CAAY,SAAA,gBACrC,IAAA,UACA,OAAA;EAAY,EAAA;AAAA,IACX,UAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/channels/base.ts"],"mappings":";;;;;;AAgBA;;iBAAgB,cAAA,CAAe,OAAA,EAAS,WAAA;;uBASlB,WAAA;EAKpB,SAAA,EAAW,SAAA;EAEX,UAAA,EAAY,UAAA;EAFD;;;EAAA,SAOF,aAAA;EAoCO;EAjChB,aAAA;EA0Fc;;;;;;;;EAAA,SAhFL,cAAA,CAAe,UAAA,GAAa,cAAA;EAlBzB;;;;;;;;;;;;;EAAA,SAiCH,MAAA,CAAO,MAAA,EAAQ,UAAA;EAmCxB;;;;;;EAAA,SA3BS,GAAA,CAAA,GAAO,SAAA;EAgFF;;;;;;EAAA,SAxEL,UAAA,CAAA,GAAc,cAAA;EA2EtB;;;;;;;EAlED,OAAA,CAAA;EAiEY;;;;;AA8Bd;EArFE,MAAA,CAAA;;;;;;EASA,WAAA,CAAA;EA+EI;;;;;;;;EA1DJ,MAAA,CAAO,KAAA,EAAO,WAAA;AAAA;AAAA,iBAuBA,aAAA,YAAyB,MAAA,SAAe,WAAA,EAAA,CACtD,QAAA,EAAU,EAAA,EACV,UAAA,EAAY,kBAAA,GACX,EAAA;;;;;;;;iBA6Ba,uBAAA,CACd,QAAA,EAAU,MAAA,SAAe,WAAA,GACzB,0BAAA,EAA4B,MAAA,6BAC3B,GAAA;AAAA,iBAkBa,gBAAA,WAAA,CACd,UAAA,EAAY,kBAAA,EACZ,QAAA,EAAU,MAAA,SAAe,WAAA,CAAY,SAAA,gBACrC,IAAA,UACA,OAAA;EACE,EAAA;EACA,kBAAA,GAAqB,GAAA;EACrB,eAAA,GAAkB,GAAA;EAClB,cAAA,IAAkB,OAAA;AAAA,IAEnB,UAAA;;;;;;;;;;;;;iBAqEmB,sBAAA,YACT,MAAA,SAAe,WAAA,EAAA,CAE1B,KAAA,EAAO,EAAA,EACP,UAAA,EAAY,kBAAA,EACZ,OAAA;EAAY,KAAA,GAAQ,mBAAA;EAAqB,MAAA,GAAS,cAAA;AAAA,IACjD,OAAA,CAAQ,EAAA"}

package/dist/channels/base.js

@@ -1,6 +1,14 @@
+import { getDeltaMaxSuperstepsSinceSnapshot } from "../constants.js";
 import { EmptyChannelError } from "../errors.js";
-import { uuid6 } from "@langchain/langgraph-checkpoint";
+import { DeltaSnapshot, uuid6 } from "@langchain/langgraph-checkpoint";
 //#region src/channels/base.ts
+/**
+* Structural check for a {@link DeltaChannel} without importing it (avoids an
+* import cycle: `delta.ts` imports `base.ts`).
+*/
+function isDeltaChannel(channel) {
+	return channel != null && channel.lc_graph_name === "DeltaChannel";
+}
 function isBaseChannel(obj) {
 	return obj != null && obj.lg_is_channel === true;
 }
@@ -78,15 +86,45 @@ function emptyChannels(channels, checkpoint) {
 	Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });
 	return newChannels;
 }
+/**
+* Return the set of {@link DeltaChannel} names that should snapshot now.
+*
+* A channel snapshots when EITHER its accumulated update count reaches
+* `snapshotFrequency` OR the total supersteps since its last snapshot reaches
+* `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT`. Pure predicate — no mutation.
+*/
+function deltaChannelsToSnapshot(channels, countersSinceDeltaSnapshot) {
+	const result = /* @__PURE__ */ new Set();
+	const maxSupersteps = getDeltaMaxSuperstepsSinceSnapshot();
+	for (const name in channels) {
+		if (!Object.prototype.hasOwnProperty.call(channels, name)) continue;
+		const ch = channels[name];
+		if (!isDeltaChannel(ch) || !ch.isAvailable()) continue;
+		const [updates, supersteps] = countersSinceDeltaSnapshot[name] ?? [0, 0];
+		if (updates >= ch.snapshotFrequency || supersteps >= maxSupersteps) result.add(name);
+	}
+	return result;
+}
 function createCheckpoint(checkpoint, channels, step, options) {
+	const channelsToSnapshot = options?.channelsToSnapshot ?? /* @__PURE__ */ new Set();
+	const { updatedChannels, getNextVersion } = options ?? {};
 	let values;
+	let channelVersions = checkpoint.channel_versions;
 	if (channels === void 0) values = checkpoint.channel_values;
 	else {
 		values = {};
+		channelVersions = { ...checkpoint.channel_versions };
 		for (const k in channels) {
 			if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;
+			const channel = channels[k];
+			if (channelsToSnapshot.has(k)) {
+				if (getNextVersion !== void 0 && (updatedChannels === void 0 || !updatedChannels.has(k))) channelVersions[k] = getNextVersion(channelVersions[k]);
+				values[k] = new DeltaSnapshot(channel.get());
+				continue;
+			}
+			if (isDeltaChannel(channel)) continue;
 			try {
-				values[k] = channels[k].checkpoint();
+				values[k] = channel.checkpoint();
 			} catch (error) {
 				if (error.name === EmptyChannelError.unminifiable_name) {} else throw error;
 			}
@@ -97,11 +135,46 @@ function createCheckpoint(checkpoint, channels, step, options) {
 		id: options?.id ?? uuid6(step),
 		ts: (/* @__PURE__ */ new Date()).toISOString(),
 		channel_values: values,
-		channel_versions: checkpoint.channel_versions,
+		channel_versions: channelVersions,
 		versions_seen: checkpoint.versions_seen
 	};
 }
+/**
+* Hydrate channels from a checkpoint, reconstructing any {@link DeltaChannel}
+* whose value is absent from `channel_values` by replaying ancestor writes.
+*
+* For most channels (and for delta channels with a {@link DeltaSnapshot} or a
+* migrated plain value in `channel_values`), {@link emptyChannels} is
+* sufficient and no saver access is required. When a delta channel is absent
+* from `channel_values`, an ancestor walk via `saver.getDeltaChannelHistory`
+* finds the nearest seed and accumulates the writes between it and the
+* target. All delta channels needing replay are batched into a single saver
+* call.
+*/
+async function channelsFromCheckpoint(specs, checkpoint, options) {
+	const channels = emptyChannels(specs, checkpoint);
+	const { saver, config } = options ?? {};
+	const filteredSpecs = getOnlyChannels(specs);
+	const deltaKeys = [];
+	for (const k in filteredSpecs) {
+		if (!Object.prototype.hasOwnProperty.call(filteredSpecs, k)) continue;
+		if (isDeltaChannel(filteredSpecs[k]) && !Object.prototype.hasOwnProperty.call(checkpoint.channel_values, k)) deltaKeys.push(k);
+	}
+	if (deltaKeys.length === 0 || saver === void 0 || config === void 0) return channels;
+	const histories = await saver.getDeltaChannelHistory({
+		config,
+		channels: deltaKeys
+	});
+	for (const k of deltaKeys) {
+		const history = histories[k];
+		if (history === void 0) continue;
+		const replayCh = filteredSpecs[k].fromCheckpoint(history.seed);
+		replayCh.replayWrites(history.writes);
+		channels[k] = replayCh;
+	}
+	return channels;
+}
 //#endregion
-export { BaseChannel, createCheckpoint, emptyChannels, getOnlyChannels, isBaseChannel };
+export { BaseChannel, channelsFromCheckpoint, createCheckpoint, deltaChannelsToSnapshot, emptyChannels, getOnlyChannels, isBaseChannel, isDeltaChannel };
 
 //# sourceMappingURL=base.js.map

package/dist/channels/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n} from \"@langchain/langgraph-checkpoint\";\nimport { EmptyChannelError } from \"../errors.js\";\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown,\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Used to determine if two channels with the same key are semantically equivalent.\n   * Subclasses should override this method to provide a meaningful comparison.\n   *\n   * @param {BaseChannel} other - The other channel to compare with.\n   * @returns {boolean} True if the channels are equal, false otherwise.\n   */\n  equals(other: BaseChannel): boolean {\n    return this === other;\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: { id?: string }\n): Checkpoint {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      try {\n        values[k] = channels[k].checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: checkpoint.channel_versions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n"],"mappings":";;;AAOA,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAAS,kBAAkB,kBACnC,QAAO;AAET,SAAM;;;;;;;;;;;CAYV,OAAO,OAA6B;AAClC,SAAO,SAAS;;;AAIpB,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAI;AACJ,KAAI,aAAa,KAAA,EACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG,YAAY;YAE7B,OAAY;AACnB,QAAI,MAAM,SAAS,kBAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,MAAM,MAAM,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}
+{"version":3,"file":"base.js","names":[],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n  DeltaSnapshot,\n  type BaseCheckpointSaver,\n  type DeltaChannelHistory,\n} from \"@langchain/langgraph-checkpoint\";\nimport type { RunnableConfig } from \"@langchain/core/runnables\";\nimport { EmptyChannelError } from \"../errors.js\";\nimport { getDeltaMaxSuperstepsSinceSnapshot } from \"../constants.js\";\n\n/**\n * Structural check for a {@link DeltaChannel} without importing it (avoids an\n * import cycle: `delta.ts` imports `base.ts`).\n */\nexport function isDeltaChannel(channel: BaseChannel): boolean {\n  return channel != null && channel.lc_graph_name === \"DeltaChannel\";\n}\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown,\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Used to determine if two channels with the same key are semantically equivalent.\n   * Subclasses should override this method to provide a meaningful comparison.\n   *\n   * @param {BaseChannel} other - The other channel to compare with.\n   * @returns {boolean} True if the channels are equal, false otherwise.\n   */\n  equals(other: BaseChannel): boolean {\n    return this === other;\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\n/**\n * Minimal structural view of a {@link DeltaChannel}, used by helpers in this\n * module that must not import the concrete class (import-cycle avoidance).\n */\ninterface DeltaChannelLike extends BaseChannel {\n  snapshotFrequency: number;\n  replayWrites(writes: DeltaChannelHistory[\"writes\"]): void;\n}\n\n/**\n * Return the set of {@link DeltaChannel} names that should snapshot now.\n *\n * A channel snapshots when EITHER its accumulated update count reaches\n * `snapshotFrequency` OR the total supersteps since its last snapshot reaches\n * `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT`. Pure predicate — no mutation.\n */\nexport function deltaChannelsToSnapshot(\n  channels: Record<string, BaseChannel>,\n  countersSinceDeltaSnapshot: Record<string, [number, number]>\n): Set<string> {\n  const result = new Set<string>();\n  const maxSupersteps = getDeltaMaxSuperstepsSinceSnapshot();\n  for (const name in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, name)) continue;\n    const ch = channels[name];\n    if (!isDeltaChannel(ch) || !ch.isAvailable()) continue;\n    const [updates, supersteps] = countersSinceDeltaSnapshot[name] ?? [0, 0];\n    if (\n      updates >= (ch as DeltaChannelLike).snapshotFrequency ||\n      supersteps >= maxSupersteps\n    ) {\n      result.add(name);\n    }\n  }\n  return result;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: {\n    id?: string;\n    channelsToSnapshot?: Set<string>;\n    updatedChannels?: Set<string>;\n    getNextVersion?: (current: number | string | undefined) => number | string;\n  }\n): Checkpoint {\n  const channelsToSnapshot = options?.channelsToSnapshot ?? new Set<string>();\n  const { updatedChannels, getNextVersion } = options ?? {};\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  let channelVersions: Record<string, number | string> =\n    checkpoint.channel_versions;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    channelVersions = { ...checkpoint.channel_versions };\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      const channel = channels[k];\n      if (channelsToSnapshot.has(k)) {\n        // Snapshot a DeltaChannel: store the materialized value directly. In\n        // exit/deferred modes the channel may have reached its snapshot\n        // threshold over several supersteps without the LAST superstep\n        // writing to it, so its version wouldn't be bumped by applyWrites —\n        // bump it here so the saver includes the snapshot blob.\n        if (\n          getNextVersion !== undefined &&\n          (updatedChannels === undefined || !updatedChannels.has(k))\n        ) {\n          channelVersions[k] = getNextVersion(channelVersions[k]);\n        }\n        values[k] = new DeltaSnapshot(channel.get());\n        continue;\n      }\n      if (isDeltaChannel(channel)) {\n        // Omitted from channel_values; reconstructed from ancestor writes.\n        continue;\n      }\n      try {\n        values[k] = channel.checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: channelVersions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n\n/**\n * Hydrate channels from a checkpoint, reconstructing any {@link DeltaChannel}\n * whose value is absent from `channel_values` by replaying ancestor writes.\n *\n * For most channels (and for delta channels with a {@link DeltaSnapshot} or a\n * migrated plain value in `channel_values`), {@link emptyChannels} is\n * sufficient and no saver access is required. When a delta channel is absent\n * from `channel_values`, an ancestor walk via `saver.getDeltaChannelHistory`\n * finds the nearest seed and accumulates the writes between it and the\n * target. All delta channels needing replay are batched into a single saver\n * call.\n */\nexport async function channelsFromCheckpoint<\n  Cc extends Record<string, BaseChannel>,\n>(\n  specs: Cc,\n  checkpoint: ReadonlyCheckpoint,\n  options?: { saver?: BaseCheckpointSaver; config?: RunnableConfig }\n): Promise<Cc> {\n  const channels = emptyChannels(specs, checkpoint);\n  const { saver, config } = options ?? {};\n\n  const filteredSpecs = getOnlyChannels(specs);\n  const deltaKeys: string[] = [];\n  for (const k in filteredSpecs) {\n    if (!Object.prototype.hasOwnProperty.call(filteredSpecs, k)) continue;\n    if (\n      isDeltaChannel(filteredSpecs[k]) &&\n      !Object.prototype.hasOwnProperty.call(checkpoint.channel_values, k)\n    ) {\n      deltaKeys.push(k);\n    }\n  }\n\n  if (deltaKeys.length === 0 || saver === undefined || config === undefined) {\n    return channels;\n  }\n\n  const histories = await saver.getDeltaChannelHistory({\n    config,\n    channels: deltaKeys,\n  });\n  for (const k of deltaKeys) {\n    const history = histories[k];\n    if (history === undefined) continue;\n    const replayCh = filteredSpecs[k].fromCheckpoint(\n      history.seed\n    ) as unknown as DeltaChannelLike;\n    replayCh.replayWrites(history.writes);\n    (channels as Record<string, BaseChannel>)[k] = replayCh;\n  }\n  return channels;\n}\n"],"mappings":";;;;;;;;AAgBA,SAAgB,eAAe,SAA+B;AAC5D,QAAO,WAAW,QAAQ,QAAQ,kBAAkB;;AAGtD,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAAS,kBAAkB,kBACnC,QAAO;AAET,SAAM;;;;;;;;;;;CAYV,OAAO,OAA6B;AAClC,SAAO,SAAS;;;AAIpB,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;;;;;;;;AAmBT,SAAgB,wBACd,UACA,4BACa;CACb,MAAM,yBAAS,IAAI,KAAa;CAChC,MAAM,gBAAgB,oCAAoC;AAC1D,MAAK,MAAM,QAAQ,UAAU;AAC3B,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,KAAK,CAAE;EAC3D,MAAM,KAAK,SAAS;AACpB,MAAI,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,aAAa,CAAE;EAC9C,MAAM,CAAC,SAAS,cAAc,2BAA2B,SAAS,CAAC,GAAG,EAAE;AACxE,MACE,WAAY,GAAwB,qBACpC,cAAc,cAEd,QAAO,IAAI,KAAK;;AAGpB,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SAMY;CACZ,MAAM,qBAAqB,SAAS,sCAAsB,IAAI,KAAa;CAC3E,MAAM,EAAE,iBAAiB,mBAAmB,WAAW,EAAE;CAEzD,IAAI;CACJ,IAAI,kBACF,WAAW;AACb,KAAI,aAAa,KAAA,EACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,oBAAkB,EAAE,GAAG,WAAW,kBAAkB;AACpD,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;GACxD,MAAM,UAAU,SAAS;AACzB,OAAI,mBAAmB,IAAI,EAAE,EAAE;AAM7B,QACE,mBAAmB,KAAA,MAClB,oBAAoB,KAAA,KAAa,CAAC,gBAAgB,IAAI,EAAE,EAEzD,iBAAgB,KAAK,eAAe,gBAAgB,GAAG;AAEzD,WAAO,KAAK,IAAI,cAAc,QAAQ,KAAK,CAAC;AAC5C;;AAEF,OAAI,eAAe,QAAQ,CAEzB;AAEF,OAAI;AACF,WAAO,KAAK,QAAQ,YAAY;YAEzB,OAAY;AACnB,QAAI,MAAM,SAAS,kBAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,MAAM,MAAM,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB;EAClB,eAAe,WAAW;EAC3B;;;;;;;;;;;;;;AAeH,eAAsB,uBAGpB,OACA,YACA,SACa;CACb,MAAM,WAAW,cAAc,OAAO,WAAW;CACjD,MAAM,EAAE,OAAO,WAAW,WAAW,EAAE;CAEvC,MAAM,gBAAgB,gBAAgB,MAAM;CAC5C,MAAM,YAAsB,EAAE;AAC9B,MAAK,MAAM,KAAK,eAAe;AAC7B,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,eAAe,EAAE,CAAE;AAC7D,MACE,eAAe,cAAc,GAAG,IAChC,CAAC,OAAO,UAAU,eAAe,KAAK,WAAW,gBAAgB,EAAE,CAEnE,WAAU,KAAK,EAAE;;AAIrB,KAAI,UAAU,WAAW,KAAK,UAAU,KAAA,KAAa,WAAW,KAAA,EAC9D,QAAO;CAGT,MAAM,YAAY,MAAM,MAAM,uBAAuB;EACnD;EACA,UAAU;EACX,CAAC;AACF,MAAK,MAAM,KAAK,WAAW;EACzB,MAAM,UAAU,UAAU;AAC1B,MAAI,YAAY,KAAA,EAAW;EAC3B,MAAM,WAAW,cAAc,GAAG,eAChC,QAAQ,KACT;AACD,WAAS,aAAa,QAAQ,OAAO;AACpC,WAAyC,KAAK;;AAEjD,QAAO"}

package/dist/channels/delta.cjs

@@ -0,0 +1,136 @@
+const require_constants = require("../constants.cjs");
+const require_errors = require("../errors.cjs");
+const require_base = require("./base.cjs");
+let _langchain_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
+//#region src/channels/delta.ts
+const isDeltaChannel = (value) => {
+	return value != null && value.lc_graph_name === "DeltaChannel";
+};
+/**
+* Reducer channel that stores only a sentinel in checkpoint blobs and
+* reconstructs state by replaying ancestor writes through the reducer.
+*
+* `DeltaChannel` avoids re-serializing the full accumulated value at every
+* step. Instead of writing the value into `channel_values`, the channel is
+* omitted entirely and its state is reconstructed on read by walking the
+* ancestor chain and replaying the per-step writes through the reducer (see
+* {@link BaseCheckpointSaver.getDeltaChannelHistory}).
+*
+* Snapshot cadence is driven by two counters: a per-channel update count and
+* the total supersteps since the last snapshot. A full {@link DeltaSnapshot}
+* blob is written when EITHER the update count reaches `snapshotFrequency` OR
+* the supersteps count reaches the system-wide
+* `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT` bound (default 5000), bounding replay
+* depth even for channels that stop receiving writes.
+*
+* @remarks Beta. The API and on-disk representation may change in future
+* releases. Threads written with `DeltaChannel` today are expected to remain
+* readable, but the surrounding contract (`getDeltaChannelHistory`, the
+* `DeltaSnapshot` blob shape, the `counters_since_delta_snapshot` metadata
+* field) is not yet stable.
+*
+* @example
+* ```typescript
+* import { Annotation } from "@langchain/langgraph";
+* import { DeltaChannel, messagesDeltaReducer } from "@langchain/langgraph";
+*
+* const State = Annotation.Root({
+*   messages: Annotation<BaseMessage[]>({
+*     reducer: () => [], // ignored; DeltaChannel is supplied below
+*   }),
+* });
+* ```
+*/
+var DeltaChannel = class DeltaChannel extends require_base.BaseChannel {
+	lc_graph_name = "DeltaChannel";
+	/** `undefined` represents the Python `MISSING` sentinel (empty channel). */
+	value;
+	reducer;
+	snapshotFrequency;
+	initialValueFactory;
+	constructor(reducer, options) {
+		super();
+		const snapshotFrequency = options?.snapshotFrequency ?? 1e3;
+		if (!Number.isInteger(snapshotFrequency) || snapshotFrequency <= 0) throw new Error(`snapshotFrequency must be a positive integer, got ${snapshotFrequency}`);
+		this.reducer = reducer;
+		this.snapshotFrequency = snapshotFrequency;
+		this.initialValueFactory = options?.initialValueFactory ?? (() => []);
+		this.value = void 0;
+	}
+	fromCheckpoint(checkpoint) {
+		const empty = new DeltaChannel(this.reducer, {
+			snapshotFrequency: this.snapshotFrequency,
+			initialValueFactory: this.initialValueFactory
+		});
+		if (checkpoint === void 0) empty.value = this.initialValueFactory();
+		else if ((0, _langchain_langgraph_checkpoint.isDeltaSnapshot)(checkpoint)) empty.value = checkpoint.value;
+		else empty.value = checkpoint;
+		return empty;
+	}
+	/**
+	* Apply ancestor writes oldest-to-newest via a single reducer call.
+	*
+	* If any write is an Overwrite, the last one in the sequence acts as the
+	* reset point: its value becomes the new base and only writes after it are
+	* passed to the reducer.
+	*/
+	replayWrites(writes) {
+		const values = writes.map((w) => w[2]);
+		if (values.length === 0) return;
+		let base = this.value;
+		let start = 0;
+		for (let i = 0; i < values.length; i += 1) {
+			const [isOverwrite, overwriteValue] = require_constants._getOverwriteValue(values[i]);
+			if (isOverwrite) {
+				base = overwriteValue !== void 0 && overwriteValue !== null ? overwriteValue : this.initialValueFactory();
+				start = i + 1;
+			}
+		}
+		const remaining = values.slice(start);
+		this.value = remaining.length > 0 ? this.reducer(base, remaining) : base;
+	}
+	update(values) {
+		if (values.length === 0) return false;
+		let overwriteIdx;
+		for (let i = 0; i < values.length; i += 1) if (require_constants._isOverwriteValue(values[i])) {
+			if (overwriteIdx !== void 0) throw new require_errors.InvalidUpdateError("Can receive only one Overwrite value per step.");
+			overwriteIdx = i;
+		}
+		if (overwriteIdx !== void 0) {
+			const [, overwriteValue] = require_constants._getOverwriteValue(values[overwriteIdx]);
+			const base = overwriteValue !== void 0 && overwriteValue !== null ? overwriteValue : this.initialValueFactory();
+			const remaining = values.slice(overwriteIdx + 1);
+			this.value = remaining.length > 0 ? this.reducer(base, remaining) : base;
+			return true;
+		}
+		const base = this.value === void 0 ? this.initialValueFactory() : this.value;
+		this.value = this.reducer(base, values);
+		return true;
+	}
+	get() {
+		if (this.value === void 0) throw new require_errors.EmptyChannelError();
+		return this.value;
+	}
+	/**
+	* Always returns `undefined` (the Python `MISSING` sentinel). Snapshot
+	* decisions live in `createCheckpoint`, which has the channel version and
+	* writes a {@link DeltaSnapshot} directly into `channel_values`. For
+	* non-snapshot steps the channel does not appear in `channel_values`;
+	* reconstruction walks ancestor writes via the saver's
+	* `getDeltaChannelHistory`.
+	*/
+	checkpoint() {}
+	isAvailable() {
+		return this.value !== void 0;
+	}
+	equals(other) {
+		if (this === other) return true;
+		if (!isDeltaChannel(other)) return false;
+		if (this.snapshotFrequency !== other.snapshotFrequency) return false;
+		return this.reducer === other.reducer;
+	}
+};
+//#endregion
+exports.DeltaChannel = DeltaChannel;
+
+//# sourceMappingURL=delta.cjs.map

package/dist/channels/delta.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta.cjs","names":["BaseChannel","_getOverwriteValue","_isOverwriteValue","InvalidUpdateError","EmptyChannelError"],"sources":["../../src/channels/delta.ts"],"sourcesContent":["import {\n  type CheckpointPendingWrite,\n  DeltaSnapshot,\n  isDeltaSnapshot,\n} from \"@langchain/langgraph-checkpoint\";\nimport {\n  _getOverwriteValue,\n  _isOverwriteValue,\n  type OverwriteValue,\n} from \"../constants.js\";\nimport { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * A batch reducer for use with {@link DeltaChannel}.\n *\n * Receives the current accumulated value and a batch of writes in one call,\n * returning the new accumulated value:\n * `reducer(state, [write1, write2, ...]) -> newState`.\n *\n * Reducers must be deterministic and batching-invariant (associative across\n * folds): applying two consecutive write batches separately must produce the\n * same state as applying their concatenation once:\n *\n * ```text\n * reducer(reducer(state, xs), ys) === reducer(state, xs.concat(ys))\n * ```\n *\n * This lets LangGraph replay checkpointed writes in larger batches than they\n * were originally produced without changing reconstructed state. If your\n * reducer is not associative, use {@link BinaryOperatorAggregate} instead —\n * `DeltaChannel` is not a drop-in replacement for every reducer.\n */\nexport type DeltaReducer<ValueType, UpdateType = unknown> = (\n  state: ValueType,\n  writes: UpdateType[]\n) => ValueType;\n\ntype OverwriteOrValue<ValueType, UpdateType> =\n  | OverwriteValue<ValueType>\n  | UpdateType;\n\nconst isDeltaChannel = (\n  value: BaseChannel\n): value is DeltaChannel<unknown, unknown> => {\n  return value != null && value.lc_graph_name === \"DeltaChannel\";\n};\n\n/**\n * Reducer channel that stores only a sentinel in checkpoint blobs and\n * reconstructs state by replaying ancestor writes through the reducer.\n *\n * `DeltaChannel` avoids re-serializing the full accumulated value at every\n * step. Instead of writing the value into `channel_values`, the channel is\n * omitted entirely and its state is reconstructed on read by walking the\n * ancestor chain and replaying the per-step writes through the reducer (see\n * {@link BaseCheckpointSaver.getDeltaChannelHistory}).\n *\n * Snapshot cadence is driven by two counters: a per-channel update count and\n * the total supersteps since the last snapshot. A full {@link DeltaSnapshot}\n * blob is written when EITHER the update count reaches `snapshotFrequency` OR\n * the supersteps count reaches the system-wide\n * `DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT` bound (default 5000), bounding replay\n * depth even for channels that stop receiving writes.\n *\n * @remarks Beta. The API and on-disk representation may change in future\n * releases. Threads written with `DeltaChannel` today are expected to remain\n * readable, but the surrounding contract (`getDeltaChannelHistory`, the\n * `DeltaSnapshot` blob shape, the `counters_since_delta_snapshot` metadata\n * field) is not yet stable.\n *\n * @example\n * ```typescript\n * import { Annotation } from \"@langchain/langgraph\";\n * import { DeltaChannel, messagesDeltaReducer } from \"@langchain/langgraph\";\n *\n * const State = Annotation.Root({\n *   messages: Annotation<BaseMessage[]>({\n *     reducer: () => [], // ignored; DeltaChannel is supplied below\n *   }),\n * });\n * ```\n */\nexport class DeltaChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n> extends BaseChannel<\n  ValueType,\n  OverwriteOrValue<ValueType, UpdateType>,\n  undefined\n> {\n  lc_graph_name = \"DeltaChannel\";\n\n  /** `undefined` represents the Python `MISSING` sentinel (empty channel). */\n  value: ValueType | undefined;\n\n  reducer: DeltaReducer<ValueType, UpdateType>;\n\n  snapshotFrequency: number;\n\n  initialValueFactory: () => ValueType;\n\n  constructor(\n    reducer: DeltaReducer<ValueType, UpdateType>,\n    options?: {\n      snapshotFrequency?: number;\n      initialValueFactory?: () => ValueType;\n    }\n  ) {\n    super();\n    const snapshotFrequency = options?.snapshotFrequency ?? 1000;\n    if (!Number.isInteger(snapshotFrequency) || snapshotFrequency <= 0) {\n      throw new Error(\n        `snapshotFrequency must be a positive integer, got ${snapshotFrequency}`\n      );\n    }\n    this.reducer = reducer;\n    this.snapshotFrequency = snapshotFrequency;\n    this.initialValueFactory =\n      options?.initialValueFactory ?? (() => [] as ValueType);\n    this.value = undefined;\n  }\n\n  public fromCheckpoint(checkpoint?: undefined | DeltaSnapshot | ValueType) {\n    const empty = new DeltaChannel<ValueType, UpdateType>(this.reducer, {\n      snapshotFrequency: this.snapshotFrequency,\n      initialValueFactory: this.initialValueFactory,\n    });\n    if (checkpoint === undefined) {\n      empty.value = this.initialValueFactory();\n    } else if (isDeltaSnapshot(checkpoint)) {\n      empty.value = checkpoint.value as ValueType;\n    } else {\n      empty.value = checkpoint as ValueType;\n    }\n    return empty as this;\n  }\n\n  /**\n   * Apply ancestor writes oldest-to-newest via a single reducer call.\n   *\n   * If any write is an Overwrite, the last one in the sequence acts as the\n   * reset point: its value becomes the new base and only writes after it are\n   * passed to the reducer.\n   */\n  public replayWrites(writes: CheckpointPendingWrite[]): void {\n    const values = writes.map((w) => w[2]);\n    if (values.length === 0) return;\n    let base = this.value as ValueType;\n    let start = 0;\n    for (let i = 0; i < values.length; i += 1) {\n      const [isOverwrite, overwriteValue] = _getOverwriteValue<ValueType>(\n        values[i]\n      );\n      if (isOverwrite) {\n        base =\n          overwriteValue !== undefined && overwriteValue !== null\n            ? overwriteValue\n            : this.initialValueFactory();\n        start = i + 1;\n      }\n    }\n    const remaining = values.slice(start) as UpdateType[];\n    this.value = remaining.length > 0 ? this.reducer(base, remaining) : base;\n  }\n\n  public update(values: OverwriteOrValue<ValueType, UpdateType>[]): boolean {\n    if (values.length === 0) return false;\n\n    let overwriteIdx: number | undefined;\n    for (let i = 0; i < values.length; i += 1) {\n      if (_isOverwriteValue<ValueType>(values[i])) {\n        if (overwriteIdx !== undefined) {\n          throw new InvalidUpdateError(\n            \"Can receive only one Overwrite value per step.\"\n          );\n        }\n        overwriteIdx = i;\n      }\n    }\n\n    if (overwriteIdx !== undefined) {\n      const [, overwriteValue] = _getOverwriteValue<ValueType>(\n        values[overwriteIdx]\n      );\n      const base =\n        overwriteValue !== undefined && overwriteValue !== null\n          ? overwriteValue\n          : this.initialValueFactory();\n      // Treat Overwrite as a hard reset: drop everything up to and including\n      // the overwrite, keeping only writes that follow it. This mirrors\n      // `replayWrites` so reconstruction from a checkpoint reproduces the live\n      // state even when a plain write precedes the Overwrite in the same step.\n      const remaining = values.slice(overwriteIdx + 1) as UpdateType[];\n      this.value = remaining.length > 0 ? this.reducer(base, remaining) : base;\n      return true;\n    }\n\n    const base =\n      this.value === undefined ? this.initialValueFactory() : this.value;\n    this.value = this.reducer(base, values as UpdateType[]);\n    return true;\n  }\n\n  public get(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  /**\n   * Always returns `undefined` (the Python `MISSING` sentinel). Snapshot\n   * decisions live in `createCheckpoint`, which has the channel version and\n   * writes a {@link DeltaSnapshot} directly into `channel_values`. For\n   * non-snapshot steps the channel does not appear in `channel_values`;\n   * reconstruction walks ancestor writes via the saver's\n   * `getDeltaChannelHistory`.\n   */\n  public checkpoint(): undefined {\n    return undefined;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n\n  equals(other: BaseChannel): boolean {\n    if (this === other) return true;\n    if (!isDeltaChannel(other)) return false;\n    if (this.snapshotFrequency !== other.snapshotFrequency) return false;\n    return this.reducer === other.reducer;\n  }\n}\n"],"mappings":";;;;;AA0CA,MAAM,kBACJ,UAC4C;AAC5C,QAAO,SAAS,QAAQ,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsClD,IAAa,eAAb,MAAa,qBAGHA,aAAAA,YAIR;CACA,gBAAgB;;CAGhB;CAEA;CAEA;CAEA;CAEA,YACE,SACA,SAIA;AACA,SAAO;EACP,MAAM,oBAAoB,SAAS,qBAAqB;AACxD,MAAI,CAAC,OAAO,UAAU,kBAAkB,IAAI,qBAAqB,EAC/D,OAAM,IAAI,MACR,qDAAqD,oBACtD;AAEH,OAAK,UAAU;AACf,OAAK,oBAAoB;AACzB,OAAK,sBACH,SAAS,8BAA8B,EAAE;AAC3C,OAAK,QAAQ,KAAA;;CAGf,eAAsB,YAAoD;EACxE,MAAM,QAAQ,IAAI,aAAoC,KAAK,SAAS;GAClE,mBAAmB,KAAK;GACxB,qBAAqB,KAAK;GAC3B,CAAC;AACF,MAAI,eAAe,KAAA,EACjB,OAAM,QAAQ,KAAK,qBAAqB;gEACf,WAAW,CACpC,OAAM,QAAQ,WAAW;MAEzB,OAAM,QAAQ;AAEhB,SAAO;;;;;;;;;CAUT,aAAoB,QAAwC;EAC1D,MAAM,SAAS,OAAO,KAAK,MAAM,EAAE,GAAG;AACtC,MAAI,OAAO,WAAW,EAAG;EACzB,IAAI,OAAO,KAAK;EAChB,IAAI,QAAQ;AACZ,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,GAAG;GACzC,MAAM,CAAC,aAAa,kBAAkBC,kBAAAA,mBACpC,OAAO,GACR;AACD,OAAI,aAAa;AACf,WACE,mBAAmB,KAAA,KAAa,mBAAmB,OAC/C,iBACA,KAAK,qBAAqB;AAChC,YAAQ,IAAI;;;EAGhB,MAAM,YAAY,OAAO,MAAM,MAAM;AACrC,OAAK,QAAQ,UAAU,SAAS,IAAI,KAAK,QAAQ,MAAM,UAAU,GAAG;;CAGtE,OAAc,QAA4D;AACxE,MAAI,OAAO,WAAW,EAAG,QAAO;EAEhC,IAAI;AACJ,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,EACtC,KAAIC,kBAAAA,kBAA6B,OAAO,GAAG,EAAE;AAC3C,OAAI,iBAAiB,KAAA,EACnB,OAAM,IAAIC,eAAAA,mBACR,iDACD;AAEH,kBAAe;;AAInB,MAAI,iBAAiB,KAAA,GAAW;GAC9B,MAAM,GAAG,kBAAkBF,kBAAAA,mBACzB,OAAO,cACR;GACD,MAAM,OACJ,mBAAmB,KAAA,KAAa,mBAAmB,OAC/C,iBACA,KAAK,qBAAqB;GAKhC,MAAM,YAAY,OAAO,MAAM,eAAe,EAAE;AAChD,QAAK,QAAQ,UAAU,SAAS,IAAI,KAAK,QAAQ,MAAM,UAAU,GAAG;AACpE,UAAO;;EAGT,MAAM,OACJ,KAAK,UAAU,KAAA,IAAY,KAAK,qBAAqB,GAAG,KAAK;AAC/D,OAAK,QAAQ,KAAK,QAAQ,MAAM,OAAuB;AACvD,SAAO;;CAGT,MAAwB;AACtB,MAAI,KAAK,UAAU,KAAA,EACjB,OAAM,IAAIG,eAAAA,mBAAmB;AAE/B,SAAO,KAAK;;;;;;;;;;CAWd,aAA+B;CAI/B,cAAuB;AACrB,SAAO,KAAK,UAAU,KAAA;;CAGxB,OAAO,OAA6B;AAClC,MAAI,SAAS,MAAO,QAAO;AAC3B,MAAI,CAAC,eAAe,MAAM,CAAE,QAAO;AACnC,MAAI,KAAK,sBAAsB,MAAM,kBAAmB,QAAO;AAC/D,SAAO,KAAK,YAAY,MAAM"}