@langchain/langgraph 1.0.7 → 1.0.13

package/dist/channels/any_value.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"any_value.cjs","names":["BaseChannel","EmptyChannelError"],"sources":["../../src/channels/any_value.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"AnyValue\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor() {\n    super();\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new AnyValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      this.value = [];\n      return updated;\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return false;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,IAAa,WAAb,MAAa,iBAAwBA,yBAAiC;CACpE,gBAAgB;CAGhB,QAAsB;CAEtB,cAAc;AACZ;;CAGF,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI;AAClB,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC;AAEjB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AACpC,QAAK,QAAQ;AACb,UAAO;;AAIT,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS;AACrC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIC;AAEZ,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIA;AAEZ,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}
+{"version":3,"file":"any_value.cjs","names":["BaseChannel","EmptyChannelError"],"sources":["../../src/channels/any_value.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"AnyValue\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor() {\n    super();\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new AnyValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      this.value = [];\n      return updated;\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return false;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,IAAa,WAAb,MAAa,iBAAwBA,yBAAiC;CACpE,gBAAgB;CAGhB,QAAsB,EAAE;CAExB,cAAc;AACZ,SAAO;;CAGT,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,UAAiB;AACnC,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC,WAAW;AAE5B,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AACpC,QAAK,QAAQ,EAAE;AACf,UAAO;;AAIT,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS,GAAG;AACxC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIA,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}

package/dist/channels/any_value.d.cts

@@ -10,7 +10,6 @@ import { BaseChannel } from "./base.cjs";
  */
 declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {
   lc_graph_name: string;
-  // value is an array so we don't misinterpret an update to undefined as no write
   value: [Value] | [];
   constructor();
   fromCheckpoint(checkpoint?: Value): this;

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

@@ -1 +1 @@
-{"version":3,"file":"any_value.d.cts","names":["BaseChannel","AnyValue","Value"],"sources":["../../src/channels/any_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    // value is an array so we don't misinterpret an update to undefined as no write\n    value: [Value] | [];\n    constructor();\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAOA;;;;AAAuEE,cAAlDD,QAAkDC,CAAAA,KAAAA,CAAAA,SAA1BF,WAA0BE,CAAdA,KAAcA,EAAPA,KAAOA,EAAAA,KAAAA,CAAAA,CAAAA;eAG3DA,EAAAA,MAAAA;;OAGOA,EAAAA,CAHPA,KAGOA,CAAAA,GAAAA,EAAAA;aACRA,CAAAA;gBACOA,CAAAA,UAAAA,CAAAA,EAHcA,KAGdA,CAAAA,EAAAA,IAAAA;QAR2BF,CAAAA,MAAAA,EAM1BE,KAN0BF,EAAAA,CAAAA,EAAAA,OAAAA;SAOlCE;gBACOA"}
+{"version":3,"file":"any_value.d.cts","names":["BaseChannel","AnyValue","Value"],"sources":["../../src/channels/any_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    value: [Value] | [];\n    constructor();\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAOA;;;;AAAuEE,cAAlDD,QAAkDC,CAAAA,KAAAA,CAAAA,SAA1BF,WAA0BE,CAAdA,KAAcA,EAAPA,KAAOA,EAAAA,KAAAA,CAAAA,CAAAA;eAE3DA,EAAAA,MAAAA;OAEoBA,EAAAA,CAFpBA,KAEoBA,CAAAA,GAAAA,EAAAA;aACbA,CAAAA;gBACRA,CAAAA,UAAAA,CAAAA,EAFqBA,KAErBA,CAAAA,EAAAA,IAAAA;QACOA,CAAAA,MAAAA,EAFCA,KAEDA,EAAAA,CAAAA,EAAAA,OAAAA;KAP2BF,CAAAA,CAAAA,EAMlCE,KANkCF;EAAW,UAAA,CAAA,CAAA,EAOtCE,KAPsC"}

package/dist/channels/any_value.d.ts

@@ -10,7 +10,6 @@ import { BaseChannel } from "./base.js";
  */
 declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {
   lc_graph_name: string;
-  // value is an array so we don't misinterpret an update to undefined as no write
   value: [Value] | [];
   constructor();
   fromCheckpoint(checkpoint?: Value): this;

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

@@ -1 +1 @@
-{"version":3,"file":"any_value.d.ts","names":["BaseChannel","AnyValue","Value"],"sources":["../../src/channels/any_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    // value is an array so we don't misinterpret an update to undefined as no write\n    value: [Value] | [];\n    constructor();\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAOA;;;;AAAuEE,cAAlDD,QAAkDC,CAAAA,KAAAA,CAAAA,SAA1BF,WAA0BE,CAAdA,KAAcA,EAAPA,KAAOA,EAAAA,KAAAA,CAAAA,CAAAA;eAG3DA,EAAAA,MAAAA;;OAGOA,EAAAA,CAHPA,KAGOA,CAAAA,GAAAA,EAAAA;aACRA,CAAAA;gBACOA,CAAAA,UAAAA,CAAAA,EAHcA,KAGdA,CAAAA,EAAAA,IAAAA;QAR2BF,CAAAA,MAAAA,EAM1BE,KAN0BF,EAAAA,CAAAA,EAAAA,OAAAA;SAOlCE;gBACOA"}
+{"version":3,"file":"any_value.d.ts","names":["BaseChannel","AnyValue","Value"],"sources":["../../src/channels/any_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport declare class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    value: [Value] | [];\n    constructor();\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAOA;;;;AAAuEE,cAAlDD,QAAkDC,CAAAA,KAAAA,CAAAA,SAA1BF,WAA0BE,CAAdA,KAAcA,EAAPA,KAAOA,EAAAA,KAAAA,CAAAA,CAAAA;eAE3DA,EAAAA,MAAAA;OAEoBA,EAAAA,CAFpBA,KAEoBA,CAAAA,GAAAA,EAAAA;aACbA,CAAAA;gBACRA,CAAAA,UAAAA,CAAAA,EAFqBA,KAErBA,CAAAA,EAAAA,IAAAA;QACOA,CAAAA,MAAAA,EAFCA,KAEDA,EAAAA,CAAAA,EAAAA,OAAAA;KAP2BF,CAAAA,CAAAA,EAMlCE,KANkCF;EAAW,UAAA,CAAA,CAAA,EAOtCE,KAPsC"}

package/dist/channels/any_value.js.map

@@ -1 +1 @@
-{"version":3,"file":"any_value.js","names":[],"sources":["../../src/channels/any_value.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"AnyValue\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor() {\n    super();\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new AnyValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      this.value = [];\n      return updated;\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return false;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,IAAa,WAAb,MAAa,iBAAwB,YAAiC;CACpE,gBAAgB;CAGhB,QAAsB;CAEtB,cAAc;AACZ;;CAGF,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI;AAClB,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC;AAEjB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AACpC,QAAK,QAAQ;AACb,UAAO;;AAIT,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS;AACrC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI;AAEZ,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI;AAEZ,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}
+{"version":3,"file":"any_value.js","names":[],"sources":["../../src/channels/any_value.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the last value received, assumes that if multiple values are received, they are all equal.\n *\n * Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values\n * will be continuously overwritten.\n */\nexport class AnyValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"AnyValue\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor() {\n    super();\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new AnyValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      this.value = [];\n      return updated;\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return false;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,IAAa,WAAb,MAAa,iBAAwB,YAAiC;CACpE,gBAAgB;CAGhB,QAAsB,EAAE;CAExB,cAAc;AACZ,SAAO;;CAGT,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,UAAiB;AACnC,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC,WAAW;AAE5B,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AACpC,QAAK,QAAQ,EAAE;AACf,UAAO;;AAIT,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS,GAAG;AACxC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}

package/dist/channels/base.cjs

@@ -1,6 +1,5 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_errors = require('../errors.cjs');
-const __langchain_langgraph_checkpoint = require_rolldown_runtime.__toESM(require("@langchain/langgraph-checkpoint"));
+let _langchain_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
 
 //#region src/channels/base.ts
 function isBaseChannel(obj) {
@@ -85,7 +84,7 @@ function createCheckpoint(checkpoint, channels, step, options) {
 	}
 	return {
 		v: 4,
-		id: options?.id ?? (0, __langchain_langgraph_checkpoint.uuid6)(step),
+		id: options?.id ?? (0, _langchain_langgraph_checkpoint.uuid6)(step),
 		ts: (/* @__PURE__ */ new Date()).toISOString(),
 		channel_values: values,
 		channel_versions: checkpoint.channel_versions,

package/dist/channels/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["error: any","EmptyChannelError","values: Record<string, any>"],"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\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;AACL,UAAO;WAEAA,OAAY;AACnB,OAAI,MAAM,SAASC,iCAAkB,kBACnC,QAAO;AAET,SAAM;;;;AAKZ,MAAM,uBAAuB,OAAO,IAAI;AACxC,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc;AACpB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,GAAI;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,OAAQ,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB;AACrD,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB;CAEzC,MAAM,cAAc;AACpB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,GAAI;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe;;AAEtD,QAAO,OAAO,aAAa,GAAG,uBAAuB;AACrD,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAIC;AACJ,KAAI,aAAa,OACf,UAAS,WAAW;MACf;AACL,WAAS;AACT,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,GAAI;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG;YAEjBF,OAAY;AACnB,QAAI,MAAM,SAASC,iCAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,kDAAY;EACzB,qBAAI,IAAI,QAAO;EACf,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW"}
+{"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\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,iCAAkB,kBACnC,QAAO;AAET,SAAM;;;;AAKZ,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,OACf,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,iCAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,iDAAY,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\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     * 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     * 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     * 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     * 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    /**\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    /**\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}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;;EA+BIK;;;;;;;;EACAE,SAAAA,cAAgB,CAAA,UAAA,CAAA,EArDCL,cAqDD,CAAA,EAAA,IAAA;EAAA;;;;;;;;;;;;;0BAvCZD;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;iBAwBHG,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}
+{"version":3,"file":"base.d.cts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\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     * 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     * 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     * 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     * 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    /**\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    /**\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}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;EAOqB,aAAA,EAAA,OAAA;EAwBjBK;;;;;;;;EACAE,SAAAA,cAAgB,CAAA,UAAA,CAAA,EArDCL,cAqDD,CAAA,EAAA,IAAA;EAAA;;;;;;;;;;;;;0BAvCZD;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;iBAwBHG,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\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     * 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     * 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     * 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     * 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    /**\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    /**\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}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;;EA+BIK;;;;;;;;EACAE,SAAAA,cAAgB,CAAA,UAAA,CAAA,EArDCL,cAqDD,CAAA,EAAA,IAAA;EAAA;;;;;;;;;;;;;0BAvCZD;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;iBAwBHG,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}
+{"version":3,"file":"base.d.ts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\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     * 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     * 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     * 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     * 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    /**\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    /**\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}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;EAOqB,aAAA,EAAA,OAAA;EAwBjBK;;;;;;;;EACAE,SAAAA,cAAgB,CAAA,UAAA,CAAA,EArDCL,cAqDD,CAAA,EAAA,IAAA;EAAA;;;;;;;;;;;;;0BAvCZD;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;iBAwBHG,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}

package/dist/channels/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":["error: any","values: Record<string, any>"],"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\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;AACL,UAAO;WAEAA,OAAY;AACnB,OAAI,MAAM,SAAS,kBAAkB,kBACnC,QAAO;AAET,SAAM;;;;AAKZ,MAAM,uBAAuB,OAAO,IAAI;AACxC,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc;AACpB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,GAAI;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,OAAQ,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB;AACrD,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB;CAEzC,MAAM,cAAc;AACpB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,GAAI;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe;;AAEtD,QAAO,OAAO,aAAa,GAAG,uBAAuB;AACrD,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAIC;AACJ,KAAI,aAAa,OACf,UAAS,WAAW;MACf;AACL,WAAS;AACT,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,GAAI;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG;YAEjBD,OAAY;AACnB,QAAI,MAAM,SAAS,kBAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,MAAM,MAAM;EACzB,qBAAI,IAAI,QAAO;EACf,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW"}
+{"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\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;;;;AAKZ,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,OACf,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"}

package/dist/channels/binop.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"binop.cjs","names":["BaseChannel","EmptyChannelError"],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\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  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,MAAa,gCAGHA,yBAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA;AAEA,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ;;CAGf,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK;AAEP,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM;;AAG9B,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO;AAG3C,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIC;AAEZ,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIA;AAEZ,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU"}
+{"version":3,"file":"binop.cjs","names":["BaseChannel","EmptyChannelError"],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\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  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,MAAa,gCAGHA,yBAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA,SAAO;AAEP,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ,uBAAuB;;CAGtC,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK,oBACN;AACD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM,EAAE;;AAGhC,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,MAAM;AAGjD,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIA,kCAAmB;AAE/B,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU"}

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

@@ -1 +1 @@
-{"version":3,"file":"binop.d.cts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;YAOvED,eAAeC,WAAWC;EAHnBC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA"}
+{"version":3,"file":"binop.d.cts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;EAAS,QAAA,EAOhFD,cAPgF,CAOjEC,SAPiE,EAOtDC,UAPsD,CAAA;EAIzEC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"binop.d.ts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;YAOvED,eAAeC,WAAWC;EAHnBC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA"}
+{"version":3,"file":"binop.d.ts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;EAAS,QAAA,EAOhFD,cAPgF,CAOjEC,SAPiE,EAOtDC,UAPsD,CAAA;EAIzEC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA"}

package/dist/channels/binop.js.map

@@ -1 +1 @@
-{"version":3,"file":"binop.js","names":[],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\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  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,MAAa,gCAGH,YAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA;AAEA,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ;;CAGf,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK;AAEP,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM;;AAG9B,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO;AAG3C,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI;AAEZ,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI;AAEZ,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU"}
+{"version":3,"file":"binop.js","names":[],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\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  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,MAAa,gCAGH,YAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA,SAAO;AAEP,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ,uBAAuB;;CAGtC,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK,oBACN;AACD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM,EAAE;;AAGhC,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,MAAM;AAGjD,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU"}

package/dist/channels/dynamic_barrier_value.cjs

@@ -61,7 +61,6 @@ var DynamicBarrierValue = class DynamicBarrierValue extends require_base.BaseCha
 	}
 	get() {
 		if (!this.names || !require_named_barrier_value.areSetsEqual(this.names, this.seen)) throw new require_errors.EmptyChannelError();
-		return void 0;
 	}
 	checkpoint() {
 		return [this.names ? [...this.names] : void 0, [...this.seen]];

package/dist/channels/dynamic_barrier_value.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic_barrier_value.cjs","names":["BaseChannel","InvalidUpdateError","areSetsEqual","EmptyChannelError"],"sources":["../../src/channels/dynamic_barrier_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\nimport { areSetsEqual } from \"./named_barrier_value.js\";\n\nexport interface WaitForNames<Value> {\n  __names: Value[];\n}\n\nfunction isWaitForNames<Value>(\n  v: WaitForNames<Value> | Value\n): v is WaitForNames<Value> {\n  return (v as WaitForNames<Value>).__names !== undefined;\n}\n\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport class DynamicBarrierValue<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[]]\n> {\n  lc_graph_name = \"DynamicBarrierValue\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]) {\n    const empty = new DynamicBarrierValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.names = new Set(checkpoint[0]);\n      empty.seen = new Set(checkpoint[1]);\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (this.seen && this.names && areSetsEqual(this.seen, this.names)) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      return true;\n    }\n    return false;\n  }\n\n  // If we have not yet seen all the node names we want to wait for,\n  // throw an error to prevent continuing.\n  get(): void {\n    if (!this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[]] {\n    return [this.names ? [...this.names] : undefined, [...this.seen]];\n  }\n\n  isAvailable(): boolean {\n    return !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[], boolean]\n> {\n  lc_graph_name = \"DynamicBarrierValueAfterFinish\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  finished: boolean;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n    this.finished = false;\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]) {\n    const empty = new DynamicBarrierValueAfterFinish<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      const [names, seen, finished] = checkpoint;\n      empty.names = names ? new Set(names) : undefined;\n      empty.seen = new Set(seen);\n      empty.finished = finished;\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (\n      this.finished &&\n      this.seen &&\n      this.names &&\n      areSetsEqual(this.seen, this.names)\n    ) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      this.finished = false;\n      return true;\n    }\n    return false;\n  }\n\n  finish(): boolean {\n    if (!this.finished && this.names && areSetsEqual(this.names, this.seen)) {\n      this.finished = true;\n      return true;\n    }\n    return false;\n  }\n\n  get(): void {\n    if (!this.finished || !this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[], boolean] {\n    return [\n      this.names ? [...this.names] : undefined,\n      [...this.seen],\n      this.finished,\n    ];\n  }\n\n  isAvailable(): boolean {\n    return this.finished && !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n"],"mappings":";;;;;AAQA,SAAS,eACP,GAC0B;AAC1B,QAAQ,EAA0B,YAAY;;;;;;;;;;;AAYhD,IAAa,sBAAb,MAAa,4BAAmCA,yBAI9C;CACA,gBAAgB;CAEhB;CAEA;CAEA,cAAc;AACZ;AACA,OAAK,QAAQ;AACb,OAAK,uBAAO,IAAI;;CAGlB,eAAe,YAA6C;EAC1D,MAAM,QAAQ,IAAI;AAClB,MAAI,OAAO,eAAe,aAAa;AACrC,SAAM,QAAQ,IAAI,IAAI,WAAW;AACjC,SAAM,OAAO,IAAI,IAAI,WAAW;;AAElC,SAAO;;CAGT,OAAO,QAAkD;EACvD,MAAM,eAAe,OAAO,OAAO;AACnC,MAAI,aAAa,SAAS,GAAG;AAC3B,OAAI,aAAa,SAAS,EACxB,OAAM,IAAIC,kCACR;AAGJ,QAAK,QAAQ,IAAI,IAAI,aAAa,GAAG;AACrC,UAAO;aACE,KAAK,UAAU,QAAW;GACnC,IAAI,UAAU;AACd,QAAK,MAAM,SAAS,QAAQ;AAC1B,QAAI,eAAe,OACjB,OAAM,IAAI,MACR;AAGJ,QAAI,KAAK,MAAM,IAAI,UAAU,CAAC,KAAK,KAAK,IAAI,QAAQ;AAClD,UAAK,KAAK,IAAI;AACd,eAAU;;;AAGd,UAAO;;AAET,SAAO;;CAGT,UAAmB;AACjB,MAAI,KAAK,QAAQ,KAAK,SAASC,yCAAa,KAAK,MAAM,KAAK,QAAQ;AAClE,QAAK,uBAAO,IAAI;AAChB,QAAK,QAAQ;AACb,UAAO;;AAET,SAAO;;CAKT,MAAY;AACV,MAAI,CAAC,KAAK,SAAS,CAACA,yCAAa,KAAK,OAAO,KAAK,MAChD,OAAM,IAAIC;AAEZ,SAAO;;CAGT,aAA6C;AAC3C,SAAO,CAAC,KAAK,QAAQ,CAAC,GAAG,KAAK,SAAS,QAAW,CAAC,GAAG,KAAK;;CAG7D,cAAuB;AACrB,SAAO,CAAC,CAAC,KAAK,SAASD,yCAAa,KAAK,OAAO,KAAK"}
+{"version":3,"file":"dynamic_barrier_value.cjs","names":["BaseChannel","InvalidUpdateError","areSetsEqual","EmptyChannelError"],"sources":["../../src/channels/dynamic_barrier_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\nimport { areSetsEqual } from \"./named_barrier_value.js\";\n\nexport interface WaitForNames<Value> {\n  __names: Value[];\n}\n\nfunction isWaitForNames<Value>(\n  v: WaitForNames<Value> | Value\n): v is WaitForNames<Value> {\n  return (v as WaitForNames<Value>).__names !== undefined;\n}\n\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport class DynamicBarrierValue<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[]]\n> {\n  lc_graph_name = \"DynamicBarrierValue\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]) {\n    const empty = new DynamicBarrierValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.names = new Set(checkpoint[0]);\n      empty.seen = new Set(checkpoint[1]);\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (this.seen && this.names && areSetsEqual(this.seen, this.names)) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      return true;\n    }\n    return false;\n  }\n\n  // If we have not yet seen all the node names we want to wait for,\n  // throw an error to prevent continuing.\n  get(): void {\n    if (!this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[]] {\n    return [this.names ? [...this.names] : undefined, [...this.seen]];\n  }\n\n  isAvailable(): boolean {\n    return !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[], boolean]\n> {\n  lc_graph_name = \"DynamicBarrierValueAfterFinish\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  finished: boolean;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n    this.finished = false;\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]) {\n    const empty = new DynamicBarrierValueAfterFinish<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      const [names, seen, finished] = checkpoint;\n      empty.names = names ? new Set(names) : undefined;\n      empty.seen = new Set(seen);\n      empty.finished = finished;\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (\n      this.finished &&\n      this.seen &&\n      this.names &&\n      areSetsEqual(this.seen, this.names)\n    ) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      this.finished = false;\n      return true;\n    }\n    return false;\n  }\n\n  finish(): boolean {\n    if (!this.finished && this.names && areSetsEqual(this.names, this.seen)) {\n      this.finished = true;\n      return true;\n    }\n    return false;\n  }\n\n  get(): void {\n    if (!this.finished || !this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[], boolean] {\n    return [\n      this.names ? [...this.names] : undefined,\n      [...this.seen],\n      this.finished,\n    ];\n  }\n\n  isAvailable(): boolean {\n    return this.finished && !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n"],"mappings":";;;;;AAQA,SAAS,eACP,GAC0B;AAC1B,QAAQ,EAA0B,YAAY;;;;;;;;;;;AAYhD,IAAa,sBAAb,MAAa,4BAAmCA,yBAI9C;CACA,gBAAgB;CAEhB;CAEA;CAEA,cAAc;AACZ,SAAO;AACP,OAAK,QAAQ;AACb,OAAK,uBAAO,IAAI,KAAY;;CAG9B,eAAe,YAA6C;EAC1D,MAAM,QAAQ,IAAI,qBAA4B;AAC9C,MAAI,OAAO,eAAe,aAAa;AACrC,SAAM,QAAQ,IAAI,IAAI,WAAW,GAAG;AACpC,SAAM,OAAO,IAAI,IAAI,WAAW,GAAG;;AAErC,SAAO;;CAGT,OAAO,QAAkD;EACvD,MAAM,eAAe,OAAO,OAAO,eAAe;AAClD,MAAI,aAAa,SAAS,GAAG;AAC3B,OAAI,aAAa,SAAS,EACxB,OAAM,IAAIC,kCACR,2DACD;AAEH,QAAK,QAAQ,IAAI,IAAI,aAAa,GAAG,QAAQ;AAC7C,UAAO;aACE,KAAK,UAAU,QAAW;GACnC,IAAI,UAAU;AACd,QAAK,MAAM,SAAS,QAAQ;AAC1B,QAAI,eAAe,MAAM,CACvB,OAAM,IAAI,MACR,8DACD;AAEH,QAAI,KAAK,MAAM,IAAI,MAAM,IAAI,CAAC,KAAK,KAAK,IAAI,MAAM,EAAE;AAClD,UAAK,KAAK,IAAI,MAAM;AACpB,eAAU;;;AAGd,UAAO;;AAET,SAAO;;CAGT,UAAmB;AACjB,MAAI,KAAK,QAAQ,KAAK,SAASC,yCAAa,KAAK,MAAM,KAAK,MAAM,EAAE;AAClE,QAAK,uBAAO,IAAI,KAAY;AAC5B,QAAK,QAAQ;AACb,UAAO;;AAET,SAAO;;CAKT,MAAY;AACV,MAAI,CAAC,KAAK,SAAS,CAACA,yCAAa,KAAK,OAAO,KAAK,KAAK,CACrD,OAAM,IAAIC,kCAAmB;;CAKjC,aAA6C;AAC3C,SAAO,CAAC,KAAK,QAAQ,CAAC,GAAG,KAAK,MAAM,GAAG,QAAW,CAAC,GAAG,KAAK,KAAK,CAAC;;CAGnE,cAAuB;AACrB,SAAO,CAAC,CAAC,KAAK,SAASD,yCAAa,KAAK,OAAO,KAAK,KAAK"}

package/dist/channels/dynamic_barrier_value.d.cts

@@ -15,14 +15,12 @@ interface WaitForNames<Value> {
  */
 declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [Value[] | undefined, Value[]]> {
   lc_graph_name: string;
-  names?: Set<Value>; // Names of nodes that we want to wait for.
+  names?: Set<Value>;
   seen: Set<Value>;
   constructor();
   fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;
   update(values: (Value | WaitForNames<Value>)[]): boolean;
   consume(): boolean;
-  // If we have not yet seen all the node names we want to wait for,
-  // throw an error to prevent continuing.
   get(): void;
   checkpoint(): [Value[] | undefined, Value[]];
   isAvailable(): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"dynamic_barrier_value.d.cts","names":["BaseChannel","WaitForNames","Value","DynamicBarrierValue","Set","DynamicBarrierValueAfterFinish"],"sources":["../../src/channels/dynamic_barrier_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport interface WaitForNames<Value> {\n    __names: Value[];\n}\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[]\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>; // Names of nodes that we want to wait for.\n    seen: Set<Value>;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    // If we have not yet seen all the node names we want to wait for,\n    // throw an error to prevent continuing.\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[]];\n    isAvailable(): boolean;\n}\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport declare class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[],\n    boolean\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>; // Names of nodes that we want to wait for.\n    seen: Set<Value>;\n    finished: boolean;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    finish(): boolean;\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[], boolean];\n    isAvailable(): boolean;\n}\n"],"mappings":";;;UACiBC;WACJC;AADb;AAYA;;;;;;;;;AAMcA,cANOC,mBAMPD,CAAAA,KAAAA,CAAAA,SAN0CF,WAM1CE,CAAAA,IAAAA,EAN4DA,KAM5DA,GANoED,YAMpEC,CANiFA,KAMjFA,CAAAA,EAAAA,CALVA,KAKME,EAAAA,GAAAA,SAAAA,EAJNF,KAM6BA,EAAAA;eACbA,EAAAA,MAAAA;OAAqBA,CAAAA,EAJ7BE,GAI6BF,CAJzBA,KAIyBA,CAAAA,CAAAA,CAAAA;MAAbD,EAHlBG,GAGkBH,CAHdC,KAGcD,CAAAA;aAKTC,CAAAA;gBAAqBA,CAAAA,UAAAA,CAAAA,EAAAA,CANPA,KAMOA,EAAAA,GAAAA,SAAAA,EANcA,KAMdA,EAAAA,CAAAA,CAAAA,EAAAA,IAAAA;QAdgBF,CAAAA,MAAAA,EAAAA,CASpCE,KAToCF,GAS5BC,YAT4BD,CASfE,KATeF,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,OAAAA;;;;;iBAcrCE,qBAAqBA"}
+{"version":3,"file":"dynamic_barrier_value.d.cts","names":["BaseChannel","WaitForNames","Value","DynamicBarrierValue","Set","DynamicBarrierValueAfterFinish"],"sources":["../../src/channels/dynamic_barrier_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport interface WaitForNames<Value> {\n    __names: Value[];\n}\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[]\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>;\n    seen: Set<Value>;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[]];\n    isAvailable(): boolean;\n}\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport declare class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[],\n    boolean\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>;\n    seen: Set<Value>;\n    finished: boolean;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    finish(): boolean;\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[], boolean];\n    isAvailable(): boolean;\n}\n"],"mappings":";;;UACiBC;WACJC;AADb;AAYA;;;;;;;;;AAMcA,cANOC,mBAMPD,CAAAA,KAAAA,CAAAA,SAN0CF,WAM1CE,CAAAA,IAAAA,EAN4DA,KAM5DA,GANoED,YAMpEC,CANiFA,KAMjFA,CAAAA,EAAAA,CALVA,KAKME,EAAAA,GAAAA,SAAAA,EAJNF,KAM6BA,EAAAA;eACbA,EAAAA,MAAAA;OAAqBA,CAAAA,EAJ7BE,GAI6BF,CAJzBA,KAIyBA,CAAAA;MAAbD,EAHlBG,GAGkBH,CAHdC,KAGcD,CAAAA;aAGTC,CAAAA;gBAAqBA,CAAAA,UAAAA,CAAAA,EAAAA,CAJPA,KAIOA,EAAAA,GAAAA,SAAAA,EAJcA,KAIdA,EAAAA,CAAAA,CAAAA,EAAAA,IAAAA;QAZgBF,CAAAA,MAAAA,EAAAA,CASpCE,KAToCF,GAS5BC,YAT4BD,CASfE,KATeF,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,OAAAA;EAAW,OAAA,CAAA,CAAA,EAAA,OAAA;;iBAYhDE,qBAAqBA"}

package/dist/channels/dynamic_barrier_value.d.ts

@@ -15,14 +15,12 @@ interface WaitForNames<Value> {
  */
 declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [Value[] | undefined, Value[]]> {
   lc_graph_name: string;
-  names?: Set<Value>; // Names of nodes that we want to wait for.
+  names?: Set<Value>;
   seen: Set<Value>;
   constructor();
   fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;
   update(values: (Value | WaitForNames<Value>)[]): boolean;
   consume(): boolean;
-  // If we have not yet seen all the node names we want to wait for,
-  // throw an error to prevent continuing.
   get(): void;
   checkpoint(): [Value[] | undefined, Value[]];
   isAvailable(): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"dynamic_barrier_value.d.ts","names":["BaseChannel","WaitForNames","Value","DynamicBarrierValue","Set","DynamicBarrierValueAfterFinish"],"sources":["../../src/channels/dynamic_barrier_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport interface WaitForNames<Value> {\n    __names: Value[];\n}\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[]\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>; // Names of nodes that we want to wait for.\n    seen: Set<Value>;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    // If we have not yet seen all the node names we want to wait for,\n    // throw an error to prevent continuing.\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[]];\n    isAvailable(): boolean;\n}\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport declare class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[],\n    boolean\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>; // Names of nodes that we want to wait for.\n    seen: Set<Value>;\n    finished: boolean;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    finish(): boolean;\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[], boolean];\n    isAvailable(): boolean;\n}\n"],"mappings":";;;UACiBC;WACJC;AADb;AAYA;;;;;;;;;AAMcA,cANOC,mBAMPD,CAAAA,KAAAA,CAAAA,SAN0CF,WAM1CE,CAAAA,IAAAA,EAN4DA,KAM5DA,GANoED,YAMpEC,CANiFA,KAMjFA,CAAAA,EAAAA,CALVA,KAKME,EAAAA,GAAAA,SAAAA,EAJNF,KAM6BA,EAAAA;eACbA,EAAAA,MAAAA;OAAqBA,CAAAA,EAJ7BE,GAI6BF,CAJzBA,KAIyBA,CAAAA,CAAAA,CAAAA;MAAbD,EAHlBG,GAGkBH,CAHdC,KAGcD,CAAAA;aAKTC,CAAAA;gBAAqBA,CAAAA,UAAAA,CAAAA,EAAAA,CANPA,KAMOA,EAAAA,GAAAA,SAAAA,EANcA,KAMdA,EAAAA,CAAAA,CAAAA,EAAAA,IAAAA;QAdgBF,CAAAA,MAAAA,EAAAA,CASpCE,KAToCF,GAS5BC,YAT4BD,CASfE,KATeF,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,OAAAA;;;;;iBAcrCE,qBAAqBA"}
+{"version":3,"file":"dynamic_barrier_value.d.ts","names":["BaseChannel","WaitForNames","Value","DynamicBarrierValue","Set","DynamicBarrierValueAfterFinish"],"sources":["../../src/channels/dynamic_barrier_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport interface WaitForNames<Value> {\n    __names: Value[];\n}\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport declare class DynamicBarrierValue<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[]\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>;\n    seen: Set<Value>;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[]];\n    isAvailable(): boolean;\n}\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport declare class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<void, Value | WaitForNames<Value>, [\n    Value[] | undefined,\n    Value[],\n    boolean\n]> {\n    lc_graph_name: string;\n    names?: Set<Value>;\n    seen: Set<Value>;\n    finished: boolean;\n    constructor();\n    fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]): this;\n    update(values: (Value | WaitForNames<Value>)[]): boolean;\n    consume(): boolean;\n    finish(): boolean;\n    get(): void;\n    checkpoint(): [Value[] | undefined, Value[], boolean];\n    isAvailable(): boolean;\n}\n"],"mappings":";;;UACiBC;WACJC;AADb;AAYA;;;;;;;;;AAMcA,cANOC,mBAMPD,CAAAA,KAAAA,CAAAA,SAN0CF,WAM1CE,CAAAA,IAAAA,EAN4DA,KAM5DA,GANoED,YAMpEC,CANiFA,KAMjFA,CAAAA,EAAAA,CALVA,KAKME,EAAAA,GAAAA,SAAAA,EAJNF,KAM6BA,EAAAA;eACbA,EAAAA,MAAAA;OAAqBA,CAAAA,EAJ7BE,GAI6BF,CAJzBA,KAIyBA,CAAAA;MAAbD,EAHlBG,GAGkBH,CAHdC,KAGcD,CAAAA;aAGTC,CAAAA;gBAAqBA,CAAAA,UAAAA,CAAAA,EAAAA,CAJPA,KAIOA,EAAAA,GAAAA,SAAAA,EAJcA,KAIdA,EAAAA,CAAAA,CAAAA,EAAAA,IAAAA;QAZgBF,CAAAA,MAAAA,EAAAA,CASpCE,KAToCF,GAS5BC,YAT4BD,CASfE,KATeF,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,OAAAA;EAAW,OAAA,CAAA,CAAA,EAAA,OAAA;;iBAYhDE,qBAAqBA"}

package/dist/channels/dynamic_barrier_value.js

@@ -61,7 +61,6 @@ var DynamicBarrierValue = class DynamicBarrierValue extends BaseChannel {
 	}
 	get() {
 		if (!this.names || !areSetsEqual(this.names, this.seen)) throw new EmptyChannelError();
-		return void 0;
 	}
 	checkpoint() {
 		return [this.names ? [...this.names] : void 0, [...this.seen]];

package/dist/channels/dynamic_barrier_value.js.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic_barrier_value.js","names":[],"sources":["../../src/channels/dynamic_barrier_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\nimport { areSetsEqual } from \"./named_barrier_value.js\";\n\nexport interface WaitForNames<Value> {\n  __names: Value[];\n}\n\nfunction isWaitForNames<Value>(\n  v: WaitForNames<Value> | Value\n): v is WaitForNames<Value> {\n  return (v as WaitForNames<Value>).__names !== undefined;\n}\n\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport class DynamicBarrierValue<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[]]\n> {\n  lc_graph_name = \"DynamicBarrierValue\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]) {\n    const empty = new DynamicBarrierValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.names = new Set(checkpoint[0]);\n      empty.seen = new Set(checkpoint[1]);\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (this.seen && this.names && areSetsEqual(this.seen, this.names)) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      return true;\n    }\n    return false;\n  }\n\n  // If we have not yet seen all the node names we want to wait for,\n  // throw an error to prevent continuing.\n  get(): void {\n    if (!this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[]] {\n    return [this.names ? [...this.names] : undefined, [...this.seen]];\n  }\n\n  isAvailable(): boolean {\n    return !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[], boolean]\n> {\n  lc_graph_name = \"DynamicBarrierValueAfterFinish\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  finished: boolean;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n    this.finished = false;\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]) {\n    const empty = new DynamicBarrierValueAfterFinish<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      const [names, seen, finished] = checkpoint;\n      empty.names = names ? new Set(names) : undefined;\n      empty.seen = new Set(seen);\n      empty.finished = finished;\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (\n      this.finished &&\n      this.seen &&\n      this.names &&\n      areSetsEqual(this.seen, this.names)\n    ) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      this.finished = false;\n      return true;\n    }\n    return false;\n  }\n\n  finish(): boolean {\n    if (!this.finished && this.names && areSetsEqual(this.names, this.seen)) {\n      this.finished = true;\n      return true;\n    }\n    return false;\n  }\n\n  get(): void {\n    if (!this.finished || !this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[], boolean] {\n    return [\n      this.names ? [...this.names] : undefined,\n      [...this.seen],\n      this.finished,\n    ];\n  }\n\n  isAvailable(): boolean {\n    return this.finished && !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n"],"mappings":";;;;;AAQA,SAAS,eACP,GAC0B;AAC1B,QAAQ,EAA0B,YAAY;;;;;;;;;;;AAYhD,IAAa,sBAAb,MAAa,4BAAmC,YAI9C;CACA,gBAAgB;CAEhB;CAEA;CAEA,cAAc;AACZ;AACA,OAAK,QAAQ;AACb,OAAK,uBAAO,IAAI;;CAGlB,eAAe,YAA6C;EAC1D,MAAM,QAAQ,IAAI;AAClB,MAAI,OAAO,eAAe,aAAa;AACrC,SAAM,QAAQ,IAAI,IAAI,WAAW;AACjC,SAAM,OAAO,IAAI,IAAI,WAAW;;AAElC,SAAO;;CAGT,OAAO,QAAkD;EACvD,MAAM,eAAe,OAAO,OAAO;AACnC,MAAI,aAAa,SAAS,GAAG;AAC3B,OAAI,aAAa,SAAS,EACxB,OAAM,IAAI,mBACR;AAGJ,QAAK,QAAQ,IAAI,IAAI,aAAa,GAAG;AACrC,UAAO;aACE,KAAK,UAAU,QAAW;GACnC,IAAI,UAAU;AACd,QAAK,MAAM,SAAS,QAAQ;AAC1B,QAAI,eAAe,OACjB,OAAM,IAAI,MACR;AAGJ,QAAI,KAAK,MAAM,IAAI,UAAU,CAAC,KAAK,KAAK,IAAI,QAAQ;AAClD,UAAK,KAAK,IAAI;AACd,eAAU;;;AAGd,UAAO;;AAET,SAAO;;CAGT,UAAmB;AACjB,MAAI,KAAK,QAAQ,KAAK,SAAS,aAAa,KAAK,MAAM,KAAK,QAAQ;AAClE,QAAK,uBAAO,IAAI;AAChB,QAAK,QAAQ;AACb,UAAO;;AAET,SAAO;;CAKT,MAAY;AACV,MAAI,CAAC,KAAK,SAAS,CAAC,aAAa,KAAK,OAAO,KAAK,MAChD,OAAM,IAAI;AAEZ,SAAO;;CAGT,aAA6C;AAC3C,SAAO,CAAC,KAAK,QAAQ,CAAC,GAAG,KAAK,SAAS,QAAW,CAAC,GAAG,KAAK;;CAG7D,cAAuB;AACrB,SAAO,CAAC,CAAC,KAAK,SAAS,aAAa,KAAK,OAAO,KAAK"}
+{"version":3,"file":"dynamic_barrier_value.js","names":[],"sources":["../../src/channels/dynamic_barrier_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\nimport { areSetsEqual } from \"./named_barrier_value.js\";\n\nexport interface WaitForNames<Value> {\n  __names: Value[];\n}\n\nfunction isWaitForNames<Value>(\n  v: WaitForNames<Value> | Value\n): v is WaitForNames<Value> {\n  return (v as WaitForNames<Value>).__names !== undefined;\n}\n\n/**\n * A channel that switches between two states\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, it can be read once, and it switches\n *       back to the \"priming\" state.\n */\nexport class DynamicBarrierValue<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[]]\n> {\n  lc_graph_name = \"DynamicBarrierValue\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[]]) {\n    const empty = new DynamicBarrierValue<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      empty.names = new Set(checkpoint[0]);\n      empty.seen = new Set(checkpoint[1]);\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (this.seen && this.names && areSetsEqual(this.seen, this.names)) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      return true;\n    }\n    return false;\n  }\n\n  // If we have not yet seen all the node names we want to wait for,\n  // throw an error to prevent continuing.\n  get(): void {\n    if (!this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[]] {\n    return [this.names ? [...this.names] : undefined, [...this.seen]];\n  }\n\n  isAvailable(): boolean {\n    return !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n\n/**\n * A channel that switches between two states with an additional finished flag\n *\n * - in the \"priming\" state it can't be read from.\n *     - if it receives a WaitForNames update, it switches to the \"waiting\" state.\n * - in the \"waiting\" state it collects named values until all are received.\n *     - once all named values are received, and the finished flag is set, it can be read once, and it switches\n *       back to the \"priming\" state.\n * @internal\n */\nexport class DynamicBarrierValueAfterFinish<Value> extends BaseChannel<\n  void,\n  Value | WaitForNames<Value>,\n  [Value[] | undefined, Value[], boolean]\n> {\n  lc_graph_name = \"DynamicBarrierValueAfterFinish\";\n\n  names?: Set<Value>; // Names of nodes that we want to wait for.\n\n  seen: Set<Value>;\n\n  finished: boolean;\n\n  constructor() {\n    super();\n    this.names = undefined;\n    this.seen = new Set<Value>();\n    this.finished = false;\n  }\n\n  fromCheckpoint(checkpoint?: [Value[] | undefined, Value[], boolean]) {\n    const empty = new DynamicBarrierValueAfterFinish<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      const [names, seen, finished] = checkpoint;\n      empty.names = names ? new Set(names) : undefined;\n      empty.seen = new Set(seen);\n      empty.finished = finished;\n    }\n    return empty as this;\n  }\n\n  update(values: (Value | WaitForNames<Value>)[]): boolean {\n    const waitForNames = values.filter(isWaitForNames);\n    if (waitForNames.length > 0) {\n      if (waitForNames.length > 1) {\n        throw new InvalidUpdateError(\n          \"Received multiple WaitForNames updates in the same step.\"\n        );\n      }\n      this.names = new Set(waitForNames[0].__names);\n      return true;\n    } else if (this.names !== undefined) {\n      let updated = false;\n      for (const value of values) {\n        if (isWaitForNames(value)) {\n          throw new Error(\n            \"Assertion Error: Received unexpected WaitForNames instance.\"\n          );\n        }\n        if (this.names.has(value) && !this.seen.has(value)) {\n          this.seen.add(value);\n          updated = true;\n        }\n      }\n      return updated;\n    }\n    return false;\n  }\n\n  consume(): boolean {\n    if (\n      this.finished &&\n      this.seen &&\n      this.names &&\n      areSetsEqual(this.seen, this.names)\n    ) {\n      this.seen = new Set<Value>();\n      this.names = undefined;\n      this.finished = false;\n      return true;\n    }\n    return false;\n  }\n\n  finish(): boolean {\n    if (!this.finished && this.names && areSetsEqual(this.names, this.seen)) {\n      this.finished = true;\n      return true;\n    }\n    return false;\n  }\n\n  get(): void {\n    if (!this.finished || !this.names || !areSetsEqual(this.names, this.seen)) {\n      throw new EmptyChannelError();\n    }\n    return undefined;\n  }\n\n  checkpoint(): [Value[] | undefined, Value[], boolean] {\n    return [\n      this.names ? [...this.names] : undefined,\n      [...this.seen],\n      this.finished,\n    ];\n  }\n\n  isAvailable(): boolean {\n    return this.finished && !!this.names && areSetsEqual(this.names, this.seen);\n  }\n}\n"],"mappings":";;;;;AAQA,SAAS,eACP,GAC0B;AAC1B,QAAQ,EAA0B,YAAY;;;;;;;;;;;AAYhD,IAAa,sBAAb,MAAa,4BAAmC,YAI9C;CACA,gBAAgB;CAEhB;CAEA;CAEA,cAAc;AACZ,SAAO;AACP,OAAK,QAAQ;AACb,OAAK,uBAAO,IAAI,KAAY;;CAG9B,eAAe,YAA6C;EAC1D,MAAM,QAAQ,IAAI,qBAA4B;AAC9C,MAAI,OAAO,eAAe,aAAa;AACrC,SAAM,QAAQ,IAAI,IAAI,WAAW,GAAG;AACpC,SAAM,OAAO,IAAI,IAAI,WAAW,GAAG;;AAErC,SAAO;;CAGT,OAAO,QAAkD;EACvD,MAAM,eAAe,OAAO,OAAO,eAAe;AAClD,MAAI,aAAa,SAAS,GAAG;AAC3B,OAAI,aAAa,SAAS,EACxB,OAAM,IAAI,mBACR,2DACD;AAEH,QAAK,QAAQ,IAAI,IAAI,aAAa,GAAG,QAAQ;AAC7C,UAAO;aACE,KAAK,UAAU,QAAW;GACnC,IAAI,UAAU;AACd,QAAK,MAAM,SAAS,QAAQ;AAC1B,QAAI,eAAe,MAAM,CACvB,OAAM,IAAI,MACR,8DACD;AAEH,QAAI,KAAK,MAAM,IAAI,MAAM,IAAI,CAAC,KAAK,KAAK,IAAI,MAAM,EAAE;AAClD,UAAK,KAAK,IAAI,MAAM;AACpB,eAAU;;;AAGd,UAAO;;AAET,SAAO;;CAGT,UAAmB;AACjB,MAAI,KAAK,QAAQ,KAAK,SAAS,aAAa,KAAK,MAAM,KAAK,MAAM,EAAE;AAClE,QAAK,uBAAO,IAAI,KAAY;AAC5B,QAAK,QAAQ;AACb,UAAO;;AAET,SAAO;;CAKT,MAAY;AACV,MAAI,CAAC,KAAK,SAAS,CAAC,aAAa,KAAK,OAAO,KAAK,KAAK,CACrD,OAAM,IAAI,mBAAmB;;CAKjC,aAA6C;AAC3C,SAAO,CAAC,KAAK,QAAQ,CAAC,GAAG,KAAK,MAAM,GAAG,QAAW,CAAC,GAAG,KAAK,KAAK,CAAC;;CAGnE,cAAuB;AACrB,SAAO,CAAC,CAAC,KAAK,SAAS,aAAa,KAAK,OAAO,KAAK,KAAK"}

package/dist/channels/ephemeral_value.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ephemeral_value.cjs","names":["BaseChannel","InvalidUpdateError","EmptyChannelError"],"sources":["../../src/channels/ephemeral_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"EphemeralValue\";\n\n  guard: boolean;\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor(guard: boolean = true) {\n    super();\n    this.guard = guard;\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new EphemeralValue<Value>(this.guard);\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      // If there are no updates for this specific channel at the end of the step, wipe it.\n      this.value = [];\n      return updated;\n    }\n    if (values.length !== 1 && this.guard) {\n      throw new InvalidUpdateError(\n        \"EphemeralValue can only receive one value per step.\"\n      );\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,iBAAb,MAAa,uBAA8BA,yBAAiC;CAC1E,gBAAgB;CAEhB;CAGA,QAAsB;CAEtB,YAAY,QAAiB,MAAM;AACjC;AACA,OAAK,QAAQ;;CAGf,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,eAAsB,KAAK;AAC7C,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC;AAEjB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AAEpC,QAAK,QAAQ;AACb,UAAO;;AAET,MAAI,OAAO,WAAW,KAAK,KAAK,MAC9B,OAAM,IAAIC,kCACR;AAKJ,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS;AACrC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIC;AAEZ,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIA;AAEZ,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}
+{"version":3,"file":"ephemeral_value.cjs","names":["BaseChannel","InvalidUpdateError","EmptyChannelError"],"sources":["../../src/channels/ephemeral_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"EphemeralValue\";\n\n  guard: boolean;\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor(guard: boolean = true) {\n    super();\n    this.guard = guard;\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new EphemeralValue<Value>(this.guard);\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      // If there are no updates for this specific channel at the end of the step, wipe it.\n      this.value = [];\n      return updated;\n    }\n    if (values.length !== 1 && this.guard) {\n      throw new InvalidUpdateError(\n        \"EphemeralValue can only receive one value per step.\"\n      );\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,iBAAb,MAAa,uBAA8BA,yBAAiC;CAC1E,gBAAgB;CAEhB;CAGA,QAAsB,EAAE;CAExB,YAAY,QAAiB,MAAM;AACjC,SAAO;AACP,OAAK,QAAQ;;CAGf,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,eAAsB,KAAK,MAAM;AACnD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC,WAAW;AAE5B,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AAEpC,QAAK,QAAQ,EAAE;AACf,UAAO;;AAET,MAAI,OAAO,WAAW,KAAK,KAAK,MAC9B,OAAM,IAAIC,kCACR,sDACD;AAIH,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS,GAAG;AACxC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIA,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}

package/dist/channels/ephemeral_value.d.cts

@@ -8,7 +8,6 @@ import { BaseChannel } from "./base.cjs";
 declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {
   lc_graph_name: string;
   guard: boolean;
-  // value is an array so we don't misinterpret an update to undefined as no write
   value: [Value] | [];
   constructor(guard?: boolean);
   fromCheckpoint(checkpoint?: Value): this;

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

@@ -1 +1 @@
-{"version":3,"file":"ephemeral_value.d.cts","names":["BaseChannel","EphemeralValue","Value"],"sources":["../../src/channels/ephemeral_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    guard: boolean;\n    // value is an array so we don't misinterpret an update to undefined as no write\n    value: [Value] | [];\n    constructor(guard?: boolean);\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAIA;AAAmC,cAAdC,cAAc,CAAA,KAAA,CAAA,SAAgBD,WAAhB,CAA4BE,KAA5B,EAAmCA,KAAnC,EAA0CA,KAA1C,CAAA,CAAA;eAA4BA,EAAAA,MAAAA;OAAOA,EAAAA,OAAAA;;OAI1DA,EAAAA,CAAAA,KAAAA,CAAAA,GAAAA,EAAAA;aAEoBA,CAAAA,KAAAA,CAAAA,EAAAA,OAAAA;gBACbA,CAAAA,UAAAA,CAAAA,EADaA,KACbA,CAAAA,EAAAA,IAAAA;QACRA,CAAAA,MAAAA,EADQA,KACRA,EAAAA,CAAAA,EAAAA,OAAAA;KACOA,CAAAA,CAAAA,EADPA,KACOA;YATiCF,CAAAA,CAAAA,EASjCE,KATiCF"}
+{"version":3,"file":"ephemeral_value.d.cts","names":["BaseChannel","EphemeralValue","Value"],"sources":["../../src/channels/ephemeral_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    guard: boolean;\n    value: [Value] | [];\n    constructor(guard?: boolean);\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAIA;AAAmC,cAAdC,cAAc,CAAA,KAAA,CAAA,SAAgBD,WAAhB,CAA4BE,KAA5B,EAAmCA,KAAnC,EAA0CA,KAA1C,CAAA,CAAA;eAA4BA,EAAAA,MAAAA;OAAOA,EAAAA,OAAAA;OAAOA,EAAAA,CAGjEA,KAHiEA,CAAAA,GAAAA,EAAAA;aAGjEA,CAAAA,KAAAA,CAAAA,EAAAA,OAAAA;gBAEoBA,CAAAA,UAAAA,CAAAA,EAAAA,KAAAA,CAAAA,EAAAA,IAAAA;QACbA,CAAAA,MAAAA,EAAAA,KAAAA,EAAAA,CAAAA,EAAAA,OAAAA;KACRA,CAAAA,CAAAA,EAAAA,KAAAA;YACOA,CAAAA,CAAAA,EAAAA,KAAAA;aARiCF,CAAAA,CAAAA,EAAAA,OAAAA"}

package/dist/channels/ephemeral_value.d.ts

@@ -8,7 +8,6 @@ import { BaseChannel } from "./base.js";
 declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {
   lc_graph_name: string;
   guard: boolean;
-  // value is an array so we don't misinterpret an update to undefined as no write
   value: [Value] | [];
   constructor(guard?: boolean);
   fromCheckpoint(checkpoint?: Value): this;

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

@@ -1 +1 @@
-{"version":3,"file":"ephemeral_value.d.ts","names":["BaseChannel","EphemeralValue","Value"],"sources":["../../src/channels/ephemeral_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    guard: boolean;\n    // value is an array so we don't misinterpret an update to undefined as no write\n    value: [Value] | [];\n    constructor(guard?: boolean);\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAIA;AAAmC,cAAdC,cAAc,CAAA,KAAA,CAAA,SAAgBD,WAAhB,CAA4BE,KAA5B,EAAmCA,KAAnC,EAA0CA,KAA1C,CAAA,CAAA;eAA4BA,EAAAA,MAAAA;OAAOA,EAAAA,OAAAA;;OAI1DA,EAAAA,CAAAA,KAAAA,CAAAA,GAAAA,EAAAA;aAEoBA,CAAAA,KAAAA,CAAAA,EAAAA,OAAAA;gBACbA,CAAAA,UAAAA,CAAAA,EADaA,KACbA,CAAAA,EAAAA,IAAAA;QACRA,CAAAA,MAAAA,EADQA,KACRA,EAAAA,CAAAA,EAAAA,OAAAA;KACOA,CAAAA,CAAAA,EADPA,KACOA;YATiCF,CAAAA,CAAAA,EASjCE,KATiCF"}
+{"version":3,"file":"ephemeral_value.d.ts","names":["BaseChannel","EphemeralValue","Value"],"sources":["../../src/channels/ephemeral_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport declare class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n    lc_graph_name: string;\n    guard: boolean;\n    value: [Value] | [];\n    constructor(guard?: boolean);\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAIA;AAAmC,cAAdC,cAAc,CAAA,KAAA,CAAA,SAAgBD,WAAhB,CAA4BE,KAA5B,EAAmCA,KAAnC,EAA0CA,KAA1C,CAAA,CAAA;eAA4BA,EAAAA,MAAAA;OAAOA,EAAAA,OAAAA;OAAOA,EAAAA,CAGjEA,KAHiEA,CAAAA,GAAAA,EAAAA;aAGjEA,CAAAA,KAAAA,CAAAA,EAAAA,OAAAA;gBAEoBA,CAAAA,UAAAA,CAAAA,EAAAA,KAAAA,CAAAA,EAAAA,IAAAA;QACbA,CAAAA,MAAAA,EAAAA,KAAAA,EAAAA,CAAAA,EAAAA,OAAAA;KACRA,CAAAA,CAAAA,EAAAA,KAAAA;YACOA,CAAAA,CAAAA,EAAAA,KAAAA;aARiCF,CAAAA,CAAAA,EAAAA,OAAAA"}

package/dist/channels/ephemeral_value.js.map

@@ -1 +1 @@
-{"version":3,"file":"ephemeral_value.js","names":[],"sources":["../../src/channels/ephemeral_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"EphemeralValue\";\n\n  guard: boolean;\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor(guard: boolean = true) {\n    super();\n    this.guard = guard;\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new EphemeralValue<Value>(this.guard);\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      // If there are no updates for this specific channel at the end of the step, wipe it.\n      this.value = [];\n      return updated;\n    }\n    if (values.length !== 1 && this.guard) {\n      throw new InvalidUpdateError(\n        \"EphemeralValue can only receive one value per step.\"\n      );\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,iBAAb,MAAa,uBAA8B,YAAiC;CAC1E,gBAAgB;CAEhB;CAGA,QAAsB;CAEtB,YAAY,QAAiB,MAAM;AACjC;AACA,OAAK,QAAQ;;CAGf,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,eAAsB,KAAK;AAC7C,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC;AAEjB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AAEpC,QAAK,QAAQ;AACb,UAAO;;AAET,MAAI,OAAO,WAAW,KAAK,KAAK,MAC9B,OAAM,IAAI,mBACR;AAKJ,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS;AACrC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI;AAEZ,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI;AAEZ,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}
+{"version":3,"file":"ephemeral_value.js","names":[],"sources":["../../src/channels/ephemeral_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the value received in the step immediately preceding, clears after.\n */\nexport class EphemeralValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"EphemeralValue\";\n\n  guard: boolean;\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor(guard: boolean = true) {\n    super();\n    this.guard = guard;\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new EphemeralValue<Value>(this.guard);\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      const updated = this.value.length > 0;\n      // If there are no updates for this specific channel at the end of the step, wipe it.\n      this.value = [];\n      return updated;\n    }\n    if (values.length !== 1 && this.guard) {\n      throw new InvalidUpdateError(\n        \"EphemeralValue can only receive one value per step.\"\n      );\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,iBAAb,MAAa,uBAA8B,YAAiC;CAC1E,gBAAgB;CAEhB;CAGA,QAAsB,EAAE;CAExB,YAAY,QAAiB,MAAM;AACjC,SAAO;AACP,OAAK,QAAQ;;CAGf,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,eAAsB,KAAK,MAAM;AACnD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC,WAAW;AAE5B,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,GAAG;GACvB,MAAM,UAAU,KAAK,MAAM,SAAS;AAEpC,QAAK,QAAQ,EAAE;AACf,UAAO;;AAET,MAAI,OAAO,WAAW,KAAK,KAAK,MAC9B,OAAM,IAAI,mBACR,sDACD;AAIH,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS,GAAG;AACxC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW"}

package/dist/channels/last_value.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"last_value.cjs","names":["BaseChannel","initialValueFactory?: () => Value","InvalidUpdateError","EmptyChannelError"],"sources":["../../src/channels/last_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the last value received, can receive at most one value per step.\n *\n * Since `update` is only called once per step and value can only be of length 1,\n * LastValue always stores the last value of a single node. If multiple nodes attempt to\n * write to this channel in a single step, an error will be thrown.\n * @internal\n */\nexport class LastValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"LastValue\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor(protected initialValueFactory?: () => Value) {\n    super();\n    if (initialValueFactory) {\n      this.value = [initialValueFactory()];\n    }\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new LastValue<Value>(this.initialValueFactory);\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      return false;\n    }\n    if (values.length !== 1) {\n      throw new InvalidUpdateError(\n        \"LastValue can only receive one value per step.\",\n        { lc_error_code: \"INVALID_CONCURRENT_GRAPH_UPDATE\" }\n      );\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n\n/**\n * Stores the last value received, but only made available after finish().\n * Once made available, clears the value.\n */\nexport class LastValueAfterFinish<Value> extends BaseChannel<\n  Value,\n  Value,\n  [Value, boolean]\n> {\n  lc_graph_name = \"LastValueAfterFinish\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  finished: boolean = false;\n\n  fromCheckpoint(checkpoint?: [Value, boolean]) {\n    const empty = new LastValueAfterFinish<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      const [value, finished] = checkpoint;\n      empty.value = [value];\n      empty.finished = finished;\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      return false;\n    }\n\n    this.finished = false;\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0 || !this.finished) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): [Value, boolean] | undefined {\n    if (this.value.length === 0) return undefined;\n    return [this.value[0], this.finished];\n  }\n\n  consume(): boolean {\n    if (this.finished) {\n      this.finished = false;\n      this.value = [];\n      return true;\n    }\n    return false;\n  }\n\n  finish(): boolean {\n    if (!this.finished && this.value.length > 0) {\n      this.finished = true;\n      return true;\n    }\n    return false;\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0 && this.finished;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,IAAa,YAAb,MAAa,kBAAyBA,yBAAiC;CACrE,gBAAgB;CAGhB,QAAsB;CAEtB,YAAY,AAAUC,qBAAmC;AACvD;EADoB;AAEpB,MAAI,oBACF,MAAK,QAAQ,CAAC;;CAIlB,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,UAAiB,KAAK;AACxC,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC;AAGjB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,EACpB,QAAO;AAET,MAAI,OAAO,WAAW,EACpB,OAAM,IAAIC,kCACR,kDACA,EAAE,eAAe;AAKrB,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS;AACrC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIC;AAEZ,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIA;AAEZ,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW;;;;;;;AAQjC,IAAa,uBAAb,MAAa,6BAAoCH,yBAI/C;CACA,gBAAgB;CAGhB,QAAsB;CAEtB,WAAoB;CAEpB,eAAe,YAA+B;EAC5C,MAAM,QAAQ,IAAI;AAClB,MAAI,OAAO,eAAe,aAAa;GACrC,MAAM,CAAC,OAAO,YAAY;AAC1B,SAAM,QAAQ,CAAC;AACf,SAAM,WAAW;;AAEnB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,EACpB,QAAO;AAGT,OAAK,WAAW;AAEhB,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS;AACrC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,KAAK,CAAC,KAAK,SACnC,OAAM,IAAIG;AAEZ,SAAO,KAAK,MAAM;;CAGpB,aAA2C;AACzC,MAAI,KAAK,MAAM,WAAW,EAAG,QAAO;AACpC,SAAO,CAAC,KAAK,MAAM,IAAI,KAAK;;CAG9B,UAAmB;AACjB,MAAI,KAAK,UAAU;AACjB,QAAK,WAAW;AAChB,QAAK,QAAQ;AACb,UAAO;;AAET,SAAO;;CAGT,SAAkB;AAChB,MAAI,CAAC,KAAK,YAAY,KAAK,MAAM,SAAS,GAAG;AAC3C,QAAK,WAAW;AAChB,UAAO;;AAET,SAAO;;CAGT,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW,KAAK,KAAK"}
+{"version":3,"file":"last_value.cjs","names":["BaseChannel","InvalidUpdateError","EmptyChannelError"],"sources":["../../src/channels/last_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n/**\n * Stores the last value received, can receive at most one value per step.\n *\n * Since `update` is only called once per step and value can only be of length 1,\n * LastValue always stores the last value of a single node. If multiple nodes attempt to\n * write to this channel in a single step, an error will be thrown.\n * @internal\n */\nexport class LastValue<Value> extends BaseChannel<Value, Value, Value> {\n  lc_graph_name = \"LastValue\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  constructor(protected initialValueFactory?: () => Value) {\n    super();\n    if (initialValueFactory) {\n      this.value = [initialValueFactory()];\n    }\n  }\n\n  fromCheckpoint(checkpoint?: Value) {\n    const empty = new LastValue<Value>(this.initialValueFactory);\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = [checkpoint];\n    }\n\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      return false;\n    }\n    if (values.length !== 1) {\n      throw new InvalidUpdateError(\n        \"LastValue can only receive one value per step.\",\n        { lc_error_code: \"INVALID_CONCURRENT_GRAPH_UPDATE\" }\n      );\n    }\n\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): Value {\n    if (this.value.length === 0) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0;\n  }\n}\n\n/**\n * Stores the last value received, but only made available after finish().\n * Once made available, clears the value.\n */\nexport class LastValueAfterFinish<Value> extends BaseChannel<\n  Value,\n  Value,\n  [Value, boolean]\n> {\n  lc_graph_name = \"LastValueAfterFinish\";\n\n  // value is an array so we don't misinterpret an update to undefined as no write\n  value: [Value] | [] = [];\n\n  finished: boolean = false;\n\n  fromCheckpoint(checkpoint?: [Value, boolean]) {\n    const empty = new LastValueAfterFinish<Value>();\n    if (typeof checkpoint !== \"undefined\") {\n      const [value, finished] = checkpoint;\n      empty.value = [value];\n      empty.finished = finished;\n    }\n    return empty as this;\n  }\n\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      return false;\n    }\n\n    this.finished = false;\n    // eslint-disable-next-line prefer-destructuring\n    this.value = [values[values.length - 1]];\n    return true;\n  }\n\n  get(): Value {\n    if (this.value.length === 0 || !this.finished) {\n      throw new EmptyChannelError();\n    }\n    return this.value[0];\n  }\n\n  checkpoint(): [Value, boolean] | undefined {\n    if (this.value.length === 0) return undefined;\n    return [this.value[0], this.finished];\n  }\n\n  consume(): boolean {\n    if (this.finished) {\n      this.finished = false;\n      this.value = [];\n      return true;\n    }\n    return false;\n  }\n\n  finish(): boolean {\n    if (!this.finished && this.value.length > 0) {\n      this.finished = true;\n      return true;\n    }\n    return false;\n  }\n\n  isAvailable(): boolean {\n    return this.value.length !== 0 && this.finished;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,IAAa,YAAb,MAAa,kBAAyBA,yBAAiC;CACrE,gBAAgB;CAGhB,QAAsB,EAAE;CAExB,YAAY,AAAU,qBAAmC;AACvD,SAAO;EADa;AAEpB,MAAI,oBACF,MAAK,QAAQ,CAAC,qBAAqB,CAAC;;CAIxC,eAAe,YAAoB;EACjC,MAAM,QAAQ,IAAI,UAAiB,KAAK,oBAAoB;AAC5D,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ,CAAC,WAAW;AAG5B,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,EACpB,QAAO;AAET,MAAI,OAAO,WAAW,EACpB,OAAM,IAAIC,kCACR,kDACA,EAAE,eAAe,mCAAmC,CACrD;AAIH,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS,GAAG;AACxC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,aAAoB;AAClB,MAAI,KAAK,MAAM,WAAW,EACxB,OAAM,IAAIA,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW;;;;;;;AAQjC,IAAa,uBAAb,MAAa,6BAAoCF,yBAI/C;CACA,gBAAgB;CAGhB,QAAsB,EAAE;CAExB,WAAoB;CAEpB,eAAe,YAA+B;EAC5C,MAAM,QAAQ,IAAI,sBAA6B;AAC/C,MAAI,OAAO,eAAe,aAAa;GACrC,MAAM,CAAC,OAAO,YAAY;AAC1B,SAAM,QAAQ,CAAC,MAAM;AACrB,SAAM,WAAW;;AAEnB,SAAO;;CAGT,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,EACpB,QAAO;AAGT,OAAK,WAAW;AAEhB,OAAK,QAAQ,CAAC,OAAO,OAAO,SAAS,GAAG;AACxC,SAAO;;CAGT,MAAa;AACX,MAAI,KAAK,MAAM,WAAW,KAAK,CAAC,KAAK,SACnC,OAAM,IAAIE,kCAAmB;AAE/B,SAAO,KAAK,MAAM;;CAGpB,aAA2C;AACzC,MAAI,KAAK,MAAM,WAAW,EAAG,QAAO;AACpC,SAAO,CAAC,KAAK,MAAM,IAAI,KAAK,SAAS;;CAGvC,UAAmB;AACjB,MAAI,KAAK,UAAU;AACjB,QAAK,WAAW;AAChB,QAAK,QAAQ,EAAE;AACf,UAAO;;AAET,SAAO;;CAGT,SAAkB;AAChB,MAAI,CAAC,KAAK,YAAY,KAAK,MAAM,SAAS,GAAG;AAC3C,QAAK,WAAW;AAChB,UAAO;;AAET,SAAO;;CAGT,cAAuB;AACrB,SAAO,KAAK,MAAM,WAAW,KAAK,KAAK"}

package/dist/channels/last_value.d.cts

@@ -13,7 +13,6 @@ import { BaseChannel } from "./base.cjs";
 declare class LastValue<Value> extends BaseChannel<Value, Value, Value> {
   protected initialValueFactory?: (() => Value) | undefined;
   lc_graph_name: string;
-  // value is an array so we don't misinterpret an update to undefined as no write
   value: [Value] | [];
   constructor(initialValueFactory?: (() => Value) | undefined);
   fromCheckpoint(checkpoint?: Value): this;
@@ -28,7 +27,6 @@ declare class LastValue<Value> extends BaseChannel<Value, Value, Value> {
  */
 declare class LastValueAfterFinish<Value> extends BaseChannel<Value, Value, [Value, boolean]> {
   lc_graph_name: string;
-  // value is an array so we don't misinterpret an update to undefined as no write
   value: [Value] | [];
   finished: boolean;
   fromCheckpoint(checkpoint?: [Value, boolean]): this;

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

@@ -1 +1 @@
-{"version":3,"file":"last_value.d.cts","names":["BaseChannel","LastValue","Value","LastValueAfterFinish"],"sources":["../../src/channels/last_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, can receive at most one value per step.\n *\n * Since `update` is only called once per step and value can only be of length 1,\n * LastValue always stores the last value of a single node. If multiple nodes attempt to\n * write to this channel in a single step, an error will be thrown.\n * @internal\n */\nexport declare class LastValue<Value> extends BaseChannel<Value, Value, Value> {\n    protected initialValueFactory?: (() => Value) | undefined;\n    lc_graph_name: string;\n    // value is an array so we don't misinterpret an update to undefined as no write\n    value: [Value] | [];\n    constructor(initialValueFactory?: (() => Value) | undefined);\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n/**\n * Stores the last value received, but only made available after finish().\n * Once made available, clears the value.\n */\nexport declare class LastValueAfterFinish<Value> extends BaseChannel<Value, Value, [\n    Value,\n    boolean\n]> {\n    lc_graph_name: string;\n    // value is an array so we don't misinterpret an update to undefined as no write\n    value: [Value] | [];\n    finished: boolean;\n    fromCheckpoint(checkpoint?: [Value, boolean]): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): [Value, boolean] | undefined;\n    consume(): boolean;\n    finish(): boolean;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AASA;;;;;;AAIYE,cAJSD,SAITC,CAAAA,KAAAA,CAAAA,SAJkCF,WAIlCE,CAJ8CA,KAI9CA,EAJqDA,KAIrDA,EAJ4DA,KAI5DA,CAAAA,CAAAA;YACiCA,mBAAAA,CAAAA,EAAAA,CAAAA,GAAAA,GAJFA,KAIEA,CAAAA,GAAAA,SAAAA;eACbA,EAAAA,MAAAA;;OAErBA,EAAAA,CAJCA,KAIDA,CAAAA,GAAAA,EAAAA;aACOA,CAAAA,mBAAAA,CAAAA,EAAAA,CAAAA,GAAAA,GAJ2BA,KAI3BA,CAAAA,GAAAA,SAAAA;gBAT4BF,CAAAA,UAAAA,CAAAA,EAMdE,KANcF,CAAAA,EAAAA,IAAAA;iBAO3BE;EASEC,GAAAA,CAAAA,CAAAA,EARVD,KAQUC;EAAoB,UAAA,CAAA,CAAA,EAPvBD,KAOuB;aAA4BA,CAAAA,CAAAA,EAAAA,OAAAA;;;;;;AAU1DA,cAVUC,oBAUVD,CAAAA,KAAAA,CAAAA,SAV8CF,WAU9CE,CAV0DA,KAU1DA,EAViEA,KAUjEA,EAAAA,CATPA,KAUeA,SAXsCF;;;UAM7CE;;+BAEqBA;iBACdA;SACRA;iBACQA"}
+{"version":3,"file":"last_value.d.cts","names":["BaseChannel","LastValue","Value","LastValueAfterFinish"],"sources":["../../src/channels/last_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, can receive at most one value per step.\n *\n * Since `update` is only called once per step and value can only be of length 1,\n * LastValue always stores the last value of a single node. If multiple nodes attempt to\n * write to this channel in a single step, an error will be thrown.\n * @internal\n */\nexport declare class LastValue<Value> extends BaseChannel<Value, Value, Value> {\n    protected initialValueFactory?: (() => Value) | undefined;\n    lc_graph_name: string;\n    value: [Value] | [];\n    constructor(initialValueFactory?: (() => Value) | undefined);\n    fromCheckpoint(checkpoint?: Value): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): Value;\n    isAvailable(): boolean;\n}\n/**\n * Stores the last value received, but only made available after finish().\n * Once made available, clears the value.\n */\nexport declare class LastValueAfterFinish<Value> extends BaseChannel<Value, Value, [\n    Value,\n    boolean\n]> {\n    lc_graph_name: string;\n    value: [Value] | [];\n    finished: boolean;\n    fromCheckpoint(checkpoint?: [Value, boolean]): this;\n    update(values: Value[]): boolean;\n    get(): Value;\n    checkpoint(): [Value, boolean] | undefined;\n    consume(): boolean;\n    finish(): boolean;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AASA;;;;;;AAGYE,cAHSD,SAGTC,CAAAA,KAAAA,CAAAA,SAHkCF,WAGlCE,CAH8CA,KAG9CA,EAHqDA,KAGrDA,EAH4DA,KAG5DA,CAAAA,CAAAA;YACiCA,mBAAAA,CAAAA,EAAAA,CAAAA,GAAAA,GAHFA,KAGEA,CAAAA,GAAAA,SAAAA;eACbA,EAAAA,MAAAA;OACbA,EAAAA,CAHPA,KAGOA,CAAAA,GAAAA,EAAAA;aACRA,CAAAA,mBAAAA,CAAAA,EAAAA,CAAAA,GAAAA,GAHkCA,KAGlCA,CAAAA,GAAAA,SAAAA;gBACOA,CAAAA,UAAAA,CAAAA,EAHcA,KAGdA,CAAAA,EAAAA,IAAAA;QAR4BF,CAAAA,MAAAA,EAM3BE,KAN2BF,EAAAA,CAAAA,EAAAA,OAAAA;EAAW,GAAA,CAAA,CAAA,EAO9CE,KAP8C;EAepCC,UAAAA,CAAAA,CAAAA,EAPHD,KAOGC;EAAoB,WAAA,CAAA,CAAA,EAAA,OAAA;;;;;;AAQtBD,cAREC,oBAQFD,CAAAA,KAAAA,CAAAA,SARsCF,WAQtCE,CARkDA,KAQlDA,EARyDA,KAQzDA,EAAAA,CAPfA,KAQOA,SACQA;EAViD,aAAA,EAAA,MAAA;UAKxDA;;+BAEqBA;iBACdA;SACRA;iBACQA"}