@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/zero-cache/src/types/subscription.js

@@ -1,216 +1,268 @@
-import { resolver } from "@rocicorp/resolver";
 import { assert } from "../../../shared/src/asserts.js";
-class Subscription {
-  /**
-   * Convenience factory method for creating a {@link Subscription} with internal message type
-   * `M` as a subtype of `T`, defaulting to the same type. The default `publish` method publishes
-   * the message of type `M` directly to the AsyncIterable.
-   */
-  static create(options = {}, publish = (m) => m) {
-    return new Subscription(options, publish);
-  }
-  // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).
-  #consumers = [];
-  // Messages waiting to be consumed.
-  #messages = [];
-  #pipelineEnabled;
-  // Sentinel value signaling that the subscription is "done" and no more
-  // messages can be added.
-  #sentinel = void 0;
-  #coalesce;
-  #consumed;
-  #cleanup;
-  #publish;
-  /**
-   * @param publish function for converting the internally pushed / coalesced message
-   *        of type `M` to the external type `T` exposed via async iteration.
-   */
-  constructor(options = {}, publish) {
-    const {
-      coalesce,
-      consumed = () => {
-      },
-      cleanup = () => {
-      },
-      pipeline = coalesce === void 0
-    } = options;
-    this.#coalesce = !coalesce ? void 0 : (curr, prev) => {
-      try {
-        return coalesce(curr.value, prev.value);
-      } finally {
-        prev.resolve("coalesced");
-      }
-    };
-    this.#consumed = (entry) => {
-      consumed(entry.value);
-      entry.resolve("consumed");
-    };
-    this.#cleanup = (entries, err) => {
-      cleanup(
-        entries.map((e) => e.value),
-        err
-      );
-      entries.forEach((e) => e.resolve("unconsumed"));
-    };
-    this.#publish = publish;
-    this.#pipelineEnabled = pipeline;
-  }
-  /**
-   * Pushes the next message to be consumed, and returns a `result` that resolves to the
-   * eventual {@link Result} of the `value`.
-   *
-   * If there is an existing unconsumed message and the Subscription has a
-   * {@link Options#coalesce coalesce} function, the specified `value` will be coalesced
-   * with the pending message. In this case, the result of the pending message
-   * is resolved to `coalesced`, regardless of the `coalesce` function implementation.
-   *
-   * If the subscription is in a terminal state, the message is dropped and the
-   * result resolves to `unconsumed`.
-   */
-  push(value) {
-    const { promise: result, resolve } = resolver();
-    const entry = { value, resolve };
-    if (this.#sentinel) {
-      entry.resolve("unconsumed");
-      return { result };
-    }
-    const consumer = this.#consumers.shift();
-    if (consumer) {
-      consumer.resolve(entry);
-    } else if (this.#coalesce && this.#messages.length && this.#messages[this.#messages.length - 1] !== "terminus") {
-      const prev = this.#messages[this.#messages.length - 1];
-      assert(prev !== "terminus", "prev should not be terminus after check");
-      this.#messages[this.#messages.length - 1] = {
-        value: this.#coalesce(entry, prev),
-        resolve
-      };
-    } else {
-      this.#messages.push(entry);
-    }
-    return { result };
-  }
-  /** False if the subscription has been canceled or has failed. */
-  get active() {
-    return this.#sentinel === void 0;
-  }
-  /** The number messages waiting to be consumed. */
-  get queued() {
-    return this.#messages.length;
-  }
-  /**
-   * Cancels the subscription after any queued messages are consumed. This is
-   * meant for the producer-side code.
-   *
-   * Any messages pushed after calling `end()` will be unconsumed as if
-   * `cancel()` were called (once the first set of pending messages is
-   * consumed). In particular, if a coalesce function is defined, the new
-   * messages will not be coalesced with the messages enqueued before `end()`
-   * was called. However, to effect the intent of memory efficiency, multiple
-   * messages pushed after calling `end()` will be coalesced together.
-   *
-   */
-  end() {
-    if (this.#sentinel) ;
-    else if (this.#messages.length === 0) {
-      this.cancel();
-    } else {
-      this.#messages.push("terminus");
-    }
-  }
-  /**
-   * Cancels the subscription immediately, cleans up, and terminates any iteration.
-   * This is intended for the consumer to call when it is no longer interested
-   * in the subscription.
-   *
-   * @param err If an `err` is specified, an iteration over the Subscription /
-   *        Sink will throw the `err` (equivalent to the producer calling
-   *        {@link fail()}). If undefined, the iteration will exit gracefully.
-   */
-  cancel(err) {
-    this.#terminate(err ?? "canceled");
-  }
-  /** Fails the subscription, cleans up, and throws from any iteration. */
-  fail(err) {
-    this.#terminate(err);
-  }
-  #terminate(sentinel) {
-    if (!this.#sentinel) {
-      this.#sentinel = sentinel;
-      this.#cleanup(
-        this.#messages.filter((m) => m !== "terminus"),
-        sentinel instanceof Error ? sentinel : void 0
-      );
-      this.#messages.splice(0);
-      for (let consumer = this.#consumers.shift(); consumer; consumer = this.#consumers.shift()) {
-        sentinel === "canceled" ? consumer.resolve(null) : consumer.reject(sentinel);
-      }
-    }
-  }
-  get pipeline() {
-    return this.#pipelineEnabled ? { [Symbol.asyncIterator]: () => this.#pipeline() } : void 0;
-  }
-  #pipeline() {
-    return {
-      next: async () => {
-        const entry = this.#messages.shift();
-        if (entry === "terminus") {
-          this.cancel();
-          return { value: void 0, done: true };
-        }
-        if (entry !== void 0) {
-          return {
-            value: {
-              value: this.#publish(entry.value),
-              consumed: () => this.#consumed(entry)
-            }
-          };
-        }
-        if (this.#sentinel === "canceled") {
-          return { value: void 0, done: true };
-        }
-        if (this.#sentinel) {
-          return Promise.reject(this.#sentinel);
-        }
-        const consumer = resolver();
-        this.#consumers.push(consumer);
-        const result = await consumer.promise;
-        return result ? {
-          value: {
-            value: this.#publish(result.value),
-            consumed: () => this.#consumed(result)
-          }
-        } : { value: void 0, done: true };
-      },
-      return: (value) => {
-        this.cancel();
-        return Promise.resolve({ value, done: true });
-      }
-    };
-  }
-  [Symbol.asyncIterator]() {
-    const delegate = this.#pipeline();
-    let prevConsumed = () => {
-    };
-    return {
-      next: async () => {
-        prevConsumed();
-        const entry = await delegate.next();
-        if (entry.done) {
-          return entry;
-        }
-        const { value, consumed } = entry.value;
-        prevConsumed = consumed;
-        return { value };
-      },
-      return: (value) => {
-        prevConsumed();
-        this.cancel();
-        return Promise.resolve({ value, done: true });
-      }
-    };
-  }
-}
-export {
-  Subscription
+import { resolver } from "@rocicorp/resolver";
+//#region ../zero-cache/src/types/subscription.ts
+/**
+* A Subscription abstracts a continuous, logically infinite stream of messages intended
+* for serial processing. Unlike the more general Node `Stream` API, a Subscription has
+* a limited API with specific semantics:
+*
+* * **Serial processing**: Messages must be consumed via the {@link AsyncIterable}
+*   interface, e.g.
+*   ```ts
+*   const subscription = server.subscribe(parameters);
+*
+*   for await (const message of subscription) {
+*     await process(message);  // fully process the message before consuming the next
+*   }
+*   ```
+*
+*   Moreover, the consumer is expected to completely process each message before
+*   requesting the next. This is important for cleanup semantics (explained later).
+*
+* * **cancel()**, not close(): The underlying data in a subscription is logically infinite
+*   and only terminated when the consumer is no longer interested in receiving the messages
+*   (or requires a Subscription with a different configuration). As such, there is no API
+*   for gracefully closing the subscription after pending messages are consumed; rather,
+*   cancellation is immediate, and upon cancellation, pending messages are dropped. A
+*   Subscription can also be terminated with exceptional (i.e. `Error`) circumstances,
+*   for which the behavior is equivalent.
+*
+* * **Coalescing** (optional): A producer can configure pending messages in the Subscription
+*   to be merged together with a {@link Options.coalesce coalesce} function. This is useful
+*   for semantics in which the consumer is not necessarily interested in every incremental
+*   change, but rather the cumulative change since the last processed message. A
+*   Subscription with coalescing is guaranteed to have at most one outstanding message,
+*   regardless of how quickly messages are produced and consumed. This effectively constrains
+*   the amount of outstanding work in the system.
+*
+* ### Resource Tracking and Cleanup
+*
+* Because message consumption is constrained to the async iteration API, standard
+* control flow mechanisms allow the producer to perform bookkeeping without any
+* explicit cleanup actions on the part of the consumer. This includes:
+*
+* * **Per-message cleanup**: Each request for the {@link AsyncIterator.next next}
+*   message, or the termination of the iteration, signals that the consumer has
+*   finished processing the previous message. The producer of a Subscription can
+*   supply a {@link Options.consumed consumed} callback to receive these processed
+*   messages, allowing it to clean up attached resources (e.g. TransactionPools, etc.).
+*
+* * **Per-subscription cleanup**: The producer of a Subscription can supply a
+*   {@link Options.cleanup cleanup} callback that is invoked when the Subscription
+*   is terminated, either explicitly via {@link Subscription.cancel cancel()} /
+*   {@link Subscription.fail fail()}, or implicitly when an iteration is exited via a
+*  `break`, `return`, or `throw` statement. All unconsumed messages are passed to the
+*   call back to facilitate bookkeeping.
+*
+* @param T The external message type, published to the AsyncIterable
+* @param M The internal message type used in the producer-side interfaces
+*          (e.g. {@link push}, {@link Options.consumed}, {@link Options.coalesce},
+*          and {@link Options.cleanup}). This is often the same as the external type
+*          T, but may be diverged to facilitate internal bookkeeping.
+*/
+var Subscription = class Subscription {
+	/**
+	* Convenience factory method for creating a {@link Subscription} with internal message type
+	* `M` as a subtype of `T`, defaulting to the same type. The default `publish` method publishes
+	* the message of type `M` directly to the AsyncIterable.
+	*/
+	static create(options = {}, publish = (m) => m) {
+		return new Subscription(options, publish);
+	}
+	#consumers = [];
+	#messages = [];
+	#consuming = /* @__PURE__ */ new Set();
+	#pipelineEnabled;
+	#sentinel = void 0;
+	#coalesce;
+	#consumed;
+	#cleanup;
+	#publish;
+	/**
+	* @param publish function for converting the internally pushed / coalesced message
+	*        of type `M` to the external type `T` exposed via async iteration.
+	*/
+	constructor(options = {}, publish) {
+		const { coalesce, consumed = () => {}, cleanup = () => {}, pipeline = coalesce === void 0 } = options;
+		this.#coalesce = !coalesce ? void 0 : (curr, prev) => {
+			try {
+				return coalesce(curr.value, prev.value);
+			} finally {
+				prev.resolve("coalesced");
+			}
+		};
+		this.#consumed = (entry) => {
+			consumed(entry.value);
+			this.#consuming.delete(entry);
+			entry.resolve("consumed");
+		};
+		this.#cleanup = (entries, err) => {
+			cleanup(entries.map((e) => e.value), err);
+			entries.forEach((e) => e.resolve("unconsumed"));
+		};
+		this.#publish = publish;
+		this.#pipelineEnabled = pipeline;
+	}
+	/**
+	* Pushes the next message to be consumed, and returns a `result` that resolves to the
+	* eventual {@link Result} of the `value`.
+	*
+	* If there is an existing unconsumed message and the Subscription has a
+	* {@link Options#coalesce coalesce} function, the specified `value` will be coalesced
+	* with the pending message. In this case, the result of the pending message
+	* is resolved to `coalesced`, regardless of the `coalesce` function implementation.
+	*
+	* If the subscription is in a terminal state, the message is dropped and the
+	* result resolves to `unconsumed`.
+	*/
+	push(value) {
+		const { promise: result, resolve } = resolver();
+		const entry = {
+			value,
+			resolve
+		};
+		if (this.#sentinel) {
+			entry.resolve("unconsumed");
+			return { result };
+		}
+		const consumer = this.#consumers.shift();
+		if (consumer) consumer.resolve(entry);
+		else if (this.#coalesce && this.#messages.length && this.#messages[this.#messages.length - 1] !== "terminus") {
+			const prev = this.#messages[this.#messages.length - 1];
+			assert(prev !== "terminus", "prev should not be terminus after check");
+			this.#messages[this.#messages.length - 1] = {
+				value: this.#coalesce(entry, prev),
+				resolve
+			};
+		} else this.#messages.push(entry);
+		return { result };
+	}
+	/** False if the subscription has been canceled or has failed. */
+	get active() {
+		return this.#sentinel === void 0;
+	}
+	/** The number of messages waiting to be dequeued. */
+	get queued() {
+		return this.#messages.length;
+	}
+	/** The number of messages dequeued but not yet "consumed" */
+	get consuming() {
+		return this.#consuming.size;
+	}
+	/**
+	* Cancels the subscription after any queued messages are consumed. This is
+	* meant for the producer-side code.
+	*
+	* Any messages pushed after calling `end()` will be unconsumed as if
+	* `cancel()` were called (once the first set of pending messages is
+	* consumed). In particular, if a coalesce function is defined, the new
+	* messages will not be coalesced with the messages enqueued before `end()`
+	* was called. However, to effect the intent of memory efficiency, multiple
+	* messages pushed after calling `end()` will be coalesced together.
+	*
+	*/
+	end() {
+		if (this.#sentinel) {} else if (this.#messages.length === 0) this.cancel();
+		else this.#messages.push("terminus");
+	}
+	/**
+	* Cancels the subscription immediately, cleans up, and terminates any iteration.
+	* This is intended for the consumer to call when it is no longer interested
+	* in the subscription.
+	*
+	* @param err If an `err` is specified, an iteration over the Subscription /
+	*        Sink will throw the `err` (equivalent to the producer calling
+	*        {@link fail()}). If undefined, the iteration will exit gracefully.
+	*/
+	cancel(err) {
+		this.#terminate(err ?? "canceled");
+	}
+	/** Fails the subscription, cleans up, and throws from any iteration. */
+	fail(err) {
+		this.#terminate(err);
+	}
+	#terminate(sentinel) {
+		if (!this.#sentinel) {
+			this.#sentinel = sentinel;
+			this.#cleanup([...this.#consuming, ...this.#messages.filter((m) => m !== "terminus")], sentinel instanceof Error ? sentinel : void 0);
+			this.#messages.splice(0);
+			for (let consumer = this.#consumers.shift(); consumer; consumer = this.#consumers.shift()) sentinel === "canceled" ? consumer.resolve(null) : consumer.reject(sentinel);
+		}
+	}
+	get pipeline() {
+		return this.#pipelineEnabled ? { [Symbol.asyncIterator]: () => this.#pipeline() } : void 0;
+	}
+	#pipeline() {
+		return {
+			next: async () => {
+				const entry = this.#messages.shift();
+				if (entry === "terminus") {
+					this.cancel();
+					return {
+						value: void 0,
+						done: true
+					};
+				}
+				if (entry !== void 0) {
+					this.#consuming.add(entry);
+					return { value: {
+						value: this.#publish(entry.value),
+						consumed: () => this.#consumed(entry)
+					} };
+				}
+				if (this.#sentinel === "canceled") return {
+					value: void 0,
+					done: true
+				};
+				if (this.#sentinel) return Promise.reject(this.#sentinel);
+				const consumer = resolver();
+				this.#consumers.push(consumer);
+				const result = await consumer.promise;
+				if (result !== null) {
+					this.#consuming.add(result);
+					return { value: {
+						value: this.#publish(result.value),
+						consumed: () => this.#consumed(result)
+					} };
+				}
+				return {
+					value: void 0,
+					done: true
+				};
+			},
+			return: (value) => {
+				this.cancel();
+				return Promise.resolve({
+					value,
+					done: true
+				});
+			}
+		};
+	}
+	[Symbol.asyncIterator]() {
+		const delegate = this.#pipeline();
+		let prevConsumed = () => {};
+		return {
+			next: async () => {
+				prevConsumed();
+				const entry = await delegate.next();
+				if (entry.done) return entry;
+				const { value, consumed } = entry.value;
+				prevConsumed = consumed;
+				return { value };
+			},
+			return: (value) => {
+				prevConsumed();
+				this.cancel();
+				return Promise.resolve({
+					value,
+					done: true
+				});
+			}
+		};
+	}
 };
-//# sourceMappingURL=subscription.js.map
+//#endregion
+export { Subscription };
+
+//# sourceMappingURL=subscription.js.map

package/out/zero-cache/src/types/subscription.js.map

@@ -1 +1 @@
-{"version":3,"file":"subscription.js","sources":["../../../../../zero-cache/src/types/subscription.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Sink, Source} from './streams.ts';\n\n/**\n * A Subscription abstracts a continuous, logically infinite stream of messages intended\n * for serial processing. Unlike the more general Node `Stream` API, a Subscription has\n * a limited API with specific semantics:\n *\n * * **Serial processing**: Messages must be consumed via the {@link AsyncIterable}\n *   interface, e.g.\n *   ```ts\n *   const subscription = server.subscribe(parameters);\n *\n *   for await (const message of subscription) {\n *     await process(message);  // fully process the message before consuming the next\n *   }\n *   ```\n *\n *   Moreover, the consumer is expected to completely process each message before\n *   requesting the next. This is important for cleanup semantics (explained later).\n *\n * * **cancel()**, not close(): The underlying data in a subscription is logically infinite\n *   and only terminated when the consumer is no longer interested in receiving the messages\n *   (or requires a Subscription with a different configuration). As such, there is no API\n *   for gracefully closing the subscription after pending messages are consumed; rather,\n *   cancellation is immediate, and upon cancellation, pending messages are dropped. A\n *   Subscription can also be terminated with exceptional (i.e. `Error`) circumstances,\n *   for which the behavior is equivalent.\n *\n * * **Coalescing** (optional): A producer can configure pending messages in the Subscription\n *   to be merged together with a {@link Options.coalesce coalesce} function. This is useful\n *   for semantics in which the consumer is not necessarily interested in every incremental\n *   change, but rather the cumulative change since the last processed message. A\n *   Subscription with coalescing is guaranteed to have at most one outstanding message,\n *   regardless of how quickly messages are produced and consumed. This effectively constrains\n *   the amount of outstanding work in the system.\n *\n * ### Resource Tracking and Cleanup\n *\n * Because message consumption is constrained to the async iteration API, standard\n * control flow mechanisms allow the producer to perform bookkeeping without any\n * explicit cleanup actions on the part of the consumer. This includes:\n *\n * * **Per-message cleanup**: Each request for the {@link AsyncIterator.next next}\n *   message, or the termination of the iteration, signals that the consumer has\n *   finished processing the previous message. The producer of a Subscription can\n *   supply a {@link Options.consumed consumed} callback to receive these processed\n *   messages, allowing it to clean up attached resources (e.g. TransactionPools, etc.).\n *\n * * **Per-subscription cleanup**: The producer of a Subscription can supply a\n *   {@link Options.cleanup cleanup} callback that is invoked when the Subscription\n *   is terminated, either explicitly via {@link Subscription.cancel cancel()} /\n *   {@link Subscription.fail fail()}, or implicitly when an iteration is exited via a\n *  `break`, `return`, or `throw` statement. All unconsumed messages are passed to the\n *   call back to facilitate bookkeeping.\n *\n * @param T The external message type, published to the AsyncIterable\n * @param M The internal message type used in the producer-side interfaces\n *          (e.g. {@link push}, {@link Options.consumed}, {@link Options.coalesce},\n *          and {@link Options.cleanup}). This is often the same as the external type\n *          T, but may be diverged to facilitate internal bookkeeping.\n */\nexport class Subscription<T, M = T> implements Source<T>, Sink<M> {\n  /**\n   * Convenience factory method for creating a {@link Subscription} with internal message type\n   * `M` as a subtype of `T`, defaulting to the same type. The default `publish` method publishes\n   * the message of type `M` directly to the AsyncIterable.\n   */\n  static create<T, M extends T = T>(\n    options: Options<M> = {},\n    publish: (m: M) => T = m => m,\n  ) {\n    return new Subscription(options, publish);\n  }\n\n  // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).\n  readonly #consumers: Resolver<Entry<M> | null>[] = [];\n  // Messages waiting to be consumed.\n  readonly #messages: (Entry<M> | 'terminus')[] = [];\n  readonly #pipelineEnabled: boolean;\n  // Sentinel value signaling that the subscription is \"done\" and no more\n  // messages can be added.\n  #sentinel: 'canceled' | Error | undefined = undefined;\n\n  #coalesce: ((curr: Entry<M>, prev: Entry<M>) => M) | undefined;\n  #consumed: (prev: Entry<M>) => void;\n  #cleanup: (unconsumed: Entry<M>[], err?: Error) => void;\n  #publish: (internal: M) => T;\n\n  /**\n   * @param publish function for converting the internally pushed / coalesced message\n   *        of type `M` to the external type `T` exposed via async iteration.\n   */\n  constructor(options: Options<M> = {}, publish: (m: M) => T) {\n    const {\n      coalesce,\n      consumed = () => {},\n      cleanup = () => {},\n      pipeline = coalesce === undefined,\n    } = options;\n\n    this.#coalesce = !coalesce\n      ? undefined\n      : (curr, prev) => {\n          try {\n            return coalesce(curr.value, prev.value);\n          } finally {\n            prev.resolve('coalesced');\n          }\n        };\n\n    this.#consumed = entry => {\n      consumed(entry.value);\n      entry.resolve('consumed');\n    };\n\n    this.#cleanup = (entries, err) => {\n      cleanup(\n        entries.map(e => e.value),\n        err,\n      );\n      entries.forEach(e => e.resolve('unconsumed'));\n    };\n\n    this.#publish = publish;\n\n    this.#pipelineEnabled = pipeline;\n  }\n\n  /**\n   * Pushes the next message to be consumed, and returns a `result` that resolves to the\n   * eventual {@link Result} of the `value`.\n   *\n   * If there is an existing unconsumed message and the Subscription has a\n   * {@link Options#coalesce coalesce} function, the specified `value` will be coalesced\n   * with the pending message. In this case, the result of the pending message\n   * is resolved to `coalesced`, regardless of the `coalesce` function implementation.\n   *\n   * If the subscription is in a terminal state, the message is dropped and the\n   * result resolves to `unconsumed`.\n   */\n  push(value: M): PendingResult {\n    const {promise: result, resolve} = resolver<Result>();\n    const entry = {value, resolve};\n\n    if (this.#sentinel) {\n      entry.resolve('unconsumed');\n      return {result};\n    }\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolve(entry);\n    } else if (\n      this.#coalesce &&\n      this.#messages.length &&\n      this.#messages[this.#messages.length - 1] !== 'terminus'\n    ) {\n      const prev = this.#messages[this.#messages.length - 1];\n      assert(prev !== 'terminus', 'prev should not be terminus after check');\n      this.#messages[this.#messages.length - 1] = {\n        value: this.#coalesce(entry, prev),\n        resolve,\n      };\n    } else {\n      this.#messages.push(entry);\n    }\n    return {result};\n  }\n\n  /** False if the subscription has been canceled or has failed. */\n  get active(): boolean {\n    return this.#sentinel === undefined;\n  }\n\n  /** The number messages waiting to be consumed. */\n  get queued(): number {\n    return this.#messages.length;\n  }\n\n  /**\n   * Cancels the subscription after any queued messages are consumed. This is\n   * meant for the producer-side code.\n   *\n   * Any messages pushed after calling `end()` will be unconsumed as if\n   * `cancel()` were called (once the first set of pending messages is\n   * consumed). In particular, if a coalesce function is defined, the new\n   * messages will not be coalesced with the messages enqueued before `end()`\n   * was called. However, to effect the intent of memory efficiency, multiple\n   * messages pushed after calling `end()` will be coalesced together.\n   *\n   */\n  end() {\n    if (this.#sentinel) {\n      // already terminated\n    } else if (this.#messages.length === 0) {\n      this.cancel();\n    } else {\n      this.#messages.push('terminus');\n    }\n  }\n\n  /**\n   * Cancels the subscription immediately, cleans up, and terminates any iteration.\n   * This is intended for the consumer to call when it is no longer interested\n   * in the subscription.\n   *\n   * @param err If an `err` is specified, an iteration over the Subscription /\n   *        Sink will throw the `err` (equivalent to the producer calling\n   *        {@link fail()}). If undefined, the iteration will exit gracefully.\n   */\n  cancel(err?: Error) {\n    this.#terminate(err ?? 'canceled');\n  }\n\n  /** Fails the subscription, cleans up, and throws from any iteration. */\n  fail(err: Error) {\n    this.#terminate(err);\n  }\n\n  #terminate(sentinel: 'canceled' | Error) {\n    if (!this.#sentinel) {\n      this.#sentinel = sentinel;\n      this.#cleanup(\n        this.#messages.filter(m => m !== 'terminus'),\n        sentinel instanceof Error ? sentinel : undefined,\n      );\n      this.#messages.splice(0);\n\n      for (\n        let consumer = this.#consumers.shift();\n        consumer;\n        consumer = this.#consumers.shift()\n      ) {\n        sentinel === 'canceled'\n          ? consumer.resolve(null)\n          : consumer.reject(sentinel);\n      }\n    }\n  }\n\n  get pipeline(): AsyncIterable<{value: T; consumed: () => void}> | undefined {\n    return this.#pipelineEnabled\n      ? {[Symbol.asyncIterator]: () => this.#pipeline()}\n      : undefined;\n  }\n\n  #pipeline(): AsyncIterator<{value: T; consumed: () => void}> {\n    return {\n      next: async () => {\n        const entry = this.#messages.shift();\n        if (entry === 'terminus') {\n          this.cancel();\n          return {value: undefined, done: true};\n        }\n        if (entry !== undefined) {\n          return {\n            value: {\n              value: this.#publish(entry.value),\n              consumed: () => this.#consumed(entry),\n            },\n          };\n        }\n        if (this.#sentinel === 'canceled') {\n          return {value: undefined, done: true};\n        }\n        if (this.#sentinel) {\n          return Promise.reject(this.#sentinel);\n        }\n        const consumer = resolver<Entry<M> | null>();\n        this.#consumers.push(consumer);\n\n        // Wait for push() (or termination) to resolve the consumer.\n        const result = await consumer.promise;\n        return result\n          ? {\n              value: {\n                value: this.#publish(result.value),\n                consumed: () => this.#consumed(result),\n              },\n            }\n          : {value: undefined, done: true};\n      },\n\n      return: value => {\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    const delegate = this.#pipeline();\n\n    let prevConsumed = () => {};\n    return {\n      next: async () => {\n        prevConsumed();\n\n        const entry = await delegate.next();\n        if (entry.done) {\n          return entry;\n        }\n\n        const {value, consumed} = entry.value;\n        prevConsumed = consumed;\n        return {value};\n      },\n\n      return: value => {\n        prevConsumed();\n\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n}\n\nexport type Options<M> = {\n  /**\n   * Coalesces messages waiting to be consumed. This is useful for \"watermark\" type\n   * subscriptions in which the consumer is only interested in the cumulative state\n   * change since the last processed message. When a `coalesce` function is specified,\n   * there is guaranteed to be at most one message waiting to be consumed.\n   *\n   * Note that the `curr` argument comes before `prev`. This facilitates a common\n   * scenario in which coalescing just means using the newest value; in such a case,\n   * `coalesce` can simply be the identity function (e.g. `msg => msg`).\n   */\n  coalesce?: (curr: M, prev: M) => M;\n\n  /**\n   * Called on the previous message in an iteration (1) when the next message is requested,\n   * or (2) when the iteration is terminated. This allows the producer to perform\n   * per-message cleanup.\n   *\n   * Note that when a {@link Options.coalesce coalesce} function is defined,\n   * `consumed` is _not_ called on the `prev` message; it is the responsibility of\n   * producers requiring both coalescing and consumption notification to perform any\n   * necessary cleanup of `prev` messages when coalescing.\n   */\n  consumed?: (prev: M) => void;\n\n  /**\n   * `cleanup` is called exactly once when the subscription is terminated via a failure or\n   * cancelation (whichever happens first), which includes implicit cancelation when\n   * the consumer exits an iteration via a `break`, `return`, or `throw` statement.\n   *\n   * Note that the `err` argument will only reflect an explicit cancelation via a call\n   * to {@link Subscription.fail()}. On the other hand, if the iteration is canceled via\n   * a `throw` statement, the thrown reason is not reflected in the `err` parameter, as that\n   * information is not made available to the AsyncIterator implementation.\n   */\n  cleanup?: (unconsumed: M[], err?: Error) => void;\n\n  /**\n   * Enable or disable pipelining when streaming messages over a websocket.\n   *\n   * If unspecified, pipelining is enabled if there is no {@link Options.coalesce coalesce}\n   * method, as pipelining is counter to the semantics of coalescing. However, the\n   * application can explicitly enable pipelining even if there is a coalesce method\n   * by specifying `true` for this option. This assumes that coalescing is either\n   * not important for websocket semantics, or that the receiving end of the websocket\n   * transport performs the desired coalescing.\n   */\n  pipeline?: boolean;\n};\n\n/** Post-queueing results of messages. */\nexport type Result = 'consumed' | 'coalesced' | 'unconsumed';\n\n/**\n * {@link Subscription.subscribe()} wraps the `Promise<Result>` in a `PendingResult`\n * object to avoid forcing all callers to handle the Promise, as most logic does not\n * need to.\n */\nexport type PendingResult = {result: Promise<Result>};\n\ntype Entry<M> = {\n  readonly value: M;\n  readonly resolve: (r: Result) => void;\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"subscription.js","names":["#consumers","#messages","#consuming","#pipelineEnabled","#coalesce","#consumed","#cleanup","#publish","#sentinel","#terminate","#pipeline"],"sources":["../../../../../zero-cache/src/types/subscription.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Sink, Source} from './streams.ts';\n\n/**\n * A Subscription abstracts a continuous, logically infinite stream of messages intended\n * for serial processing. Unlike the more general Node `Stream` API, a Subscription has\n * a limited API with specific semantics:\n *\n * * **Serial processing**: Messages must be consumed via the {@link AsyncIterable}\n *   interface, e.g.\n *   ```ts\n *   const subscription = server.subscribe(parameters);\n *\n *   for await (const message of subscription) {\n *     await process(message);  // fully process the message before consuming the next\n *   }\n *   ```\n *\n *   Moreover, the consumer is expected to completely process each message before\n *   requesting the next. This is important for cleanup semantics (explained later).\n *\n * * **cancel()**, not close(): The underlying data in a subscription is logically infinite\n *   and only terminated when the consumer is no longer interested in receiving the messages\n *   (or requires a Subscription with a different configuration). As such, there is no API\n *   for gracefully closing the subscription after pending messages are consumed; rather,\n *   cancellation is immediate, and upon cancellation, pending messages are dropped. A\n *   Subscription can also be terminated with exceptional (i.e. `Error`) circumstances,\n *   for which the behavior is equivalent.\n *\n * * **Coalescing** (optional): A producer can configure pending messages in the Subscription\n *   to be merged together with a {@link Options.coalesce coalesce} function. This is useful\n *   for semantics in which the consumer is not necessarily interested in every incremental\n *   change, but rather the cumulative change since the last processed message. A\n *   Subscription with coalescing is guaranteed to have at most one outstanding message,\n *   regardless of how quickly messages are produced and consumed. This effectively constrains\n *   the amount of outstanding work in the system.\n *\n * ### Resource Tracking and Cleanup\n *\n * Because message consumption is constrained to the async iteration API, standard\n * control flow mechanisms allow the producer to perform bookkeeping without any\n * explicit cleanup actions on the part of the consumer. This includes:\n *\n * * **Per-message cleanup**: Each request for the {@link AsyncIterator.next next}\n *   message, or the termination of the iteration, signals that the consumer has\n *   finished processing the previous message. The producer of a Subscription can\n *   supply a {@link Options.consumed consumed} callback to receive these processed\n *   messages, allowing it to clean up attached resources (e.g. TransactionPools, etc.).\n *\n * * **Per-subscription cleanup**: The producer of a Subscription can supply a\n *   {@link Options.cleanup cleanup} callback that is invoked when the Subscription\n *   is terminated, either explicitly via {@link Subscription.cancel cancel()} /\n *   {@link Subscription.fail fail()}, or implicitly when an iteration is exited via a\n *  `break`, `return`, or `throw` statement. All unconsumed messages are passed to the\n *   call back to facilitate bookkeeping.\n *\n * @param T The external message type, published to the AsyncIterable\n * @param M The internal message type used in the producer-side interfaces\n *          (e.g. {@link push}, {@link Options.consumed}, {@link Options.coalesce},\n *          and {@link Options.cleanup}). This is often the same as the external type\n *          T, but may be diverged to facilitate internal bookkeeping.\n */\nexport class Subscription<T, M = T> implements Source<T>, Sink<M> {\n  /**\n   * Convenience factory method for creating a {@link Subscription} with internal message type\n   * `M` as a subtype of `T`, defaulting to the same type. The default `publish` method publishes\n   * the message of type `M` directly to the AsyncIterable.\n   */\n  static create<T, M extends T = T>(\n    options: Options<M> = {},\n    publish: (m: M) => T = m => m,\n  ) {\n    return new Subscription(options, publish);\n  }\n\n  // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).\n  readonly #consumers: Resolver<Entry<M> | null>[] = [];\n  // Messages waiting to be dequeued.\n  readonly #messages: (Entry<M> | 'terminus')[] = [];\n  // Messages dequeued but not yet consumed.\n  readonly #consuming = new Set<Entry<M>>();\n  readonly #pipelineEnabled: boolean;\n  // Sentinel value signaling that the subscription is \"done\" and no more\n  // messages can be added.\n  #sentinel: 'canceled' | Error | undefined = undefined;\n\n  #coalesce: ((curr: Entry<M>, prev: Entry<M>) => M) | undefined;\n  #consumed: (prev: Entry<M>) => void;\n  #cleanup: (unconsumed: Entry<M>[], err?: Error) => void;\n  #publish: (internal: M) => T;\n\n  /**\n   * @param publish function for converting the internally pushed / coalesced message\n   *        of type `M` to the external type `T` exposed via async iteration.\n   */\n  constructor(options: Options<M> = {}, publish: (m: M) => T) {\n    const {\n      coalesce,\n      consumed = () => {},\n      cleanup = () => {},\n      pipeline = coalesce === undefined,\n    } = options;\n\n    this.#coalesce = !coalesce\n      ? undefined\n      : (curr, prev) => {\n          try {\n            return coalesce(curr.value, prev.value);\n          } finally {\n            prev.resolve('coalesced');\n          }\n        };\n\n    this.#consumed = entry => {\n      consumed(entry.value);\n      this.#consuming.delete(entry);\n      entry.resolve('consumed');\n    };\n\n    this.#cleanup = (entries, err) => {\n      cleanup(\n        entries.map(e => e.value),\n        err,\n      );\n      entries.forEach(e => e.resolve('unconsumed'));\n    };\n\n    this.#publish = publish;\n\n    this.#pipelineEnabled = pipeline;\n  }\n\n  /**\n   * Pushes the next message to be consumed, and returns a `result` that resolves to the\n   * eventual {@link Result} of the `value`.\n   *\n   * If there is an existing unconsumed message and the Subscription has a\n   * {@link Options#coalesce coalesce} function, the specified `value` will be coalesced\n   * with the pending message. In this case, the result of the pending message\n   * is resolved to `coalesced`, regardless of the `coalesce` function implementation.\n   *\n   * If the subscription is in a terminal state, the message is dropped and the\n   * result resolves to `unconsumed`.\n   */\n  push(value: M): PendingResult {\n    const {promise: result, resolve} = resolver<Result>();\n    const entry = {value, resolve};\n\n    if (this.#sentinel) {\n      entry.resolve('unconsumed');\n      return {result};\n    }\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolve(entry);\n    } else if (\n      this.#coalesce &&\n      this.#messages.length &&\n      this.#messages[this.#messages.length - 1] !== 'terminus'\n    ) {\n      const prev = this.#messages[this.#messages.length - 1];\n      assert(prev !== 'terminus', 'prev should not be terminus after check');\n      this.#messages[this.#messages.length - 1] = {\n        value: this.#coalesce(entry, prev),\n        resolve,\n      };\n    } else {\n      this.#messages.push(entry);\n    }\n    return {result};\n  }\n\n  /** False if the subscription has been canceled or has failed. */\n  get active(): boolean {\n    return this.#sentinel === undefined;\n  }\n\n  /** The number of messages waiting to be dequeued. */\n  get queued(): number {\n    return this.#messages.length;\n  }\n\n  /** The number of messages dequeued but not yet \"consumed\" */\n  get consuming(): number {\n    return this.#consuming.size;\n  }\n\n  /**\n   * Cancels the subscription after any queued messages are consumed. This is\n   * meant for the producer-side code.\n   *\n   * Any messages pushed after calling `end()` will be unconsumed as if\n   * `cancel()` were called (once the first set of pending messages is\n   * consumed). In particular, if a coalesce function is defined, the new\n   * messages will not be coalesced with the messages enqueued before `end()`\n   * was called. However, to effect the intent of memory efficiency, multiple\n   * messages pushed after calling `end()` will be coalesced together.\n   *\n   */\n  end() {\n    if (this.#sentinel) {\n      // already terminated\n    } else if (this.#messages.length === 0) {\n      this.cancel();\n    } else {\n      this.#messages.push('terminus');\n    }\n  }\n\n  /**\n   * Cancels the subscription immediately, cleans up, and terminates any iteration.\n   * This is intended for the consumer to call when it is no longer interested\n   * in the subscription.\n   *\n   * @param err If an `err` is specified, an iteration over the Subscription /\n   *        Sink will throw the `err` (equivalent to the producer calling\n   *        {@link fail()}). If undefined, the iteration will exit gracefully.\n   */\n  cancel(err?: Error) {\n    this.#terminate(err ?? 'canceled');\n  }\n\n  /** Fails the subscription, cleans up, and throws from any iteration. */\n  fail(err: Error) {\n    this.#terminate(err);\n  }\n\n  #terminate(sentinel: 'canceled' | Error) {\n    if (!this.#sentinel) {\n      this.#sentinel = sentinel;\n      this.#cleanup(\n        [...this.#consuming, ...this.#messages.filter(m => m !== 'terminus')],\n        sentinel instanceof Error ? sentinel : undefined,\n      );\n      this.#messages.splice(0);\n\n      for (\n        let consumer = this.#consumers.shift();\n        consumer;\n        consumer = this.#consumers.shift()\n      ) {\n        sentinel === 'canceled'\n          ? consumer.resolve(null)\n          : consumer.reject(sentinel);\n      }\n    }\n  }\n\n  get pipeline(): AsyncIterable<{value: T; consumed: () => void}> | undefined {\n    return this.#pipelineEnabled\n      ? {[Symbol.asyncIterator]: () => this.#pipeline()}\n      : undefined;\n  }\n\n  #pipeline(): AsyncIterator<{value: T; consumed: () => void}> {\n    return {\n      next: async () => {\n        const entry = this.#messages.shift();\n        if (entry === 'terminus') {\n          this.cancel();\n          return {value: undefined, done: true};\n        }\n        if (entry !== undefined) {\n          this.#consuming.add(entry);\n          return {\n            value: {\n              value: this.#publish(entry.value),\n              consumed: () => this.#consumed(entry),\n            },\n          };\n        }\n        if (this.#sentinel === 'canceled') {\n          return {value: undefined, done: true};\n        }\n        if (this.#sentinel) {\n          return Promise.reject(this.#sentinel);\n        }\n        const consumer = resolver<Entry<M> | null>();\n        this.#consumers.push(consumer);\n\n        // Wait for push() (or termination) to resolve the consumer.\n        const result = await consumer.promise;\n        if (result !== null) {\n          this.#consuming.add(result);\n          return {\n            value: {\n              value: this.#publish(result.value),\n              consumed: () => this.#consumed(result),\n            },\n          };\n        }\n        return {value: undefined, done: true};\n      },\n\n      return: value => {\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    const delegate = this.#pipeline();\n\n    let prevConsumed = () => {};\n    return {\n      next: async () => {\n        prevConsumed();\n\n        const entry = await delegate.next();\n        if (entry.done) {\n          return entry;\n        }\n\n        const {value, consumed} = entry.value;\n        prevConsumed = consumed;\n        return {value};\n      },\n\n      return: value => {\n        prevConsumed();\n\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n}\n\nexport type Options<M> = {\n  /**\n   * Coalesces messages waiting to be consumed. This is useful for \"watermark\" type\n   * subscriptions in which the consumer is only interested in the cumulative state\n   * change since the last processed message. When a `coalesce` function is specified,\n   * there is guaranteed to be at most one message waiting to be consumed.\n   *\n   * Note that the `curr` argument comes before `prev`. This facilitates a common\n   * scenario in which coalescing just means using the newest value; in such a case,\n   * `coalesce` can simply be the identity function (e.g. `msg => msg`).\n   */\n  coalesce?: (curr: M, prev: M) => M;\n\n  /**\n   * Called on the previous message in an iteration (1) when the next message is requested,\n   * or (2) when the iteration is terminated. This allows the producer to perform\n   * per-message cleanup.\n   *\n   * Note that when a {@link Options.coalesce coalesce} function is defined,\n   * `consumed` is _not_ called on the `prev` message; it is the responsibility of\n   * producers requiring both coalescing and consumption notification to perform any\n   * necessary cleanup of `prev` messages when coalescing.\n   */\n  consumed?: (prev: M) => void;\n\n  /**\n   * `cleanup` is called exactly once when the subscription is terminated via a failure or\n   * cancelation (whichever happens first), which includes implicit cancelation when\n   * the consumer exits an iteration via a `break`, `return`, or `throw` statement.\n   *\n   * Note that the `err` argument will only reflect an explicit cancelation via a call\n   * to {@link Subscription.fail()}. On the other hand, if the iteration is canceled via\n   * a `throw` statement, the thrown reason is not reflected in the `err` parameter, as that\n   * information is not made available to the AsyncIterator implementation.\n   */\n  cleanup?: (unconsumed: M[], err?: Error) => void;\n\n  /**\n   * Enable or disable pipelining when streaming messages over a websocket.\n   *\n   * If unspecified, pipelining is enabled if there is no {@link Options.coalesce coalesce}\n   * method, as pipelining is counter to the semantics of coalescing. However, the\n   * application can explicitly enable pipelining even if there is a coalesce method\n   * by specifying `true` for this option. This assumes that coalescing is either\n   * not important for websocket semantics, or that the receiving end of the websocket\n   * transport performs the desired coalescing.\n   */\n  pipeline?: boolean;\n};\n\n/** Post-queueing results of messages. */\nexport type Result = 'consumed' | 'coalesced' | 'unconsumed';\n\n/**\n * {@link Subscription.subscribe()} wraps the `Promise<Result>` in a `PendingResult`\n * object to avoid forcing all callers to handle the Promise, as most logic does not\n * need to.\n */\nexport type PendingResult = {result: Promise<Result>};\n\ntype Entry<M> = {\n  readonly value: M;\n  readonly resolve: (r: Result) => void;\n};\n"],"mappings":"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"}