@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

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

@@ -1,4 +1,5 @@
 import { assert } from "../../../shared/src/asserts.js";
+import { RingBuffer } from "../../../shared/src/ring-buffer.js";
 import { resolver } from "@rocicorp/resolver";
 //#region ../zero-cache/src/types/subscription.ts
 /**
@@ -70,14 +71,14 @@ var Subscription = class Subscription {
 		return new Subscription(options, publish);
 	}
 	#abortController = new AbortController();
-	#consumers = [];
-	#messages = [];
+	#consumers = new RingBuffer();
+	#messages = new RingBuffer();
 	#consuming = /* @__PURE__ */ new Set();
 	#pipelineEnabled;
 	#sentinel = void 0;
-	#coalesce;
-	#consumed;
-	#cleanup;
+	#coalesceFunc;
+	#consumedFunc;
+	#cleanupFunc;
 	#publish;
 	/**
 	* @param publish function for converting the internally pushed / coalesced message
@@ -85,25 +86,44 @@ var Subscription = class Subscription {
 	*/
 	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.#coalesceFunc = coalesce;
+		this.#consumedFunc = consumed;
+		this.#cleanupFunc = cleanup;
 		this.#publish = publish;
 		this.#pipelineEnabled = pipeline;
 	}
+	#coalesce(curr, prev) {
+		assert(this.#coalesceFunc, "expected a coalesce function");
+		try {
+			return this.#coalesceFunc(curr.value, prev.value);
+		} finally {
+			prev.resolve("coalesced");
+		}
+	}
+	#consumed(prev) {
+		this.#consumedFunc(prev.value);
+		this.#consuming.delete(prev);
+		prev.resolve("consumed");
+	}
+	#cleanup(entries, err) {
+		this.#cleanupFunc(entries.map((e) => e.value), err);
+		entries.forEach((e) => e.resolve("unconsumed"));
+	}
+	/**
+	* Dynamically adds a function that is called when the Subscription
+	* terminates. This will be called immediately if the Subscription is
+	* already closed.
+	*
+	* Unlike the `cleanup` handler specified in the Subscription options,
+	* this a close handler can be added to an existing Subscription object
+	* thereby avoiding a cyclic dependency, and allowing Subscription
+	* receivers to add their own cleanup logic.
+	*/
+	addCloseHandler(onClose) {
+		if (this.signal.aborted) onClose(this.signal.reason);
+		else this.signal.addEventListener("abort", () => onClose(this.signal.reason));
+		return this;
+	}
 	/**
 	* Pushes the next message to be consumed, and returns a `result` that resolves to the
 	* eventual {@link Result} of the `value`.
@@ -128,13 +148,13 @@ var Subscription = class Subscription {
 		}
 		const consumer = this.#consumers.shift();
 		if (consumer) consumer.resolve(entry);
-		else if (this.#coalesce && this.#messages.length && this.#messages.at(-1) !== "terminus") {
-			const prev = this.#messages.at(-1);
-			assert(prev !== "terminus", "prev should not be terminus after check");
-			this.#messages[this.#messages.length - 1] = {
+		else if (this.#coalesceFunc && this.#messages.size && this.#messages.last() !== "terminus") {
+			const prev = this.#messages.last();
+			assert(prev !== void 0 && prev !== "terminus", "expected an entry");
+			this.#messages.replaceLast({
 				value: this.#coalesce(entry, prev),
 				resolve
-			};
+			});
 		} else this.#messages.push(entry);
 		return { result };
 	}
@@ -144,7 +164,7 @@ var Subscription = class Subscription {
 	}
 	/** The number of messages waiting to be dequeued. */
 	get queued() {
-		return this.#messages.length;
+		return this.#messages.size;
 	}
 	/** The number of messages dequeued but not yet "consumed" */
 	get consuming() {
@@ -167,7 +187,7 @@ var Subscription = class Subscription {
 	*
 	*/
 	end() {
-		if (this.#sentinel) {} else if (this.#messages.length === 0) this.cancel();
+		if (this.#sentinel) {} else if (this.#messages.size === 0) this.cancel();
 		else this.#messages.push("terminus");
 	}
 	/**
@@ -189,15 +209,87 @@ var Subscription = class Subscription {
 	#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);
+			this.#cleanup([...this.#consuming, ...this.#messages.toArray().filter((m) => m !== "terminus")], sentinel instanceof Error ? sentinel : void 0);
+			this.#messages.clear();
+			for (let consumer = this.#consumers.shift(); consumer; consumer = this.#consumers.shift()) if (sentinel === "canceled") consumer.resolve(null);
+			else consumer.reject(sentinel);
 			this.#abortController.abort(sentinel);
 		}
 	}
 	get pipeline() {
 		return this.#pipelineEnabled ? { [Symbol.asyncIterator]: () => this.#pipeline() } : void 0;
 	}
+	pipelineBatched = (maxBatch = 64) => {
+		assert(Number.isInteger(maxBatch) && maxBatch > 0, () => `maxBatch must be a positive integer, got: ${maxBatch}`);
+		return this.#pipelineEnabled ? { [Symbol.asyncIterator]: () => this.#pipelineBatched(maxBatch) } : void 0;
+	};
+	#pipelineBatched(maxBatch) {
+		return {
+			next: async () => {
+				const entries = [];
+				while (this.#messages.size > 0 && entries.length < maxBatch) {
+					if (this.#messages.first() === "terminus") {
+						if (entries.length > 0) break;
+						this.#messages.shift();
+						this.cancel();
+						return {
+							value: void 0,
+							done: true
+						};
+					}
+					const entry = this.#messages.shift();
+					entries.push(entry);
+				}
+				if (entries.length > 0) {
+					for (const e of entries) this.#consuming.add(e);
+					return {
+						value: {
+							values: entries.map((e) => this.#publish(e.value)),
+							consumed: () => {
+								for (const e of entries) this.#consumed(e);
+							}
+						},
+						done: false
+					};
+				}
+				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) return {
+					value: void 0,
+					done: true
+				};
+				entries.push(result);
+				while (this.#messages.size > 0 && entries.length < maxBatch) {
+					if (this.#messages.first() === "terminus") break;
+					const entry = this.#messages.shift();
+					entries.push(entry);
+				}
+				for (const e of entries) this.#consuming.add(e);
+				return {
+					value: {
+						values: entries.map((e) => this.#publish(e.value)),
+						consumed: () => {
+							for (const e of entries) this.#consumed(e);
+						}
+					},
+					done: false
+				};
+			},
+			return: (value) => {
+				this.cancel();
+				return Promise.resolve({
+					value,
+					done: true
+				});
+			}
+		};
+	}
 	#pipeline() {
 		return {
 			next: async () => {

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

@@ -1 +1 @@
-{"version":3,"file":"subscription.js","names":["#abortController","#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  readonly #abortController = new AbortController();\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.at(-1) !== 'terminus'\n    ) {\n      // oxlint-disable-next-line typescript/no-non-null-assertion\n      const prev = this.#messages.at(-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  /** Satisfies the Source interface. */\n  get signal() {\n    return this.#abortController.signal;\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      this.#abortController.abort(sentinel);\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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"}
+{"version":3,"file":"subscription.js","names":["#abortController","#consumers","#messages","#consuming","#pipelineEnabled","#coalesceFunc","#consumedFunc","#cleanupFunc","#publish","#sentinel","#coalesce","#terminate","#cleanup","#pipeline","#pipelineBatched","#consumed"],"sources":["../../../../../zero-cache/src/types/subscription.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {RingBuffer} from '../../../shared/src/ring-buffer.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  readonly #abortController = new AbortController();\n  // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).\n  readonly #consumers = new RingBuffer<Resolver<Entry<M> | null>>();\n  // Messages waiting to be dequeued.\n  readonly #messages = new RingBuffer<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  readonly #coalesceFunc: ((curr: M, prev: M) => M) | undefined;\n  readonly #consumedFunc: (prev: M) => void;\n  readonly #cleanupFunc: (unconsumed: M[], err?: Error) => void;\n\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.#coalesceFunc = coalesce;\n    this.#consumedFunc = consumed;\n    this.#cleanupFunc = cleanup;\n    this.#publish = publish;\n    this.#pipelineEnabled = pipeline;\n  }\n\n  #coalesce(curr: Entry<M>, prev: Entry<M>): M {\n    assert(this.#coalesceFunc, 'expected a coalesce function');\n    try {\n      return this.#coalesceFunc(curr.value, prev.value);\n    } finally {\n      prev.resolve('coalesced');\n    }\n  }\n\n  #consumed(prev: Entry<M>): void {\n    this.#consumedFunc(prev.value);\n    this.#consuming.delete(prev);\n    prev.resolve('consumed');\n  }\n\n  #cleanup(entries: Entry<M>[], err?: Error) {\n    this.#cleanupFunc(\n      entries.map(e => e.value),\n      err,\n    );\n    entries.forEach(e => e.resolve('unconsumed'));\n  }\n\n  /**\n   * Dynamically adds a function that is called when the Subscription\n   * terminates. This will be called immediately if the Subscription is\n   * already closed.\n   *\n   * Unlike the `cleanup` handler specified in the Subscription options,\n   * this a close handler can be added to an existing Subscription object\n   * thereby avoiding a cyclic dependency, and allowing Subscription\n   * receivers to add their own cleanup logic.\n   */\n  addCloseHandler(onClose: (reason?: unknown) => void): this {\n    if (this.signal.aborted) {\n      onClose(this.signal.reason);\n    } else {\n      this.signal.addEventListener('abort', () => onClose(this.signal.reason));\n    }\n    return this;\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.#coalesceFunc &&\n      this.#messages.size &&\n      this.#messages.last() !== 'terminus'\n    ) {\n      const prev = this.#messages.last();\n      assert(prev !== undefined && prev !== 'terminus', 'expected an entry');\n      this.#messages.replaceLast({\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.size;\n  }\n\n  /** The number of messages dequeued but not yet \"consumed\" */\n  get consuming(): number {\n    return this.#consuming.size;\n  }\n\n  /** Satisfies the Source interface. */\n  get signal() {\n    return this.#abortController.signal;\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.size === 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        [\n          ...this.#consuming,\n          ...this.#messages.toArray().filter(m => m !== 'terminus'),\n        ],\n        sentinel instanceof Error ? sentinel : undefined,\n      );\n      this.#messages.clear();\n\n      for (\n        let consumer = this.#consumers.shift();\n        consumer;\n        consumer = this.#consumers.shift()\n      ) {\n        if (sentinel === 'canceled') {\n          consumer.resolve(null);\n        } else {\n          consumer.reject(sentinel);\n        }\n      }\n      this.#abortController.abort(sentinel);\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  pipelineBatched = (\n    maxBatch = 64,\n  ): AsyncIterable<{values: T[]; consumed: () => void}> | undefined => {\n    assert(\n      Number.isInteger(maxBatch) && maxBatch > 0,\n      () => `maxBatch must be a positive integer, got: ${maxBatch}`,\n    );\n    return this.#pipelineEnabled\n      ? {[Symbol.asyncIterator]: () => this.#pipelineBatched(maxBatch)}\n      : undefined;\n  };\n\n  #pipelineBatched(\n    maxBatch: number,\n  ): AsyncIterator<{values: T[]; consumed: () => void}> {\n    return {\n      next: async () => {\n        const entries: Entry<M>[] = [];\n\n        while (this.#messages.size > 0 && entries.length < maxBatch) {\n          const head = this.#messages.first();\n          if (head === 'terminus') {\n            if (entries.length > 0) {\n              break;\n            }\n            this.#messages.shift();\n            this.cancel();\n            return {value: undefined, done: true};\n          }\n          const entry = this.#messages.shift() as Entry<M>;\n          entries.push(entry);\n        }\n\n        if (entries.length > 0) {\n          for (const e of entries) {\n            this.#consuming.add(e);\n          }\n          return {\n            value: {\n              values: entries.map(e => this.#publish(e.value)),\n              consumed: () => {\n                for (const e of entries) {\n                  this.#consumed(e);\n                }\n              },\n            },\n            done: false,\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\n        const consumer = resolver<Entry<M> | null>();\n        this.#consumers.push(consumer);\n\n        const result = await consumer.promise;\n        if (result === null) {\n          return {value: undefined, done: true};\n        }\n\n        entries.push(result);\n\n        while (this.#messages.size > 0 && entries.length < maxBatch) {\n          if (this.#messages.first() === 'terminus') {\n            break;\n          }\n          const entry = this.#messages.shift() as Entry<M>;\n          entries.push(entry);\n        }\n\n        for (const e of entries) {\n          this.#consuming.add(e);\n        }\n\n        return {\n          value: {\n            values: entries.map(e => this.#publish(e.value)),\n            consumed: () => {\n              for (const e of entries) {\n                this.#consumed(e);\n              }\n            },\n          },\n          done: false,\n        };\n      },\n\n      return: value => {\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\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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"}

package/out/zero-cache/src/types/websocket-handoff.d.ts

@@ -32,7 +32,7 @@ export declare function createWebSocketHandoffHandler<P>(lc: LogContext, handoff
  * that is handing off requests to this process.
  */
 export declare function installWebSocketHandoff<P>(lc: LogContext, handoff: WebSocketHandoff<P>, source: Server | Worker, serverOptions?: ServerOptions): void;
-export declare function installWebSocketReceiver<P>(lc: LogContext, server: WebSocketServer, receive: WebSocketReceiver<P>, receiver: Receiver): void;
+export declare function installWebSocketReceiver<P>(lc: LogContext, server: WebSocketServer, receive: WebSocketReceiver<P>, receiver: Receiver, onAbort?: ((payload: P) => void) | undefined, onReceived?: ((payload: P) => void) | undefined): void;
 export type Handoff<P> = [
     typeof MESSAGE_TYPES.handoff,
     {

package/out/zero-cache/src/types/websocket-handoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-handoff.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/websocket-handoff.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAC,eAAe,EAAE,KAAK,aAAa,EAAE,KAAK,SAAS,EAAC,MAAM,IAAI,CAAC;AAEvE,OAAO,EAAqB,KAAK,qBAAqB,EAAC,MAAM,WAAW,CAAC;AACzE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAC,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,EAAC,MAAM,gBAAgB,CAAC;AAGvE,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAChC,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,EACrC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,KAC/B,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAE3B,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CACjC,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,CAAC,EACV,GAAG,EAAE,qBAAqB,KACvB,IAAI,CAAC;AAEV,MAAM,MAAM,uBAAuB,GAAG,CACpC,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,WAAW,KACd,IAAI,CAAC;AAEV;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAC7C,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC5B,aAAa,CAAC,EAAE,aAAa,GAC5B,uBAAuB,CAoDzB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC5B,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,aAAa,CAAC,EAAE,aAAa,QAc9B;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC7B,QAAQ,EAAE,QAAQ,QA6BnB;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,OAAO,aAAa,CAAC,OAAO;IAC5B;QACE,OAAO,EAAE,qBAAqB,CAAC;QAC/B,IAAI,EAAE,WAAW,CAAC;QAClB,OAAO,EAAE,CAAC,CAAC;KACZ;CACF,CAAC"}
+{"version":3,"file":"websocket-handoff.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/websocket-handoff.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAC,eAAe,EAAE,KAAK,aAAa,EAAE,KAAK,SAAS,EAAC,MAAM,IAAI,CAAC;AAEvE,OAAO,EAAqB,KAAK,qBAAqB,EAAC,MAAM,WAAW,CAAC;AACzE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAC,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,EAAC,MAAM,gBAAgB,CAAC;AAGvE,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAChC,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,EACrC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,KAC/B,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAE3B,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CACjC,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,CAAC,EACV,GAAG,EAAE,qBAAqB,KACvB,IAAI,CAAC;AAEV,MAAM,MAAM,uBAAuB,GAAG,CACpC,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,WAAW,KACd,IAAI,CAAC;AAEV;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAC7C,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC5B,aAAa,CAAC,EAAE,aAAa,GAC5B,uBAAuB,CAoDzB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC5B,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,aAAa,CAAC,EAAE,aAAa,QAc9B;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC7B,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,EAC5C,UAAU,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,QAsChD;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,OAAO,aAAa,CAAC,OAAO;IAC5B;QACE,OAAO,EAAE,qBAAqB,CAAC;QAC/B,IAAI,EAAE,WAAW,CAAC;QAClB,OAAO,EAAE,CAAC,CAAC;KACZ;CACF,CAAC"}

package/out/zero-cache/src/types/websocket-handoff.js

@@ -48,20 +48,29 @@ function installWebSocketHandoff(lc, handoff, source, serverOptions) {
 		handle(message, socket, head);
 	});
 }
-function installWebSocketReceiver(lc, server, receive, receiver) {
+function installWebSocketReceiver(lc, server, receive, receiver, onAbort, onReceived) {
 	receiver.onMessageType("handoff", (msg, socket) => {
+		const { message, head, payload } = msg;
+		onReceived?.(payload);
 		if (!socket) {
 			lc.warn?.("websocket closed during handoff");
+			onAbort?.(payload);
 			return;
 		}
-		const { message, head, payload } = msg;
-		server.handleUpgrade(message, socket, Buffer.from(head), (ws) => {
-			if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {
-				lc.warn?.("websocket closed during upgrade, skipping receive");
-				return;
-			}
-			receive(ws, payload, message);
-		});
+		try {
+			server.handleUpgrade(message, socket, Buffer.from(head), (ws) => {
+				if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {
+					lc.warn?.("websocket closed during upgrade, skipping receive");
+					onAbort?.(payload);
+					return;
+				}
+				receive(ws, payload, message);
+			});
+		} catch (e) {
+			lc.warn?.("error during websocket handleUpgrade", e);
+			socket?.destroy?.();
+			onAbort?.(payload);
+		}
 	});
 }
 //#endregion

package/out/zero-cache/src/types/websocket-handoff.js.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-handoff.js","names":[],"sources":["../../../../../zero-cache/src/types/websocket-handoff.ts"],"sourcesContent":["import type {IncomingMessage} from 'node:http';\nimport {Server} from 'node:http';\nimport type {Socket} from 'node:net';\nimport type {LogContext} from '@rocicorp/logger';\nimport {WebSocketServer, type ServerOptions, type WebSocket} from 'ws';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {serializableSubset, type IncomingMessageSubset} from './http.ts';\nimport type {MESSAGE_TYPES} from './processes.ts';\nimport {type Receiver, type Sender, type Worker} from './processes.ts';\nimport {closeWithError, PROTOCOL_ERROR} from './ws.ts';\n\nexport type HandoffSpec<P> = {\n  payload: P;\n  sender: Sender;\n};\n\n/**\n * The WebSocketHandoff is a function that either returns the payload and\n * receiver, or invokes the specified `callback` with the payload and\n * receiver. It must not do both.\n *\n * Similarly, an error can be handled by throwing synchronously from the\n * function, or invoking the `onerror` callback.\n */\nexport type WebSocketHandoff<P> = (\n  message: IncomingMessageSubset,\n  callback: (h: HandoffSpec<P>) => void,\n  onerror: (reason: unknown) => void,\n) => HandoffSpec<P> | void;\n\nexport type WebSocketReceiver<P> = (\n  ws: WebSocket,\n  payload: P,\n  msg: IncomingMessageSubset,\n) => void;\n\nexport type WebSocketHandoffHandler = (\n  message: IncomingMessageSubset,\n  socket: Socket,\n  head: ArrayBuffer,\n) => void;\n\n/**\n * Installs websocket handoff logic from either an http.Server\n * receiving requests, or a parent Worker process\n * that is handing off requests to this process.\n */\nexport function createWebSocketHandoffHandler<P>(\n  lc: LogContext,\n  handoff: WebSocketHandoff<P>,\n  serverOptions?: ServerOptions,\n): WebSocketHandoffHandler {\n  const wss = new WebSocketServer(\n    serverOptions ?? {\n      noServer: true,\n    },\n  );\n  return (\n    message: IncomingMessageSubset,\n    socket: Socket,\n    head: ArrayBuffer,\n  ) => {\n    let sent = false;\n\n    function send({payload, sender}: HandoffSpec<P>) {\n      assert(!sent, 'Handoff callback already invoked');\n      sent = true;\n\n      const data = [\n        'handoff',\n        {\n          message: serializableSubset(message),\n          head,\n          payload,\n        },\n      ] satisfies Handoff<P>;\n\n      // \"This event is guaranteed to be passed an instance of the <net.Socket> class\"\n      // https://nodejs.org/api/http.html#event-upgrade\n      sender.send(data, socket);\n    }\n\n    function onError(error: unknown) {\n      // Returning an error on the HTTP handshake looks like a hanging connection\n      // (at least from Chrome) and doesn't report any meaningful error in the browser.\n      // Instead, finish the upgrade to a websocket and then close it with an error.\n      wss.handleUpgrade(\n        message as IncomingMessage,\n        socket,\n        Buffer.from(head),\n        ws => closeWithError(lc, ws, error, PROTOCOL_ERROR),\n      );\n    }\n\n    try {\n      const spec = handoff(message, send, onError);\n      if (spec) {\n        send(spec);\n      }\n    } catch (error) {\n      onError(error);\n    }\n  };\n}\n\n/**\n * Installs websocket handoff logic from either an http.Server\n * receiving requests, or a parent Worker process\n * that is handing off requests to this process.\n */\nexport function installWebSocketHandoff<P>(\n  lc: LogContext,\n  handoff: WebSocketHandoff<P>,\n  source: Server | Worker,\n  serverOptions?: ServerOptions,\n) {\n  const handle = createWebSocketHandoffHandler(lc, handoff, serverOptions);\n\n  if (source instanceof Server) {\n    // handoff messages from an HTTP server\n    source.on('upgrade', handle);\n  } else {\n    // handoff messages from this worker's parent.\n    source.onMessageType<Handoff<P>>('handoff', (msg, socket) => {\n      const {message, head} = msg;\n      handle(message, socket as Socket, head);\n    });\n  }\n}\n\nexport function installWebSocketReceiver<P>(\n  lc: LogContext,\n  server: WebSocketServer,\n  receive: WebSocketReceiver<P>,\n  receiver: Receiver,\n) {\n  receiver.onMessageType<Handoff<P>>('handoff', (msg, socket) => {\n    // Per https://nodejs.org/api/child_process.html#subprocesssendmessage-sendhandle-options-callback\n    //\n    // > Any 'message' handlers in the subprocess should verify that socket\n    // > exists, as the connection may have been closed during the time it\n    // > takes to send the connection to the child.\n    if (!socket) {\n      lc.warn?.('websocket closed during handoff');\n      return;\n    }\n    const {message, head, payload} = msg;\n    server.handleUpgrade(\n      message as IncomingMessage,\n      socket as Socket,\n      Buffer.from(head),\n      ws => {\n        // Guard against WebSocket being closed during handoff.\n        // This can happen due to network issues or client disconnection\n        // between the time the socket was sent and when handleUpgrade completes.\n        if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {\n          lc.warn?.('websocket closed during upgrade, skipping receive');\n          return;\n        }\n        receive(ws, payload, message);\n      },\n    );\n  });\n}\n\nexport type Handoff<P> = [\n  typeof MESSAGE_TYPES.handoff,\n  {\n    message: IncomingMessageSubset;\n    head: ArrayBuffer;\n    payload: P;\n  },\n];\n"],"mappings":";;;;;;;;;;;;AA+CA,SAAgB,8BACd,IACA,SACA,eACyB;CACzB,MAAM,MAAM,IAAI,gBACd,iBAAiB,EACf,UAAU,KACZ,CACF;CACA,QACE,SACA,QACA,SACG;EACH,IAAI,OAAO;EAEX,SAAS,KAAK,EAAC,SAAS,UAAyB;GAC/C,OAAO,CAAC,MAAM,kCAAkC;GAChD,OAAO;GAEP,MAAM,OAAO,CACX,WACA;IACE,SAAS,mBAAmB,OAAO;IACnC;IACA;GACF,CACF;GAIA,OAAO,KAAK,MAAM,MAAM;EAC1B;EAEA,SAAS,QAAQ,OAAgB;GAI/B,IAAI,cACF,SACA,QACA,OAAO,KAAK,IAAI,IAChB,OAAM,eAAe,IAAI,IAAI,OAAO,cAAc,CACpD;EACF;EAEA,IAAI;GACF,MAAM,OAAO,QAAQ,SAAS,MAAM,OAAO;GAC3C,IAAI,MACF,KAAK,IAAI;EAEb,SAAS,OAAO;GACd,QAAQ,KAAK;EACf;CACF;AACF;;;;;;AAOA,SAAgB,wBACd,IACA,SACA,QACA,eACA;CACA,MAAM,SAAS,8BAA8B,IAAI,SAAS,aAAa;CAEvE,IAAI,kBAAkB,QAEpB,OAAO,GAAG,WAAW,MAAM;MAG3B,OAAO,cAA0B,YAAY,KAAK,WAAW;EAC3D,MAAM,EAAC,SAAS,SAAQ;EACxB,OAAO,SAAS,QAAkB,IAAI;CACxC,CAAC;AAEL;AAEA,SAAgB,yBACd,IACA,QACA,SACA,UACA;CACA,SAAS,cAA0B,YAAY,KAAK,WAAW;EAM7D,IAAI,CAAC,QAAQ;GACX,GAAG,OAAO,iCAAiC;GAC3C;EACF;EACA,MAAM,EAAC,SAAS,MAAM,YAAW;EACjC,OAAO,cACL,SACA,QACA,OAAO,KAAK,IAAI,IAChB,OAAM;GAIJ,IAAI,GAAG,eAAe,GAAG,UAAU,GAAG,eAAe,GAAG,SAAS;IAC/D,GAAG,OAAO,mDAAmD;IAC7D;GACF;GACA,QAAQ,IAAI,SAAS,OAAO;EAC9B,CACF;CACF,CAAC;AACH"}
+{"version":3,"file":"websocket-handoff.js","names":[],"sources":["../../../../../zero-cache/src/types/websocket-handoff.ts"],"sourcesContent":["import type {IncomingMessage} from 'node:http';\nimport {Server} from 'node:http';\nimport type {Socket} from 'node:net';\nimport type {LogContext} from '@rocicorp/logger';\nimport {WebSocketServer, type ServerOptions, type WebSocket} from 'ws';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {serializableSubset, type IncomingMessageSubset} from './http.ts';\nimport type {MESSAGE_TYPES} from './processes.ts';\nimport {type Receiver, type Sender, type Worker} from './processes.ts';\nimport {closeWithError, PROTOCOL_ERROR} from './ws.ts';\n\nexport type HandoffSpec<P> = {\n  payload: P;\n  sender: Sender;\n};\n\n/**\n * The WebSocketHandoff is a function that either returns the payload and\n * receiver, or invokes the specified `callback` with the payload and\n * receiver. It must not do both.\n *\n * Similarly, an error can be handled by throwing synchronously from the\n * function, or invoking the `onerror` callback.\n */\nexport type WebSocketHandoff<P> = (\n  message: IncomingMessageSubset,\n  callback: (h: HandoffSpec<P>) => void,\n  onerror: (reason: unknown) => void,\n) => HandoffSpec<P> | void;\n\nexport type WebSocketReceiver<P> = (\n  ws: WebSocket,\n  payload: P,\n  msg: IncomingMessageSubset,\n) => void;\n\nexport type WebSocketHandoffHandler = (\n  message: IncomingMessageSubset,\n  socket: Socket,\n  head: ArrayBuffer,\n) => void;\n\n/**\n * Installs websocket handoff logic from either an http.Server\n * receiving requests, or a parent Worker process\n * that is handing off requests to this process.\n */\nexport function createWebSocketHandoffHandler<P>(\n  lc: LogContext,\n  handoff: WebSocketHandoff<P>,\n  serverOptions?: ServerOptions,\n): WebSocketHandoffHandler {\n  const wss = new WebSocketServer(\n    serverOptions ?? {\n      noServer: true,\n    },\n  );\n  return (\n    message: IncomingMessageSubset,\n    socket: Socket,\n    head: ArrayBuffer,\n  ) => {\n    let sent = false;\n\n    function send({payload, sender}: HandoffSpec<P>) {\n      assert(!sent, 'Handoff callback already invoked');\n      sent = true;\n\n      const data = [\n        'handoff',\n        {\n          message: serializableSubset(message),\n          head,\n          payload,\n        },\n      ] satisfies Handoff<P>;\n\n      // \"This event is guaranteed to be passed an instance of the <net.Socket> class\"\n      // https://nodejs.org/api/http.html#event-upgrade\n      sender.send(data, socket);\n    }\n\n    function onError(error: unknown) {\n      // Returning an error on the HTTP handshake looks like a hanging connection\n      // (at least from Chrome) and doesn't report any meaningful error in the browser.\n      // Instead, finish the upgrade to a websocket and then close it with an error.\n      wss.handleUpgrade(\n        message as IncomingMessage,\n        socket,\n        Buffer.from(head),\n        ws => closeWithError(lc, ws, error, PROTOCOL_ERROR),\n      );\n    }\n\n    try {\n      const spec = handoff(message, send, onError);\n      if (spec) {\n        send(spec);\n      }\n    } catch (error) {\n      onError(error);\n    }\n  };\n}\n\n/**\n * Installs websocket handoff logic from either an http.Server\n * receiving requests, or a parent Worker process\n * that is handing off requests to this process.\n */\nexport function installWebSocketHandoff<P>(\n  lc: LogContext,\n  handoff: WebSocketHandoff<P>,\n  source: Server | Worker,\n  serverOptions?: ServerOptions,\n) {\n  const handle = createWebSocketHandoffHandler(lc, handoff, serverOptions);\n\n  if (source instanceof Server) {\n    // handoff messages from an HTTP server\n    source.on('upgrade', handle);\n  } else {\n    // handoff messages from this worker's parent.\n    source.onMessageType<Handoff<P>>('handoff', (msg, socket) => {\n      const {message, head} = msg;\n      handle(message, socket as Socket, head);\n    });\n  }\n}\n\nexport function installWebSocketReceiver<P>(\n  lc: LogContext,\n  server: WebSocketServer,\n  receive: WebSocketReceiver<P>,\n  receiver: Receiver,\n  onAbort?: ((payload: P) => void) | undefined,\n  onReceived?: ((payload: P) => void) | undefined,\n) {\n  receiver.onMessageType<Handoff<P>>('handoff', (msg, socket) => {\n    const {message, head, payload} = msg;\n    onReceived?.(payload);\n    // Per https://nodejs.org/api/child_process.html#subprocesssendmessage-sendhandle-options-callback\n    //\n    // > Any 'message' handlers in the subprocess should verify that socket\n    // > exists, as the connection may have been closed during the time it\n    // > takes to send the connection to the child.\n    if (!socket) {\n      lc.warn?.('websocket closed during handoff');\n      onAbort?.(payload);\n      return;\n    }\n    try {\n      server.handleUpgrade(\n        message as IncomingMessage,\n        socket as Socket,\n        Buffer.from(head),\n        ws => {\n          // Guard against WebSocket being closed during handoff.\n          // This can happen due to network issues or client disconnection\n          // between the time the socket was sent and when handleUpgrade completes.\n          if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {\n            lc.warn?.('websocket closed during upgrade, skipping receive');\n            onAbort?.(payload);\n            return;\n          }\n          receive(ws, payload, message);\n        },\n      );\n    } catch (e) {\n      lc.warn?.('error during websocket handleUpgrade', e);\n      (socket as Socket)?.destroy?.();\n      onAbort?.(payload);\n    }\n  });\n}\n\nexport type Handoff<P> = [\n  typeof MESSAGE_TYPES.handoff,\n  {\n    message: IncomingMessageSubset;\n    head: ArrayBuffer;\n    payload: P;\n  },\n];\n"],"mappings":";;;;;;;;;;;;AA+CA,SAAgB,8BACd,IACA,SACA,eACyB;CACzB,MAAM,MAAM,IAAI,gBACd,iBAAiB,EACf,UAAU,KACZ,CACF;CACA,QACE,SACA,QACA,SACG;EACH,IAAI,OAAO;EAEX,SAAS,KAAK,EAAC,SAAS,UAAyB;GAC/C,OAAO,CAAC,MAAM,kCAAkC;GAChD,OAAO;GAEP,MAAM,OAAO,CACX,WACA;IACE,SAAS,mBAAmB,OAAO;IACnC;IACA;GACF,CACF;GAIA,OAAO,KAAK,MAAM,MAAM;EAC1B;EAEA,SAAS,QAAQ,OAAgB;GAI/B,IAAI,cACF,SACA,QACA,OAAO,KAAK,IAAI,IAChB,OAAM,eAAe,IAAI,IAAI,OAAO,cAAc,CACpD;EACF;EAEA,IAAI;GACF,MAAM,OAAO,QAAQ,SAAS,MAAM,OAAO;GAC3C,IAAI,MACF,KAAK,IAAI;EAEb,SAAS,OAAO;GACd,QAAQ,KAAK;EACf;CACF;AACF;;;;;;AAOA,SAAgB,wBACd,IACA,SACA,QACA,eACA;CACA,MAAM,SAAS,8BAA8B,IAAI,SAAS,aAAa;CAEvE,IAAI,kBAAkB,QAEpB,OAAO,GAAG,WAAW,MAAM;MAG3B,OAAO,cAA0B,YAAY,KAAK,WAAW;EAC3D,MAAM,EAAC,SAAS,SAAQ;EACxB,OAAO,SAAS,QAAkB,IAAI;CACxC,CAAC;AAEL;AAEA,SAAgB,yBACd,IACA,QACA,SACA,UACA,SACA,YACA;CACA,SAAS,cAA0B,YAAY,KAAK,WAAW;EAC7D,MAAM,EAAC,SAAS,MAAM,YAAW;EACjC,aAAa,OAAO;EAMpB,IAAI,CAAC,QAAQ;GACX,GAAG,OAAO,iCAAiC;GAC3C,UAAU,OAAO;GACjB;EACF;EACA,IAAI;GACF,OAAO,cACL,SACA,QACA,OAAO,KAAK,IAAI,IAChB,OAAM;IAIJ,IAAI,GAAG,eAAe,GAAG,UAAU,GAAG,eAAe,GAAG,SAAS;KAC/D,GAAG,OAAO,mDAAmD;KAC7D,UAAU,OAAO;KACjB;IACF;IACA,QAAQ,IAAI,SAAS,OAAO;GAC9B,CACF;EACF,SAAS,GAAG;GACV,GAAG,OAAO,wCAAwC,CAAC;GACnD,QAAoB,UAAU;GAC9B,UAAU,OAAO;EACnB;CACF,CAAC;AACH"}

package/out/zero-cache/src/types/ws.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/ws.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,IAAI,CAAC;AAIlC,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC,MAAM,MAAM,SAAS,GAAG,OAAO,cAAc,GAAG,OAAO,cAAc,CAAC;AAEtE,wBAAgB,cAAc,CAC5B,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,OAAO,EACZ,IAAI,GAAE,SAA0B,QASjC;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,QAkCnB;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,EAClB,eAAe,SAAQ,QAwBxB"}
+{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/ws.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,IAAI,CAAC;AAIlC,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC,MAAM,MAAM,SAAS,GAAG,OAAO,cAAc,GAAG,OAAO,cAAc,CAAC;AAEtE,wBAAgB,cAAc,CAC5B,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,OAAO,EACZ,IAAI,GAAE,SAA0B,QASjC;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,QAkCnB;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,EAClB,eAAe,SAAQ,QA+CxB"}

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

@@ -29,22 +29,7 @@ function sendPingsForLiveness(lc, ws, intervalMs) {
 	ws.on("message", signalAlive);
 	ws.once("close", () => clearInterval(livenessTimer));
 }
-function expectPingsForLiveness(lc, ws, intervalMs, timeoutBufferMs = 3e3) {
-	let gotLivenessSignal = false;
-	const livenessTimer = setInterval(() => {
-		if (!gotLivenessSignal) {
-			lc.warn?.(`socket@${ws.url} did not send heartbeat or messages. Terminating...`);
-			ws.terminate();
-			return;
-		}
-		gotLivenessSignal = false;
-	}, intervalMs + timeoutBufferMs);
-	const signalAlive = () => gotLivenessSignal = true;
-	ws.on("ping", signalAlive);
-	ws.on("message", signalAlive);
-	ws.once("close", () => clearTimeout(livenessTimer));
-}
 //#endregion
-export { PROTOCOL_ERROR, closeWithError, expectPingsForLiveness, sendPingsForLiveness };
+export { PROTOCOL_ERROR, closeWithError, sendPingsForLiveness };
 
 //# sourceMappingURL=ws.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"ws.js","names":[],"sources":["../../../../../zero-cache/src/types/ws.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {WebSocket} from 'ws';\nimport {elide} from './strings.ts';\n\n// https://github.com/Luka967/websocket-close-codes\nexport const PROTOCOL_ERROR = 1002;\nexport const INTERNAL_ERROR = 1011;\n\nexport type ErrorCode = typeof PROTOCOL_ERROR | typeof INTERNAL_ERROR;\n\nexport function closeWithError(\n  lc: LogContext,\n  ws: WebSocket,\n  err: unknown,\n  code: ErrorCode = INTERNAL_ERROR,\n) {\n  const endpoint = ws.url ?? 'client';\n  const errMsg = String(err);\n  lc.warn?.(`closing connection to ${endpoint} with error`, errMsg);\n\n  // close messages must be less than or equal to 123 bytes:\n  // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason\n  ws.close(code, elide(errMsg, 123));\n}\n\nexport function sendPingsForLiveness(\n  lc: LogContext,\n  ws: WebSocket,\n  intervalMs: number,\n) {\n  let gotLivenessSignal = true;\n\n  let livenessTimer: NodeJS.Timeout | undefined;\n  function startHeartBeats() {\n    livenessTimer = setInterval(() => {\n      if (!gotLivenessSignal) {\n        lc.warn?.(\n          `socket@${ws.url} did not respond to heartbeat. Terminating...`,\n        );\n        ws.terminate();\n        return;\n      }\n      // Reset gotLivenessSignal and expect another pong or message to arrive\n      // before the next interval elapses.\n      gotLivenessSignal = false;\n      ws.ping();\n    }, intervalMs);\n  }\n\n  if (ws.readyState === ws.CONNECTING) {\n    ws.once('open', () => startHeartBeats());\n  } else if (ws.readyState === ws.OPEN) {\n    startHeartBeats();\n  }\n\n  // Both pongs and messages are accepted as signs of liveness.\n  // Checking for pongs only risks false positives as pongs may be backed\n  // up behind a large stream of messages.\n  const signalAlive = () => (gotLivenessSignal = true);\n  ws.on('pong', signalAlive);\n  ws.on('message', signalAlive);\n  ws.once('close', () => clearInterval(livenessTimer));\n}\n\nexport function expectPingsForLiveness(\n  lc: LogContext,\n  ws: WebSocket,\n  intervalMs: number,\n  timeoutBufferMs = 3_000,\n) {\n  let gotLivenessSignal = false;\n\n  const livenessTimer = setInterval(() => {\n    if (!gotLivenessSignal) {\n      lc.warn?.(\n        `socket@${ws.url} did not send heartbeat or messages. Terminating...`,\n      );\n      ws.terminate();\n      return;\n    }\n    // Reset gotLivenessSignal and expect another ping or message to arrive\n    // before the next interval elapses.\n    gotLivenessSignal = false;\n  }, intervalMs + timeoutBufferMs);\n\n  // Both pings and messages are accepted as signs of liveness.\n  // Checking for pings only risks false positives as pings may be backed\n  // up behind a large stream of messages.\n  const signalAlive = () => (gotLivenessSignal = true);\n  ws.on('ping', signalAlive);\n  ws.on('message', signalAlive);\n  ws.once('close', () => clearTimeout(livenessTimer));\n}\n"],"mappings":";;AAKA,IAAa,iBAAiB;AAC9B,IAAa,iBAAiB;AAI9B,SAAgB,eACd,IACA,IACA,KACA,OAAkB,gBAClB;CACA,MAAM,WAAW,GAAG,OAAO;CAC3B,MAAM,SAAS,OAAO,GAAG;CACzB,GAAG,OAAO,yBAAyB,SAAS,cAAc,MAAM;CAIhE,GAAG,MAAM,MAAM,MAAM,QAAQ,GAAG,CAAC;AACnC;AAEA,SAAgB,qBACd,IACA,IACA,YACA;CACA,IAAI,oBAAoB;CAExB,IAAI;CACJ,SAAS,kBAAkB;EACzB,gBAAgB,kBAAkB;GAChC,IAAI,CAAC,mBAAmB;IACtB,GAAG,OACD,UAAU,GAAG,IAAI,8CACnB;IACA,GAAG,UAAU;IACb;GACF;GAGA,oBAAoB;GACpB,GAAG,KAAK;EACV,GAAG,UAAU;CACf;CAEA,IAAI,GAAG,eAAe,GAAG,YACvB,GAAG,KAAK,cAAc,gBAAgB,CAAC;MAClC,IAAI,GAAG,eAAe,GAAG,MAC9B,gBAAgB;CAMlB,MAAM,oBAAqB,oBAAoB;CAC/C,GAAG,GAAG,QAAQ,WAAW;CACzB,GAAG,GAAG,WAAW,WAAW;CAC5B,GAAG,KAAK,eAAe,cAAc,aAAa,CAAC;AACrD;AAEA,SAAgB,uBACd,IACA,IACA,YACA,kBAAkB,KAClB;CACA,IAAI,oBAAoB;CAExB,MAAM,gBAAgB,kBAAkB;EACtC,IAAI,CAAC,mBAAmB;GACtB,GAAG,OACD,UAAU,GAAG,IAAI,oDACnB;GACA,GAAG,UAAU;GACb;EACF;EAGA,oBAAoB;CACtB,GAAG,aAAa,eAAe;CAK/B,MAAM,oBAAqB,oBAAoB;CAC/C,GAAG,GAAG,QAAQ,WAAW;CACzB,GAAG,GAAG,WAAW,WAAW;CAC5B,GAAG,KAAK,eAAe,aAAa,aAAa,CAAC;AACpD"}
+{"version":3,"file":"ws.js","names":[],"sources":["../../../../../zero-cache/src/types/ws.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {WebSocket} from 'ws';\nimport {elide} from './strings.ts';\n\n// https://github.com/Luka967/websocket-close-codes\nexport const PROTOCOL_ERROR = 1002;\nexport const INTERNAL_ERROR = 1011;\n\nexport type ErrorCode = typeof PROTOCOL_ERROR | typeof INTERNAL_ERROR;\n\nexport function closeWithError(\n  lc: LogContext,\n  ws: WebSocket,\n  err: unknown,\n  code: ErrorCode = INTERNAL_ERROR,\n) {\n  const endpoint = ws.url ?? 'client';\n  const errMsg = String(err);\n  lc.warn?.(`closing connection to ${endpoint} with error`, errMsg);\n\n  // close messages must be less than or equal to 123 bytes:\n  // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason\n  ws.close(code, elide(errMsg, 123));\n}\n\nexport function sendPingsForLiveness(\n  lc: LogContext,\n  ws: WebSocket,\n  intervalMs: number,\n) {\n  let gotLivenessSignal = true;\n\n  let livenessTimer: NodeJS.Timeout | undefined;\n  function startHeartBeats() {\n    livenessTimer = setInterval(() => {\n      if (!gotLivenessSignal) {\n        lc.warn?.(\n          `socket@${ws.url} did not respond to heartbeat. Terminating...`,\n        );\n        ws.terminate();\n        return;\n      }\n      // Reset gotLivenessSignal and expect another pong or message to arrive\n      // before the next interval elapses.\n      gotLivenessSignal = false;\n      ws.ping();\n    }, intervalMs);\n  }\n\n  if (ws.readyState === ws.CONNECTING) {\n    ws.once('open', () => startHeartBeats());\n  } else if (ws.readyState === ws.OPEN) {\n    startHeartBeats();\n  }\n\n  // Both pongs and messages are accepted as signs of liveness.\n  // Checking for pongs only risks false positives as pongs may be backed\n  // up behind a large stream of messages.\n  const signalAlive = () => (gotLivenessSignal = true);\n  ws.on('pong', signalAlive);\n  ws.on('message', signalAlive);\n  ws.once('close', () => clearInterval(livenessTimer));\n}\n\nexport function expectPingsForLiveness(\n  lc: LogContext,\n  ws: WebSocket,\n  intervalMs: number,\n  timeoutBufferMs = 3_000,\n) {\n  const timeoutMs = intervalMs + timeoutBufferMs;\n  let gotLivenessSignal = false;\n\n  let livenessTimer: NodeJS.Timeout | undefined;\n  function startLivenessChecks() {\n    livenessTimer = setInterval(() => {\n      if (!gotLivenessSignal) {\n        lc.warn?.(\n          `socket@${ws.url} did not send heartbeat or messages. Terminating...`,\n        );\n        ws.terminate();\n        return;\n      }\n      // Reset gotLivenessSignal and expect another ping or message to arrive\n      // before the next interval elapses.\n      gotLivenessSignal = false;\n    }, timeoutMs);\n  }\n\n  if (ws.readyState === ws.CONNECTING) {\n    // Heartbeats only start once the connection is open, so time out the\n    // handshake separately. Otherwise a slow handshake eats into the first\n    // heartbeat interval, and a stuck one is reported as a missed heartbeat.\n    const connectTimer = setTimeout(() => {\n      lc.warn?.(\n        `socket@${ws.url} did not connect within ${timeoutMs} ms. Terminating...`,\n      );\n      ws.terminate();\n    }, timeoutMs);\n    ws.once('open', () => {\n      clearTimeout(connectTimer);\n      startLivenessChecks();\n    });\n    ws.once('close', () => clearTimeout(connectTimer));\n  } else if (ws.readyState === ws.OPEN) {\n    startLivenessChecks();\n  }\n\n  // Both pings and messages are accepted as signs of liveness.\n  // Checking for pings only risks false positives as pings may be backed\n  // up behind a large stream of messages.\n  const signalAlive = () => (gotLivenessSignal = true);\n  ws.on('ping', signalAlive);\n  ws.on('message', signalAlive);\n  ws.once('close', () => clearInterval(livenessTimer));\n}\n"],"mappings":";;AAKA,IAAa,iBAAiB;AAC9B,IAAa,iBAAiB;AAI9B,SAAgB,eACd,IACA,IACA,KACA,OAAkB,gBAClB;CACA,MAAM,WAAW,GAAG,OAAO;CAC3B,MAAM,SAAS,OAAO,GAAG;CACzB,GAAG,OAAO,yBAAyB,SAAS,cAAc,MAAM;CAIhE,GAAG,MAAM,MAAM,MAAM,QAAQ,GAAG,CAAC;AACnC;AAEA,SAAgB,qBACd,IACA,IACA,YACA;CACA,IAAI,oBAAoB;CAExB,IAAI;CACJ,SAAS,kBAAkB;EACzB,gBAAgB,kBAAkB;GAChC,IAAI,CAAC,mBAAmB;IACtB,GAAG,OACD,UAAU,GAAG,IAAI,8CACnB;IACA,GAAG,UAAU;IACb;GACF;GAGA,oBAAoB;GACpB,GAAG,KAAK;EACV,GAAG,UAAU;CACf;CAEA,IAAI,GAAG,eAAe,GAAG,YACvB,GAAG,KAAK,cAAc,gBAAgB,CAAC;MAClC,IAAI,GAAG,eAAe,GAAG,MAC9B,gBAAgB;CAMlB,MAAM,oBAAqB,oBAAoB;CAC/C,GAAG,GAAG,QAAQ,WAAW;CACzB,GAAG,GAAG,WAAW,WAAW;CAC5B,GAAG,KAAK,eAAe,cAAc,aAAa,CAAC;AACrD"}

package/out/zero-cache/src/workers/connect-params.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingHttpHeaders } from 'node:http';
-import { type InitConnectionMessage } from '../../../zero-protocol/src/connect.ts';
+import { type FeatureFlags, type InitConnectionMessage } from '../../../zero-protocol/src/connect.ts';
+import { FeatureFlag } from '../../../zero-protocol/src/feature-flag.ts';
 export type ConnectParams = {
     readonly protocolVersion: number;
     readonly clientID: string;
@@ -10,13 +11,29 @@ export type ConnectParams = {
     readonly lmID: number;
     readonly wsID: string;
     readonly debugPerf: boolean;
+    readonly features: FeatureFlagSet;
     readonly auth: string | undefined;
     readonly userID: string | undefined;
     readonly initConnectionMsg: InitConnectionMessage | undefined;
     readonly httpCookie: string | undefined;
     readonly origin: string | undefined;
     readonly requestHeaders?: Readonly<Record<string, string>> | undefined;
+    readonly generation?: number | undefined;
 };
+/** The features a client gets. See {@link resolveFeatures}. */
+export type FeatureFlagSet = ReadonlySet<FeatureFlag>;
+/** `Set`, typed so that `new FeatureFlagSet()` needs no type argument. */
+export declare const FeatureFlagSet: {
+    new (values?: readonly FeatureFlag[] | null | undefined): Set<FeatureFlag>;
+    new (iterable?: Iterable<FeatureFlag> | null | undefined): Set<FeatureFlag>;
+    readonly prototype: Set<any>;
+    readonly [Symbol.species]: SetConstructor;
+};
+/**
+ * The features a client gets: the flags it sent, and for the flags it didn't
+ * send, the features its protocol version has on by default.
+ */
+export declare function resolveFeatures(protocolVersion: number, featureFlags: FeatureFlags): FeatureFlagSet;
 export declare function getConnectParams(protocolVersion: number, url: URL, headers: IncomingHttpHeaders): {
     params: ConnectParams;
     error: null;

package/out/zero-cache/src/workers/connect-params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect-params.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/connect-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,WAAW,CAAC;AAEnD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,uCAAuC,CAAC;AAG/C,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;CACxE,CAAC;AAoBF,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,mBAAmB,GAE1B;IACE,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CA2CJ"}
+{"version":3,"file":"connect-params.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/connect-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,WAAW,CAAC;AAGnD,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC3B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAC,WAAW,EAAC,MAAM,4CAA4C,CAAC;AAIvE,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C,CAAC;AA6BF,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;AAEtD,0EAA0E;AAC1E,eAAO,MAAM,cAAc;;;;;CAAmB,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,YAAY,GACzB,cAAc,CAWhB;AAED,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,mBAAmB,GAE1B;IACE,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAgDJ"}

package/out/zero-cache/src/workers/connect-params.js

@@ -1,5 +1,8 @@
 import { must } from "../../../shared/src/must.js";
-import { decodeSecProtocols } from "../../../zero-protocol/src/connect.js";
+import { feature_flag_enum_exports } from "../../../zero-protocol/src/feature-flag-enum.js";
+import { decodeSecProtocols, getFeatureFlags } from "../../../zero-protocol/src/connect.js";
+import "../../../zero-protocol/src/analyze-query-result.js";
+import "../../../zero-protocol/src/poke.js";
 import { URLParams } from "../types/url-params.js";
 //#region ../zero-cache/src/workers/connect-params.ts
 /**
@@ -15,6 +18,25 @@ function normalizeHeaders(headers) {
 	}
 	return normalized;
 }
+/**
+* The protocol version from which a client that doesn't send a flag gets the
+* feature. Clients below it get the feature only by sending the flag.
+*/
+var featureOnByDefaultFrom = {
+	[0]: 52,
+	[1]: 53
+};
+/** `Set`, typed so that `new FeatureFlagSet()` needs no type argument. */
+var FeatureFlagSet = Set;
+/**
+* The features a client gets: the flags it sent, and for the flags it didn't
+* send, the features its protocol version has on by default.
+*/
+function resolveFeatures(protocolVersion, featureFlags) {
+	const features = new FeatureFlagSet();
+	for (const flag of Object.values(feature_flag_enum_exports)) if (featureFlags.get(flag) ?? protocolVersion >= featureOnByDefaultFrom[flag]) features.add(flag);
+	return features;
+}
 function getConnectParams(protocolVersion, url, headers) {
 	const params = new URLParams(url);
 	try {
@@ -27,6 +49,7 @@ function getConnectParams(protocolVersion, url, headers) {
 		const wsID = params.get("wsid", false) ?? "";
 		const userID = params.get("userID", false) ?? void 0;
 		const debugPerf = params.getBoolean("debugPerf");
+		const features = resolveFeatures(protocolVersion, getFeatureFlags(url.searchParams));
 		const { initConnectionMessage, authToken } = decodeSecProtocols(must(headers["sec-websocket-protocol"]));
 		return {
 			params: {
@@ -39,6 +62,7 @@ function getConnectParams(protocolVersion, url, headers) {
 				lmID,
 				wsID,
 				debugPerf,
+				features,
 				initConnectionMsg: initConnectionMessage,
 				auth: authToken,
 				userID,

package/out/zero-cache/src/workers/connect-params.js.map

@@ -1 +1 @@
-{"version":3,"file":"connect-params.js","names":[],"sources":["../../../../../zero-cache/src/workers/connect-params.ts"],"sourcesContent":["import type {IncomingHttpHeaders} from 'node:http';\nimport {must} from '../../../shared/src/must.ts';\nimport {\n  decodeSecProtocols,\n  type InitConnectionMessage,\n} from '../../../zero-protocol/src/connect.ts';\nimport {URLParams} from '../types/url-params.ts';\n\nexport type ConnectParams = {\n  readonly protocolVersion: number;\n  readonly clientID: string;\n  readonly clientGroupID: string;\n  readonly profileID: string | null;\n  readonly baseCookie: string | null;\n  readonly timestamp: number;\n  readonly lmID: number;\n  readonly wsID: string;\n  readonly debugPerf: boolean;\n  readonly auth: string | undefined;\n  readonly userID: string | undefined;\n  readonly initConnectionMsg: InitConnectionMessage | undefined;\n  readonly httpCookie: string | undefined;\n  readonly origin: string | undefined;\n  readonly requestHeaders?: Readonly<Record<string, string>> | undefined;\n};\n\n/**\n * Normalizes Node's {@link IncomingHttpHeaders} (whose values are\n * `string | string[] | undefined`) into a plain `Record<string, string>`,\n * joining array values with `, ` and dropping `undefined` values.\n */\nfunction normalizeHeaders(\n  headers: IncomingHttpHeaders,\n): Record<string, string> {\n  const normalized: Record<string, string> = {};\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) {\n      continue;\n    }\n    normalized[key] = Array.isArray(value) ? value.join(', ') : value;\n  }\n  return normalized;\n}\n\nexport function getConnectParams(\n  protocolVersion: number,\n  url: URL,\n  headers: IncomingHttpHeaders,\n):\n  | {\n      params: ConnectParams;\n      error: null;\n    }\n  | {\n      params: null;\n      error: string;\n    } {\n  const params = new URLParams(url);\n\n  try {\n    const clientID = params.get('clientID', true);\n    const clientGroupID = params.get('clientGroupID', true);\n    const profileID = params.get('profileID', false);\n    const baseCookie = params.get('baseCookie', false);\n    const timestamp = params.getInteger('ts', true);\n    const lmID = params.getInteger('lmid', true);\n    const wsID = params.get('wsid', false) ?? '';\n    const userID = params.get('userID', false) ?? undefined;\n    const debugPerf = params.getBoolean('debugPerf');\n    const {initConnectionMessage, authToken} = decodeSecProtocols(\n      must(headers['sec-websocket-protocol']),\n    );\n\n    return {\n      params: {\n        protocolVersion,\n        clientID,\n        clientGroupID,\n        profileID,\n        baseCookie,\n        timestamp,\n        lmID,\n        wsID,\n        debugPerf,\n        initConnectionMsg: initConnectionMessage,\n        auth: authToken,\n        userID,\n        httpCookie: headers.cookie,\n        origin: headers.origin,\n        requestHeaders: normalizeHeaders(headers),\n      },\n      error: null,\n    };\n  } catch (e) {\n    return {\n      params: null,\n      error: e instanceof Error ? e.message : String(e),\n    };\n  }\n}\n"],"mappings":";;;;;;;;;AA+BA,SAAS,iBACP,SACwB;CACxB,MAAM,aAAqC,CAAC;CAC5C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAAG;EAClD,IAAI,UAAU,KAAA,GACZ;EAEF,WAAW,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,IAAI,IAAI;CAC9D;CACA,OAAO;AACT;AAEA,SAAgB,iBACd,iBACA,KACA,SASI;CACJ,MAAM,SAAS,IAAI,UAAU,GAAG;CAEhC,IAAI;EACF,MAAM,WAAW,OAAO,IAAI,YAAY,IAAI;EAC5C,MAAM,gBAAgB,OAAO,IAAI,iBAAiB,IAAI;EACtD,MAAM,YAAY,OAAO,IAAI,aAAa,KAAK;EAC/C,MAAM,aAAa,OAAO,IAAI,cAAc,KAAK;EACjD,MAAM,YAAY,OAAO,WAAW,MAAM,IAAI;EAC9C,MAAM,OAAO,OAAO,WAAW,QAAQ,IAAI;EAC3C,MAAM,OAAO,OAAO,IAAI,QAAQ,KAAK,KAAK;EAC1C,MAAM,SAAS,OAAO,IAAI,UAAU,KAAK,KAAK,KAAA;EAC9C,MAAM,YAAY,OAAO,WAAW,WAAW;EAC/C,MAAM,EAAC,uBAAuB,cAAa,mBACzC,KAAK,QAAQ,yBAAyB,CACxC;EAEA,OAAO;GACL,QAAQ;IACN;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,mBAAmB;IACnB,MAAM;IACN;IACA,YAAY,QAAQ;IACpB,QAAQ,QAAQ;IAChB,gBAAgB,iBAAiB,OAAO;GAC1C;GACA,OAAO;EACT;CACF,SAAS,GAAG;EACV,OAAO;GACL,QAAQ;GACR,OAAO,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;EAClD;CACF;AACF"}
+{"version":3,"file":"connect-params.js","names":[],"sources":["../../../../../zero-cache/src/workers/connect-params.ts"],"sourcesContent":["import type {IncomingHttpHeaders} from 'node:http';\nimport {must} from '../../../shared/src/must.ts';\nimport {ANALYZE_FILTER_NODE_PROTOCOL_VERSION} from '../../../zero-protocol/src/analyze-query-result.ts';\nimport {\n  decodeSecProtocols,\n  getFeatureFlags,\n  type FeatureFlags,\n  type InitConnectionMessage,\n} from '../../../zero-protocol/src/connect.ts';\nimport {FeatureFlag} from '../../../zero-protocol/src/feature-flag.ts';\nimport {POKE_CHUNK_PROTOCOL_VERSION} from '../../../zero-protocol/src/poke.ts';\nimport {URLParams} from '../types/url-params.ts';\n\nexport type ConnectParams = {\n  readonly protocolVersion: number;\n  readonly clientID: string;\n  readonly clientGroupID: string;\n  readonly profileID: string | null;\n  readonly baseCookie: string | null;\n  readonly timestamp: number;\n  readonly lmID: number;\n  readonly wsID: string;\n  readonly debugPerf: boolean;\n  readonly features: FeatureFlagSet;\n  readonly auth: string | undefined;\n  readonly userID: string | undefined;\n  readonly initConnectionMsg: InitConnectionMessage | undefined;\n  readonly httpCookie: string | undefined;\n  readonly origin: string | undefined;\n  readonly requestHeaders?: Readonly<Record<string, string>> | undefined;\n  readonly generation?: number | undefined;\n};\n\n/**\n * Normalizes Node's {@link IncomingHttpHeaders} (whose values are\n * `string | string[] | undefined`) into a plain `Record<string, string>`,\n * joining array values with `, ` and dropping `undefined` values.\n */\nfunction normalizeHeaders(\n  headers: IncomingHttpHeaders,\n): Record<string, string> {\n  const normalized: Record<string, string> = {};\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) {\n      continue;\n    }\n    normalized[key] = Array.isArray(value) ? value.join(', ') : value;\n  }\n  return normalized;\n}\n\n/**\n * The protocol version from which a client that doesn't send a flag gets the\n * feature. Clients below it get the feature only by sending the flag.\n */\nconst featureOnByDefaultFrom = {\n  [FeatureFlag.PokeChunk]: POKE_CHUNK_PROTOCOL_VERSION,\n  [FeatureFlag.AnalyzeFilterNode]: ANALYZE_FILTER_NODE_PROTOCOL_VERSION,\n} as const satisfies Record<FeatureFlag, number>;\n\n/** The features a client gets. See {@link resolveFeatures}. */\nexport type FeatureFlagSet = ReadonlySet<FeatureFlag>;\n\n/** `Set`, typed so that `new FeatureFlagSet()` needs no type argument. */\nexport const FeatureFlagSet = Set<FeatureFlag>;\n\n/**\n * The features a client gets: the flags it sent, and for the flags it didn't\n * send, the features its protocol version has on by default.\n */\nexport function resolveFeatures(\n  protocolVersion: number,\n  featureFlags: FeatureFlags,\n): FeatureFlagSet {\n  const features = new FeatureFlagSet();\n  for (const flag of Object.values(FeatureFlag)) {\n    if (\n      featureFlags.get(flag) ??\n      protocolVersion >= featureOnByDefaultFrom[flag]\n    ) {\n      features.add(flag);\n    }\n  }\n  return features;\n}\n\nexport function getConnectParams(\n  protocolVersion: number,\n  url: URL,\n  headers: IncomingHttpHeaders,\n):\n  | {\n      params: ConnectParams;\n      error: null;\n    }\n  | {\n      params: null;\n      error: string;\n    } {\n  const params = new URLParams(url);\n\n  try {\n    const clientID = params.get('clientID', true);\n    const clientGroupID = params.get('clientGroupID', true);\n    const profileID = params.get('profileID', false);\n    const baseCookie = params.get('baseCookie', false);\n    const timestamp = params.getInteger('ts', true);\n    const lmID = params.getInteger('lmid', true);\n    const wsID = params.get('wsid', false) ?? '';\n    const userID = params.get('userID', false) ?? undefined;\n    const debugPerf = params.getBoolean('debugPerf');\n    const features = resolveFeatures(\n      protocolVersion,\n      getFeatureFlags(url.searchParams),\n    );\n    const {initConnectionMessage, authToken} = decodeSecProtocols(\n      must(headers['sec-websocket-protocol']),\n    );\n\n    return {\n      params: {\n        protocolVersion,\n        clientID,\n        clientGroupID,\n        profileID,\n        baseCookie,\n        timestamp,\n        lmID,\n        wsID,\n        debugPerf,\n        features,\n        initConnectionMsg: initConnectionMessage,\n        auth: authToken,\n        userID,\n        httpCookie: headers.cookie,\n        origin: headers.origin,\n        requestHeaders: normalizeHeaders(headers),\n      },\n      error: null,\n    };\n  } catch (e) {\n    return {\n      params: null,\n      error: e instanceof Error ? e.message : String(e),\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAsCA,SAAS,iBACP,SACwB;CACxB,MAAM,aAAqC,CAAC;CAC5C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAAG;EAClD,IAAI,UAAU,KAAA,GACZ;EAEF,WAAW,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,IAAI,IAAI;CAC9D;CACA,OAAO;AACT;;;;;AAMA,IAAM,yBAAyB;EAC5B,IAAA;EACA,IAAA;AACH;;AAMA,IAAa,iBAAiB;;;;;AAM9B,SAAgB,gBACd,iBACA,cACgB;CAChB,MAAM,WAAW,IAAI,eAAe;CACpC,KAAK,MAAM,QAAQ,OAAO,OAAO,yBAAW,GAC1C,IACE,aAAa,IAAI,IAAI,KACrB,mBAAmB,uBAAuB,OAE1C,SAAS,IAAI,IAAI;CAGrB,OAAO;AACT;AAEA,SAAgB,iBACd,iBACA,KACA,SASI;CACJ,MAAM,SAAS,IAAI,UAAU,GAAG;CAEhC,IAAI;EACF,MAAM,WAAW,OAAO,IAAI,YAAY,IAAI;EAC5C,MAAM,gBAAgB,OAAO,IAAI,iBAAiB,IAAI;EACtD,MAAM,YAAY,OAAO,IAAI,aAAa,KAAK;EAC/C,MAAM,aAAa,OAAO,IAAI,cAAc,KAAK;EACjD,MAAM,YAAY,OAAO,WAAW,MAAM,IAAI;EAC9C,MAAM,OAAO,OAAO,WAAW,QAAQ,IAAI;EAC3C,MAAM,OAAO,OAAO,IAAI,QAAQ,KAAK,KAAK;EAC1C,MAAM,SAAS,OAAO,IAAI,UAAU,KAAK,KAAK,KAAA;EAC9C,MAAM,YAAY,OAAO,WAAW,WAAW;EAC/C,MAAM,WAAW,gBACf,iBACA,gBAAgB,IAAI,YAAY,CAClC;EACA,MAAM,EAAC,uBAAuB,cAAa,mBACzC,KAAK,QAAQ,yBAAyB,CACxC;EAEA,OAAO;GACL,QAAQ;IACN;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,mBAAmB;IACnB,MAAM;IACN;IACA,YAAY,QAAQ;IACpB,QAAQ,QAAQ;IAChB,gBAAgB,iBAAiB,OAAO;GAC1C;GACA,OAAO;EACT;CACF,SAAS,GAAG;EACV,OAAO;GACL,QAAQ;GACR,OAAO,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;EAClD;CACF;AACF"}

package/out/zero-cache/src/workers/connection.d.ts

@@ -60,15 +60,15 @@ export type WebSocketLike = Pick<WebSocket, 'readyState'> & {
 };
 export declare function send(lc: LogContext, ws: WebSocketLike, data: Downstream, callback: ((err?: Error | null) => void) | 'ignore-backpressure', serialized?: string | undefined): void;
 /**
- * Sends downstream messages in the format supported by a connection's sync
- * protocol version. Keep version forks contained here so the view-syncer can
- * continue producing one canonical poke representation.
+ * Sends downstream messages in the format the client supports. Keep format
+ * forks contained here so the view-syncer can continue producing one
+ * canonical poke representation.
  *
  * Exported for compatibility testing.
  */
 export declare class DownstreamSender {
     #private;
-    constructor(lc: LogContext, ws: WebSocketLike, protocolVersion: number);
+    constructor(lc: LogContext, ws: WebSocketLike, pokeChunks: boolean);
     send(data: Downstream, callback: ((err?: Error | null) => void) | 'ignore-backpressure', serialized?: string | undefined): void;
 }
 export declare function sendError(lc: LogContext, ws: WebSocket, errorBody: ErrorBody, thrown?: unknown): void;