@rocicorp/zero 1.10.0-canary.2 → 1.10.0-canary.21

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

@@ -1 +1 @@
-{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAE,MAAM,EAAC,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;;IAC/D;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,EAC9B,OAAO,GAAE,OAAO,CAAC,CAAC,CAAM,EACxB,OAAO,GAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAU;IAsB/B;;;OAGG;gBACS,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAK,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAqC1D;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa;IA6B7B,iEAAiE;IACjE,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,qDAAqD;IACrD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,6DAA6D;IAC7D,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;;;;;;;;;OAWG;IACH,GAAG;IAUH;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK;IAIlB,wEAAwE;IACxE,IAAI,CAAC,GAAG,EAAE,KAAK;IAIf;;;;;;;;;OASG;IACG,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,CAAC,CAAC;IA+CrD,IAAI,QAAQ,IAAI,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAI1E;IAiDD,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CA0B3C;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;IAEnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC"}
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAE,MAAM,EAAC,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;;IAC/D;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,EAC9B,OAAO,GAAE,OAAO,CAAC,CAAC,CAAM,EACxB,OAAO,GAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAU;IAsB/B;;;OAGG;gBACS,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAK,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAqC1D;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa;IA6B7B,iEAAiE;IACjE,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,qDAAqD;IACrD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,6DAA6D;IAC7D,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,sCAAsC;IACtC,IAAI,MAAM,gBAET;IAED;;;;;;;;;;;OAWG;IACH,GAAG;IAUH;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK;IAIlB,wEAAwE;IACxE,IAAI,CAAC,GAAG,EAAE,KAAK;IA0Bf,IAAI,QAAQ,IAAI,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAI1E;IAiDD,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CA0B3C;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;IAEnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC"}

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

@@ -150,6 +150,10 @@ var Subscription = class Subscription {
 	get consuming() {
 		return this.#consuming.size;
 	}
+	/** Satisfies the Source interface. */
+	get signal() {
+		return this.#abortController.signal;
+	}
 	/**
 	* Cancels the subscription after any queued messages are consumed. This is
 	* meant for the producer-side code.
@@ -182,31 +186,6 @@ var Subscription = class Subscription {
 	fail(err) {
 		this.#terminate(err);
 	}
-	/**
-	* Resolves the result of the specified `other` Promise, or a
-	* resolved/rejected Promise when the Subscription {@link end}s,
-	* is {@link cancel}ed, or {@link fail}s.
-	*
-	* This is similar to using `Promise.race([other, subscriptionDone])`, but
-	* in a memory safe way, as repeatedly calling `Promise.race([ ... ])` with
-	* a long-lived Promise results in leaking memory via a growing list of
-	* `then()` callbacks (https://github.com/nodejs/node/issues/17469).
-	*/
-	async doneOr(other) {
-		const result = resolver();
-		const handler = () => {
-			if (this.#sentinel instanceof Error) result.reject(this.#sentinel);
-			else result.resolve();
-		};
-		const { signal } = this.#abortController;
-		if (signal.aborted) handler();
-		else signal.addEventListener("abort", handler);
-		try {
-			return await Promise.race([other, result.promise]);
-		} finally {
-			signal.removeEventListener("abort", handler);
-		}
-	}
 	#terminate(sentinel) {
 		if (!this.#sentinel) {
 			this.#sentinel = sentinel;

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  /**\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  /**\n   * Resolves the result of the specified `other` Promise, or a\n   * resolved/rejected Promise when the Subscription {@link end}s,\n   * is {@link cancel}ed, or {@link fail}s.\n   *\n   * This is similar to using `Promise.race([other, subscriptionDone])`, but\n   * in a memory safe way, as repeatedly calling `Promise.race([ ... ])` with\n   * a long-lived Promise results in leaking memory via a growing list of\n   * `then()` callbacks (https://github.com/nodejs/node/issues/17469).\n   */\n  async doneOr<R>(other: Promise<R>): Promise<void | R> {\n    const result = resolver();\n    const handler = () => {\n      if (this.#sentinel instanceof Error) {\n        result.reject(this.#sentinel);\n      } else {\n        result.resolve();\n      }\n    };\n    const {signal} = this.#abortController;\n    if (signal.aborted) {\n      // The subscription is already terminated. `addEventListener('abort')`\n      // would never fire on an already-aborted signal, so settle eagerly.\n      handler();\n    } else {\n      signal.addEventListener('abort', handler);\n    }\n\n    try {\n      return await Promise.race([other, result.promise]);\n    } finally {\n      signal.removeEventListener('abort', handler);\n    }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,IAAa,eAAb,MAAa,aAAqD;;;;;;CAMhE,OAAO,OACL,UAAsB,CAAC,GACvB,WAAuB,MAAK,GAC5B;EACA,OAAO,IAAI,aAAa,SAAS,OAAO;CAC1C;CAEA,mBAA4B,IAAI,gBAAgB;CAEhD,aAAmD,CAAC;CAEpD,YAAgD,CAAC;CAEjD,6BAAsB,IAAI,IAAc;CACxC;CAGA,YAA4C,KAAA;CAE5C;CACA;CACA;CACA;;;;;CAMA,YAAY,UAAsB,CAAC,GAAG,SAAsB;EAC1D,MAAM,EACJ,UACA,iBAAiB,CAAC,GAClB,gBAAgB,CAAC,GACjB,WAAW,aAAa,KAAA,MACtB;EAEJ,KAAKK,YAAY,CAAC,WACd,KAAA,KACC,MAAM,SAAS;GACd,IAAI;IACF,OAAO,SAAS,KAAK,OAAO,KAAK,KAAK;GACxC,UAAU;IACR,KAAK,QAAQ,WAAW;GAC1B;EACF;EAEJ,KAAKC,aAAY,UAAS;GACxB,SAAS,MAAM,KAAK;GACpB,KAAKH,WAAW,OAAO,KAAK;GAC5B,MAAM,QAAQ,UAAU;EAC1B;EAEA,KAAKI,YAAY,SAAS,QAAQ;GAChC,QACE,QAAQ,KAAI,MAAK,EAAE,KAAK,GACxB,GACF;GACA,QAAQ,SAAQ,MAAK,EAAE,QAAQ,YAAY,CAAC;EAC9C;EAEA,KAAKC,WAAW;EAEhB,KAAKJ,mBAAmB;CAC1B;;;;;;;;;;;;;CAcA,KAAK,OAAyB;EAC5B,MAAM,EAAC,SAAS,QAAQ,YAAW,SAAiB;EACpD,MAAM,QAAQ;GAAC;GAAO;EAAO;EAE7B,IAAI,KAAKK,WAAW;GAClB,MAAM,QAAQ,YAAY;GAC1B,OAAO,EAAC,OAAM;EAChB;EACA,MAAM,WAAW,KAAKR,WAAW,MAAM;EACvC,IAAI,UACF,SAAS,QAAQ,KAAK;OACjB,IACL,KAAKI,aACL,KAAKH,UAAU,UACf,KAAKA,UAAU,GAAG,EAAE,MAAM,YAC1B;GAEA,MAAM,OAAO,KAAKA,UAAU,GAAG,EAAE;GACjC,OAAO,SAAS,YAAY,yCAAyC;GACrE,KAAKA,UAAU,KAAKA,UAAU,SAAS,KAAK;IAC1C,OAAO,KAAKG,UAAU,OAAO,IAAI;IACjC;GACF;EACF,OACE,KAAKH,UAAU,KAAK,KAAK;EAE3B,OAAO,EAAC,OAAM;CAChB;;CAGA,IAAI,SAAkB;EACpB,OAAO,KAAKO,cAAc,KAAA;CAC5B;;CAGA,IAAI,SAAiB;EACnB,OAAO,KAAKP,UAAU;CACxB;;CAGA,IAAI,YAAoB;EACtB,OAAO,KAAKC,WAAW;CACzB;;;;;;;;;;;;;CAcA,MAAM;EACJ,IAAI,KAAKM,WAAW,CAEpB,OAAO,IAAI,KAAKP,UAAU,WAAW,GACnC,KAAK,OAAO;OAEZ,KAAKA,UAAU,KAAK,UAAU;CAElC;;;;;;;;;;CAWA,OAAO,KAAa;EAClB,KAAKQ,WAAW,OAAO,UAAU;CACnC;;CAGA,KAAK,KAAY;EACf,KAAKA,WAAW,GAAG;CACrB;;;;;;;;;;;CAYA,MAAM,OAAU,OAAsC;EACpD,MAAM,SAAS,SAAS;EACxB,MAAM,gBAAgB;GACpB,IAAI,KAAKD,qBAAqB,OAC5B,OAAO,OAAO,KAAKA,SAAS;QAE5B,OAAO,QAAQ;EAEnB;EACA,MAAM,EAAC,WAAU,KAAKT;EACtB,IAAI,OAAO,SAGT,QAAQ;OAER,OAAO,iBAAiB,SAAS,OAAO;EAG1C,IAAI;GACF,OAAO,MAAM,QAAQ,KAAK,CAAC,OAAO,OAAO,OAAO,CAAC;EACnD,UAAU;GACR,OAAO,oBAAoB,SAAS,OAAO;EAC7C;CACF;CAEA,WAAW,UAA8B;EACvC,IAAI,CAAC,KAAKS,WAAW;GACnB,KAAKA,YAAY;GACjB,KAAKF,SACH,CAAC,GAAG,KAAKJ,YAAY,GAAG,KAAKD,UAAU,QAAO,MAAK,MAAM,UAAU,CAAC,GACpE,oBAAoB,QAAQ,WAAW,KAAA,CACzC;GACA,KAAKA,UAAU,OAAO,CAAC;GAEvB,KACE,IAAI,WAAW,KAAKD,WAAW,MAAM,GACrC,UACA,WAAW,KAAKA,WAAW,MAAM,GAEjC,aAAa,aACT,SAAS,QAAQ,IAAI,IACrB,SAAS,OAAO,QAAQ;GAE9B,KAAKD,iBAAiB,MAAM,QAAQ;EACtC;CACF;CAEA,IAAI,WAAwE;EAC1E,OAAO,KAAKI,mBACR,GAAE,OAAO,sBAAsB,KAAKO,UAAU,EAAC,IAC/C,KAAA;CACN;CAEA,YAA6D;EAC3D,OAAO;GACL,MAAM,YAAY;IAChB,MAAM,QAAQ,KAAKT,UAAU,MAAM;IACnC,IAAI,UAAU,YAAY;KACxB,KAAK,OAAO;KACZ,OAAO;MAAC,OAAO,KAAA;MAAW,MAAM;KAAI;IACtC;IACA,IAAI,UAAU,KAAA,GAAW;KACvB,KAAKC,WAAW,IAAI,KAAK;KACzB,OAAO,EACL,OAAO;MACL,OAAO,KAAKK,SAAS,MAAM,KAAK;MAChC,gBAAgB,KAAKF,UAAU,KAAK;KACtC,EACF;IACF;IACA,IAAI,KAAKG,cAAc,YACrB,OAAO;KAAC,OAAO,KAAA;KAAW,MAAM;IAAI;IAEtC,IAAI,KAAKA,WACP,OAAO,QAAQ,OAAO,KAAKA,SAAS;IAEtC,MAAM,WAAW,SAA0B;IAC3C,KAAKR,WAAW,KAAK,QAAQ;IAG7B,MAAM,SAAS,MAAM,SAAS;IAC9B,IAAI,WAAW,MAAM;KACnB,KAAKE,WAAW,IAAI,MAAM;KAC1B,OAAO,EACL,OAAO;MACL,OAAO,KAAKK,SAAS,OAAO,KAAK;MACjC,gBAAgB,KAAKF,UAAU,MAAM;KACvC,EACF;IACF;IACA,OAAO;KAAC,OAAO,KAAA;KAAW,MAAM;IAAI;GACtC;GAEA,SAAQ,UAAS;IACf,KAAK,OAAO;IACZ,OAAO,QAAQ,QAAQ;KAAC;KAAO,MAAM;IAAI,CAAC;GAC5C;EACF;CACF;CAEA,CAAC,OAAO,iBAAmC;EACzC,MAAM,WAAW,KAAKK,UAAU;EAEhC,IAAI,qBAAqB,CAAC;EAC1B,OAAO;GACL,MAAM,YAAY;IAChB,aAAa;IAEb,MAAM,QAAQ,MAAM,SAAS,KAAK;IAClC,IAAI,MAAM,MACR,OAAO;IAGT,MAAM,EAAC,OAAO,aAAY,MAAM;IAChC,eAAe;IACf,OAAO,EAAC,MAAK;GACf;GAEA,SAAQ,UAAS;IACf,aAAa;IAEb,KAAK,OAAO;IACZ,OAAO,QAAQ,QAAQ;KAAC;KAAO,MAAM;IAAI,CAAC;GAC5C;EACF;CACF;AACF"}
+{"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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,IAAa,eAAb,MAAa,aAAqD;;;;;;CAMhE,OAAO,OACL,UAAsB,CAAC,GACvB,WAAuB,MAAK,GAC5B;EACA,OAAO,IAAI,aAAa,SAAS,OAAO;CAC1C;CAEA,mBAA4B,IAAI,gBAAgB;CAEhD,aAAmD,CAAC;CAEpD,YAAgD,CAAC;CAEjD,6BAAsB,IAAI,IAAc;CACxC;CAGA,YAA4C,KAAA;CAE5C;CACA;CACA;CACA;;;;;CAMA,YAAY,UAAsB,CAAC,GAAG,SAAsB;EAC1D,MAAM,EACJ,UACA,iBAAiB,CAAC,GAClB,gBAAgB,CAAC,GACjB,WAAW,aAAa,KAAA,MACtB;EAEJ,KAAKK,YAAY,CAAC,WACd,KAAA,KACC,MAAM,SAAS;GACd,IAAI;IACF,OAAO,SAAS,KAAK,OAAO,KAAK,KAAK;GACxC,UAAU;IACR,KAAK,QAAQ,WAAW;GAC1B;EACF;EAEJ,KAAKC,aAAY,UAAS;GACxB,SAAS,MAAM,KAAK;GACpB,KAAKH,WAAW,OAAO,KAAK;GAC5B,MAAM,QAAQ,UAAU;EAC1B;EAEA,KAAKI,YAAY,SAAS,QAAQ;GAChC,QACE,QAAQ,KAAI,MAAK,EAAE,KAAK,GACxB,GACF;GACA,QAAQ,SAAQ,MAAK,EAAE,QAAQ,YAAY,CAAC;EAC9C;EAEA,KAAKC,WAAW;EAEhB,KAAKJ,mBAAmB;CAC1B;;;;;;;;;;;;;CAcA,KAAK,OAAyB;EAC5B,MAAM,EAAC,SAAS,QAAQ,YAAW,SAAiB;EACpD,MAAM,QAAQ;GAAC;GAAO;EAAO;EAE7B,IAAI,KAAKK,WAAW;GAClB,MAAM,QAAQ,YAAY;GAC1B,OAAO,EAAC,OAAM;EAChB;EACA,MAAM,WAAW,KAAKR,WAAW,MAAM;EACvC,IAAI,UACF,SAAS,QAAQ,KAAK;OACjB,IACL,KAAKI,aACL,KAAKH,UAAU,UACf,KAAKA,UAAU,GAAG,EAAE,MAAM,YAC1B;GAEA,MAAM,OAAO,KAAKA,UAAU,GAAG,EAAE;GACjC,OAAO,SAAS,YAAY,yCAAyC;GACrE,KAAKA,UAAU,KAAKA,UAAU,SAAS,KAAK;IAC1C,OAAO,KAAKG,UAAU,OAAO,IAAI;IACjC;GACF;EACF,OACE,KAAKH,UAAU,KAAK,KAAK;EAE3B,OAAO,EAAC,OAAM;CAChB;;CAGA,IAAI,SAAkB;EACpB,OAAO,KAAKO,cAAc,KAAA;CAC5B;;CAGA,IAAI,SAAiB;EACnB,OAAO,KAAKP,UAAU;CACxB;;CAGA,IAAI,YAAoB;EACtB,OAAO,KAAKC,WAAW;CACzB;;CAGA,IAAI,SAAS;EACX,OAAO,KAAKH,iBAAiB;CAC/B;;;;;;;;;;;;;CAcA,MAAM;EACJ,IAAI,KAAKS,WAAW,CAEpB,OAAO,IAAI,KAAKP,UAAU,WAAW,GACnC,KAAK,OAAO;OAEZ,KAAKA,UAAU,KAAK,UAAU;CAElC;;;;;;;;;;CAWA,OAAO,KAAa;EAClB,KAAKQ,WAAW,OAAO,UAAU;CACnC;;CAGA,KAAK,KAAY;EACf,KAAKA,WAAW,GAAG;CACrB;CAEA,WAAW,UAA8B;EACvC,IAAI,CAAC,KAAKD,WAAW;GACnB,KAAKA,YAAY;GACjB,KAAKF,SACH,CAAC,GAAG,KAAKJ,YAAY,GAAG,KAAKD,UAAU,QAAO,MAAK,MAAM,UAAU,CAAC,GACpE,oBAAoB,QAAQ,WAAW,KAAA,CACzC;GACA,KAAKA,UAAU,OAAO,CAAC;GAEvB,KACE,IAAI,WAAW,KAAKD,WAAW,MAAM,GACrC,UACA,WAAW,KAAKA,WAAW,MAAM,GAEjC,aAAa,aACT,SAAS,QAAQ,IAAI,IACrB,SAAS,OAAO,QAAQ;GAE9B,KAAKD,iBAAiB,MAAM,QAAQ;EACtC;CACF;CAEA,IAAI,WAAwE;EAC1E,OAAO,KAAKI,mBACR,GAAE,OAAO,sBAAsB,KAAKO,UAAU,EAAC,IAC/C,KAAA;CACN;CAEA,YAA6D;EAC3D,OAAO;GACL,MAAM,YAAY;IAChB,MAAM,QAAQ,KAAKT,UAAU,MAAM;IACnC,IAAI,UAAU,YAAY;KACxB,KAAK,OAAO;KACZ,OAAO;MAAC,OAAO,KAAA;MAAW,MAAM;KAAI;IACtC;IACA,IAAI,UAAU,KAAA,GAAW;KACvB,KAAKC,WAAW,IAAI,KAAK;KACzB,OAAO,EACL,OAAO;MACL,OAAO,KAAKK,SAAS,MAAM,KAAK;MAChC,gBAAgB,KAAKF,UAAU,KAAK;KACtC,EACF;IACF;IACA,IAAI,KAAKG,cAAc,YACrB,OAAO;KAAC,OAAO,KAAA;KAAW,MAAM;IAAI;IAEtC,IAAI,KAAKA,WACP,OAAO,QAAQ,OAAO,KAAKA,SAAS;IAEtC,MAAM,WAAW,SAA0B;IAC3C,KAAKR,WAAW,KAAK,QAAQ;IAG7B,MAAM,SAAS,MAAM,SAAS;IAC9B,IAAI,WAAW,MAAM;KACnB,KAAKE,WAAW,IAAI,MAAM;KAC1B,OAAO,EACL,OAAO;MACL,OAAO,KAAKK,SAAS,OAAO,KAAK;MACjC,gBAAgB,KAAKF,UAAU,MAAM;KACvC,EACF;IACF;IACA,OAAO;KAAC,OAAO,KAAA;KAAW,MAAM;IAAI;GACtC;GAEA,SAAQ,UAAS;IACf,KAAK,OAAO;IACZ,OAAO,QAAQ,QAAQ;KAAC;KAAO,MAAM;IAAI,CAAC;GAC5C;EACF;CACF;CAEA,CAAC,OAAO,iBAAmC;EACzC,MAAM,WAAW,KAAKK,UAAU;EAEhC,IAAI,qBAAqB,CAAC;EAC1B,OAAO;GACL,MAAM,YAAY;IAChB,aAAa;IAEb,MAAM,QAAQ,MAAM,SAAS,KAAK;IAClC,IAAI,MAAM,MACR,OAAO;IAGT,MAAM,EAAC,OAAO,aAAY,MAAM;IAChC,eAAe;IACf,OAAO,EAAC,MAAK;GACf;GAEA,SAAQ,UAAS;IACf,aAAa;IAEb,KAAK,OAAO;IACZ,OAAO,QAAQ,QAAQ;KAAC;KAAO,MAAM;IAAI,CAAC;GAC5C;EACF;CACF;AACF"}

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

@@ -3,7 +3,9 @@ import WebSocket from 'ws';
 import type { Downstream } from '../../../zero-protocol/src/down.ts';
 import type { ErrorBody } from '../../../zero-protocol/src/error.ts';
 import { type ProtocolError } from '../../../zero-protocol/src/error.ts';
+import { type PokeChunk } from '../../../zero-protocol/src/poke.ts';
 import { type Upstream } from '../../../zero-protocol/src/up.ts';
+import type { ViewSyncerDownstream } from '../types/downstream.ts';
 import type { Source } from '../types/streams.ts';
 import type { ConnectParams } from './connect-params.ts';
 export type HandlerResult = {
@@ -17,7 +19,11 @@ export type HandlerResult = {
 } | StreamResult;
 export type StreamResult = {
     type: 'stream';
-    source: 'viewSyncer' | 'pusher';
+    source: 'viewSyncer';
+    stream: Source<ViewSyncerDownstream>;
+} | {
+    type: 'stream';
+    source: 'pusher';
     stream: Source<Downstream>;
 };
 export interface MessageHandler {
@@ -45,13 +51,25 @@ export declare class Connection {
     init(): boolean;
     close(reason: string, ...args: unknown[]): void;
     handleInitConnection(initConnectionMsg: string): Promise<void>;
-    send(data: Downstream, callback: ((err?: Error | null) => void) | 'ignore-backpressure'): void;
+    send(data: Downstream, callback: ((err?: Error | null) => void) | 'ignore-backpressure', serialized?: string | undefined): void;
     sendError(errorBody: ErrorBody, thrown?: unknown): void;
 }
 export type WebSocketLike = Pick<WebSocket, 'readyState'> & {
-    send(data: string, cb?: (err?: Error) => void): void;
+    send(data: string | PokeChunk, cb?: (err?: Error) => void): void;
 };
-export declare function send(lc: LogContext, ws: WebSocketLike, data: Downstream, callback: ((err?: Error | null) => void) | 'ignore-backpressure'): void;
+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.
+ *
+ * Exported for compatibility testing.
+ */
+export declare class DownstreamSender {
+    #private;
+    constructor(lc: LogContext, ws: WebSocketLike, protocolVersion: number);
+    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;
 export declare function findProtocolError(error: unknown): ProtocolError | undefined;
 //# sourceMappingURL=connection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/connection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAE3D,OAAO,SAAkC,MAAM,IAAI,CAAC;AAIpD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oCAAoC,CAAC;AAGnE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAiB,KAAK,QAAQ,EAAC,MAAM,kCAAkC,CAAC;AAO/E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAEvD,MAAM,MAAM,aAAa,GACrB;IACE,IAAI,EAAE,IAAI,CAAC;CACZ,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,SAAS,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB,GACD,YAAY,CAAC;AAEjB,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,YAAY,GAAG,QAAQ,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CACxD;AAcD,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAIhD;;;;;;;GAOG;AACH,qBAAa,UAAU;;gBAmBnB,EAAE,EAAE,UAAU,EACd,aAAa,EAAE,aAAa,EAC5B,EAAE,EAAE,SAAS,EACb,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,MAAM,IAAI;IA2BrB;;;;;;OAMG;IACH,IAAI,IAAI,OAAO;IAyBf,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAsBxC,oBAAoB,CAAC,iBAAiB,EAAE,MAAM;IA8J9C,IAAI,CACF,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC,GAAG,qBAAqB;IAMlE,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,OAAO;CAGjD;AAED,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG;IAC1D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;CACtD,CAAC;AAGF,wBAAgB,IAAI,CAClB,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC,GAAG,qBAAqB,QAmDjE;AAED,wBAAgB,SAAS,CACvB,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,SAAS,EACb,SAAS,EAAE,SAAS,EACpB,MAAM,CAAC,EAAE,OAAO,QA+BjB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAQ3E"}
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/connection.ts"],"names":[],"mappings":"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"}

package/out/zero-cache/src/workers/connection.js

@@ -3,10 +3,12 @@ import { parse } from "../../../shared/src/valita.js";
 import { Internal, InvalidMessage, VersionNotSupported } from "../../../zero-protocol/src/error-kind-enum.js";
 import { ZeroCache } from "../../../zero-protocol/src/error-origin-enum.js";
 import { isProtocolError } from "../../../zero-protocol/src/error.js";
+import "../../../zero-protocol/src/poke.js";
 import "../../../zero-protocol/src/protocol-version.js";
 import { getOrCreateCounter } from "../observability/metrics.js";
 import { ProtocolErrorWithLevel, getLogLevel, wrapWithProtocolError } from "../types/error-with-level.js";
 import { upstreamSchema } from "../../../zero-protocol/src/up.js";
+import { PokeChunkEncoder } from "../types/poke-chunk.js";
 import WebSocket$1, { createWebSocketStream } from "ws";
 import { Readable, Writable, pipeline } from "node:stream";
 //#region ../zero-cache/src/workers/connection.ts
@@ -29,6 +31,7 @@ var Connection = class {
 	#lc;
 	#onClose;
 	#messageHandler;
+	#downstreamSender;
 	#downstreamMsgTimer;
 	#webSocketErrors = getOrCreateCounter("sync", "websocket.errors", "Client WebSocket error events.");
 	#viewSyncerOutboundStream;
@@ -41,6 +44,7 @@ var Connection = class {
 		this.#wsID = wsID;
 		this.#protocolVersion = protocolVersion;
 		this.#lc = lc.withContext("connection").withContext("clientID", clientID).withContext("clientGroupID", clientGroupID).withContext("wsID", wsID);
+		this.#downstreamSender = new DownstreamSender(this.#lc, ws, protocolVersion);
 		this.#lc.debug?.("new connection");
 		this.#onClose = onClose;
 		this.#ws.addEventListener("close", this.#handleClose);
@@ -56,9 +60,9 @@ var Connection = class {
 	* will only parse messages with schema(s) of supported protocol versions.
 	*/
 	init() {
-		if (this.#protocolVersion > 51 || this.#protocolVersion < 30) this.#closeWithError({
+		if (this.#protocolVersion > 52 || this.#protocolVersion < 30) this.#closeWithError({
 			kind: VersionNotSupported,
-			message: `server is at sync protocol v51 and does not support v${this.#protocolVersion}. The ${this.#protocolVersion > 51 ? "server" : "client"} must be updated to a newer release.`,
+			message: `server is at sync protocol v52 and does not support v${this.#protocolVersion}. The ${this.#protocolVersion > 52 ? "server" : "client"} must be updated to a newer release.`,
 			origin: ZeroCache
 		});
 		else {
@@ -134,7 +138,8 @@ var Connection = class {
 						this.#pusherOutboundStream = result.stream;
 						break;
 				}
-				this.#proxyOutbound(result.stream);
+				if (result.source === "viewSyncer") this.#proxyOutbound(result.stream, (downstream, callback) => this.send(downstream.message, callback, downstream.serialized));
+				else this.#proxyOutbound(result.stream, (downstream, callback) => this.send(downstream, callback));
 				break;
 			case "transient": for (const error of result.errors) this.sendError(error);
 		}
@@ -163,10 +168,10 @@ var Connection = class {
 			this.#handleMessage({ data }).then(() => callback(), callback);
 		} }), () => {});
 	}
-	#proxyOutbound(outboundStream) {
+	#proxyOutbound(outboundStream, sendMessage) {
 		pipeline(Readable.from(outboundStream), new Writable({
 			objectMode: true,
-			write: (downstream, _encoding, callback) => this.send(downstream, callback)
+			write: (downstream, _encoding, callback) => sendMessage(downstream, callback)
 		}), (e) => e ? this.#closeWithThrown(e) : this.close(`downstream closed by ViewSyncer`));
 	}
 	#closeWithThrown(e) {
@@ -184,28 +189,24 @@ var Connection = class {
 			this.send(["pong", {}], "ignore-backpressure");
 		}
 	};
-	send(data, callback) {
+	send(data, callback, serialized) {
 		this.#lastDownstreamMsgTime = Date.now();
-		return send(this.#lc, this.#ws, data, callback);
+		this.#downstreamSender.send(data, callback, serialized);
 	}
 	sendError(errorBody, thrown) {
 		sendError(this.#lc, this.#ws, errorBody, thrown);
 	}
 };
-function send(lc, ws, data, callback) {
+function send(lc, ws, data, callback, serialized) {
 	if (ws.readyState === WebSocket$1.OPEN) {
-		const serialized = JSON.stringify(data);
+		serialized ??= JSON.stringify(data);
 		if (callback === "ignore-backpressure") {
 			ws.send(serialized);
 			return;
 		}
 		let completed = false;
 		const timer = setTimeout(() => {
-			complete(new ProtocolErrorWithLevel({
-				kind: Internal,
-				message: `WebSocket send timed out after ${WEBSOCKET_SEND_TIMEOUT_MS} ms`,
-				origin: ZeroCache
-			}, "info"));
+			complete(webSocketSendTimeoutError());
 		}, WEBSOCKET_SEND_TIMEOUT_MS);
 		timer.unref();
 		const complete = (error) => {
@@ -224,6 +225,103 @@ function send(lc, ws, data, callback) {
 		}, "info"));
 	}
 }
+/**
+* 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.
+*
+* Exported for compatibility testing.
+*/
+var DownstreamSender = class {
+	#lc;
+	#ws;
+	#protocolVersion;
+	#pokeChunkEncoder;
+	constructor(lc, ws, protocolVersion) {
+		this.#lc = lc;
+		this.#ws = ws;
+		this.#protocolVersion = protocolVersion;
+	}
+	send(data, callback, serialized) {
+		if (this.#protocolVersion >= 52) switch (data[0]) {
+			case "pokeStart":
+				assert(this.#pokeChunkEncoder === void 0, "cannot start a poke while another poke is in progress");
+				this.#pokeChunkEncoder = new PokeChunkEncoder();
+				break;
+			case "pokePart":
+				this.#sendPokePart(data, callback, serialized);
+				return;
+			case "pokeEnd":
+				this.#sendPokeEnd(data, callback);
+				return;
+		}
+		send(this.#lc, this.#ws, data, callback, serialized);
+	}
+	#sendPokePart(pokePart, callback, serialized) {
+		const encoder = this.#pokeChunkEncoder;
+		assert(encoder, "pokePart received without a pokeStart");
+		serialized ??= JSON.stringify(pokePart);
+		assert(serialized.startsWith(POKE_PART_PREFIX) && serialized.endsWith("]"), "invalid serialized pokePart");
+		encoder.addPatch(serialized.slice(POKE_PART_PREFIX.length, -1), (chunk) => sendBinary(this.#lc, this.#ws, chunk)).then(() => invokeCallback(callback), (error) => invokeCallback(callback, toError(error)));
+	}
+	#sendPokeEnd(pokeEnd, callback) {
+		const encoder = this.#pokeChunkEncoder;
+		assert(encoder, "pokeEnd received without a pokeStart");
+		this.#pokeChunkEncoder = void 0;
+		if (pokeEnd[1].cancel) {
+			encoder.cancel();
+			send(this.#lc, this.#ws, pokeEnd, callback);
+			return;
+		}
+		encoder.finish((chunk) => sendBinary(this.#lc, this.#ws, chunk)).then(() => sendAsync(this.#lc, this.#ws, pokeEnd)).then(() => invokeCallback(callback), (error) => invokeCallback(callback, toError(error)));
+	}
+};
+var POKE_PART_PREFIX = "[\"pokePart\",";
+function sendAsync(lc, ws, data) {
+	return new Promise((resolve, reject) => {
+		send(lc, ws, data, (error) => error ? reject(error) : resolve());
+	});
+}
+function sendBinary(lc, ws, chunk) {
+	return new Promise((resolve, reject) => {
+		if (ws.readyState !== WebSocket$1.OPEN) {
+			const error = webSocketClosedError();
+			lc.debug?.(`Dropping outbound binary message on ws (state: ${ws.readyState})`);
+			reject(error);
+			return;
+		}
+		let completed = false;
+		const timer = setTimeout(() => complete(webSocketSendTimeoutError()), WEBSOCKET_SEND_TIMEOUT_MS);
+		timer.unref();
+		const complete = (error) => {
+			if (completed) return;
+			completed = true;
+			clearTimeout(timer);
+			error ? reject(error) : resolve();
+		};
+		ws.send(chunk, complete);
+	});
+}
+function invokeCallback(callback, error) {
+	if (callback !== "ignore-backpressure") callback(error);
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function webSocketClosedError() {
+	return new ProtocolErrorWithLevel({
+		kind: Internal,
+		message: "WebSocket closed",
+		origin: ZeroCache
+	}, "info");
+}
+function webSocketSendTimeoutError() {
+	return new ProtocolErrorWithLevel({
+		kind: Internal,
+		message: `WebSocket send timed out after ${WEBSOCKET_SEND_TIMEOUT_MS} ms`,
+		origin: ZeroCache
+	}, "info");
+}
 function sendError(lc, ws, errorBody, thrown) {
 	lc = lc.withContext("errorKind", errorBody.kind);
 	let logLevel;

package/out/zero-cache/src/workers/connection.js.map

@@ -1 +1 @@
-{"version":3,"file":"connection.js","names":["#ws","#wsID","#protocolVersion","#lc","#onClose","#messageHandler","#downstreamMsgTimer","#webSocketErrors","#handleClose","#handleError","#proxyInbound","#maybeSendPong","#closeWithError","#closed","#viewSyncerOutboundStream","#pusherOutboundStream","#handleMessage","#handleMessageResult","#closeWithThrown","#proxyOutbound","#recordWebSocketError","#lastDownstreamMsgTime"],"sources":["../../../../../zero-cache/src/workers/connection.ts"],"sourcesContent":["import {pipeline, Readable, Writable} from 'node:stream';\nimport type {LogContext, LogLevel} from '@rocicorp/logger';\nimport type {CloseEvent, Data, ErrorEvent} from 'ws';\nimport WebSocket, {createWebSocketStream} from 'ws';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport * as valita from '../../../shared/src/valita.ts';\nimport type {ConnectedMessage} from '../../../zero-protocol/src/connect.ts';\nimport type {Downstream} from '../../../zero-protocol/src/down.ts';\nimport {ErrorKind} from '../../../zero-protocol/src/error-kind.ts';\nimport {ErrorOrigin} from '../../../zero-protocol/src/error-origin.ts';\nimport type {ErrorBody} from '../../../zero-protocol/src/error.ts';\nimport {\n  isProtocolError,\n  type ProtocolError,\n} from '../../../zero-protocol/src/error.ts';\nimport {\n  MIN_SERVER_SUPPORTED_SYNC_PROTOCOL,\n  PROTOCOL_VERSION,\n} from '../../../zero-protocol/src/protocol-version.ts';\nimport {upstreamSchema, type Upstream} from '../../../zero-protocol/src/up.ts';\nimport {getOrCreateCounter} from '../observability/metrics.ts';\nimport {\n  ProtocolErrorWithLevel,\n  getLogLevel,\n  wrapWithProtocolError,\n} from '../types/error-with-level.ts';\nimport type {Source} from '../types/streams.ts';\nimport type {ConnectParams} from './connect-params.ts';\n\nexport type HandlerResult =\n  | {\n      type: 'ok';\n    }\n  | {\n      type: 'fatal';\n      error: ErrorBody;\n    }\n  | {\n      type: 'transient';\n      errors: ErrorBody[];\n    }\n  | StreamResult;\n\nexport type StreamResult = {\n  type: 'stream';\n  source: 'viewSyncer' | 'pusher';\n  stream: Source<Downstream>;\n};\n\nexport interface MessageHandler {\n  handleMessage(msg: Upstream): Promise<HandlerResult[]>;\n}\n\n// Ensures that a downstream message is sent at least every interval, sending a\n// 'pong' if necessary. This is set to be slightly longer than the client-side\n// PING_INTERVAL of 5 seconds, so that in the common case, 'pong's are sent in\n// response to client-initiated 'ping's. However, if the inbound stream is\n// backed up because a command is taking a long time to process, the pings\n// will be stuck in the queue (i.e. back-pressured), in which case pongs will\n// be manually sent to notify the client of server liveness.\n//\n// This is equivalent to what is done for Postgres keepalives on the\n// replication stream (which can similarly be back-pressured):\n// https://github.com/rocicorp/mono/blob/f98cb369a2dbb15650328859c732db358f187ef0/packages/zero-cache/src/services/change-source/pg/logical-replication/stream.ts#L21\nconst DOWNSTREAM_MSG_INTERVAL_MS = 6_000;\nexport const WEBSOCKET_SEND_TIMEOUT_MS = 10_000;\nconst PROTOCOL_VERSION_ATTRIBUTE = 'protocol.version';\nconst EVENT_TYPE_ATTRIBUTE = 'event.type';\n\n/**\n * Represents a connection between the client and server.\n *\n * Handles incoming messages on the connection and dispatches\n * them to the correct service.\n *\n * Listens to the ViewSyncer and sends messages to the client.\n */\nexport class Connection {\n  readonly #ws: WebSocket;\n  readonly #wsID: string;\n  readonly #protocolVersion: number;\n  readonly #lc: LogContext;\n  readonly #onClose: () => void;\n  readonly #messageHandler: MessageHandler;\n  readonly #downstreamMsgTimer: NodeJS.Timeout | undefined;\n  readonly #webSocketErrors = getOrCreateCounter(\n    'sync',\n    'websocket.errors',\n    'Client WebSocket error events.',\n  );\n\n  #viewSyncerOutboundStream: Source<Downstream> | undefined;\n  #pusherOutboundStream: Source<Downstream> | undefined;\n  #closed = false;\n\n  constructor(\n    lc: LogContext,\n    connectParams: ConnectParams,\n    ws: WebSocket,\n    messageHandler: MessageHandler,\n    onClose: () => void,\n  ) {\n    const {clientGroupID, clientID, wsID, protocolVersion} = connectParams;\n    this.#messageHandler = messageHandler;\n\n    this.#ws = ws;\n    this.#wsID = wsID;\n    this.#protocolVersion = protocolVersion;\n\n    this.#lc = lc\n      .withContext('connection')\n      .withContext('clientID', clientID)\n      .withContext('clientGroupID', clientGroupID)\n      .withContext('wsID', wsID);\n    this.#lc.debug?.('new connection');\n    this.#onClose = onClose;\n\n    this.#ws.addEventListener('close', this.#handleClose);\n    this.#ws.addEventListener('error', this.#handleError);\n\n    this.#proxyInbound();\n    this.#downstreamMsgTimer = setInterval(\n      this.#maybeSendPong,\n      DOWNSTREAM_MSG_INTERVAL_MS / 2,\n    );\n  }\n\n  /**\n   * Checks the protocol version and errors for unsupported protocols,\n   * sending the initial `connected` response on success.\n   *\n   * This is early in the connection lifecycle because {@link #handleMessage}\n   * will only parse messages with schema(s) of supported protocol versions.\n   */\n  init(): boolean {\n    if (\n      this.#protocolVersion > PROTOCOL_VERSION ||\n      this.#protocolVersion < MIN_SERVER_SUPPORTED_SYNC_PROTOCOL\n    ) {\n      this.#closeWithError({\n        kind: ErrorKind.VersionNotSupported,\n        message: `server is at sync protocol v${PROTOCOL_VERSION} and does not support v${\n          this.#protocolVersion\n        }. The ${\n          this.#protocolVersion > PROTOCOL_VERSION ? 'server' : 'client'\n        } must be updated to a newer release.`,\n        origin: ErrorOrigin.ZeroCache,\n      });\n    } else {\n      const connectedMessage: ConnectedMessage = [\n        'connected',\n        {wsid: this.#wsID, timestamp: Date.now()},\n      ];\n      this.send(connectedMessage, 'ignore-backpressure');\n      return true;\n    }\n    return false;\n  }\n\n  close(reason: string, ...args: unknown[]) {\n    if (this.#closed) {\n      return;\n    }\n    this.#closed = true;\n    this.#lc.info?.(`closing connection: ${reason}`, ...args);\n    this.#ws.removeEventListener('close', this.#handleClose);\n    this.#ws.removeEventListener('error', this.#handleError);\n    this.#viewSyncerOutboundStream?.cancel();\n    this.#viewSyncerOutboundStream = undefined;\n    this.#pusherOutboundStream?.cancel();\n    this.#pusherOutboundStream = undefined;\n    this.#onClose();\n    if (this.#ws.readyState !== this.#ws.CLOSED) {\n      this.#ws.close();\n    }\n    clearTimeout(this.#downstreamMsgTimer);\n\n    // spin down services if we have\n    // no more client connections for the client group?\n  }\n\n  handleInitConnection(initConnectionMsg: string) {\n    return this.#handleMessage({data: initConnectionMsg});\n  }\n\n  #handleMessage = async (event: {data: Data}) => {\n    const data = event.data.toString();\n    if (this.#closed) {\n      this.#lc.debug?.('Ignoring message received after closed', data);\n      return;\n    }\n\n    let msg;\n    try {\n      const value = JSON.parse(data);\n      msg = valita.parse(value, upstreamSchema);\n    } catch (e) {\n      const errorBody = {\n        kind: ErrorKind.InvalidMessage,\n        message: String(e),\n        origin: ErrorOrigin.ZeroCache,\n      } as const;\n      this.#closeWithError(\n        errorBody,\n        new ProtocolErrorWithLevel(errorBody, 'warn'),\n      );\n      return;\n    }\n\n    try {\n      const msgType = msg[0];\n      if (msgType === 'ping') {\n        this.send(['pong', {}], 'ignore-backpressure');\n        return;\n      }\n\n      const result = await this.#messageHandler.handleMessage(msg);\n      for (const r of result) {\n        this.#handleMessageResult(r);\n      }\n    } catch (e) {\n      this.#closeWithThrown(e);\n    }\n  };\n\n  #handleMessageResult(result: HandlerResult): void {\n    switch (result.type) {\n      case 'fatal':\n        this.#closeWithError(result.error);\n        break;\n      case 'ok':\n        break;\n      case 'stream': {\n        switch (result.source) {\n          case 'viewSyncer':\n            assert(\n              this.#viewSyncerOutboundStream === undefined,\n              'Outbound stream already set for this connection!',\n            );\n            this.#viewSyncerOutboundStream = result.stream;\n            break;\n          case 'pusher':\n            assert(\n              this.#pusherOutboundStream === undefined,\n              'Outbound stream already set for this connection!',\n            );\n            this.#pusherOutboundStream = result.stream;\n            break;\n        }\n        this.#proxyOutbound(result.stream);\n        break;\n      }\n      case 'transient': {\n        for (const error of result.errors) {\n          this.sendError(error);\n        }\n      }\n    }\n  }\n\n  #handleClose = (e: CloseEvent) => {\n    const {code, reason, wasClean} = e;\n    if (!wasClean) {\n      this.#recordWebSocketError('unclean_close');\n    }\n    this.close('WebSocket close event', {code, reason, wasClean});\n  };\n\n  #handleError = (e: ErrorEvent) => {\n    this.#recordWebSocketError('error_event');\n    this.#lc.warn?.('WebSocket error event', e.message, e.error);\n  };\n\n  #recordWebSocketError(eventType: string) {\n    this.#webSocketErrors.add(1, {\n      [PROTOCOL_VERSION_ATTRIBUTE]: this.#protocolVersion,\n      [EVENT_TYPE_ATTRIBUTE]: eventType,\n    });\n  }\n\n  #proxyInbound() {\n    pipeline(\n      createWebSocketStream(this.#ws),\n      new Writable({\n        write: (data, _encoding, callback) => {\n          this.#handleMessage({data}).then(() => callback(), callback);\n        },\n      }),\n      // The done callback is not used, as #handleClose and #handleError,\n      // configured on the underlying WebSocket, provide more complete\n      // information.\n      () => {},\n    );\n  }\n\n  #proxyOutbound(outboundStream: Source<Downstream>) {\n    // Note: createWebSocketStream() is avoided here in order to control\n    //       exception handling with #closeWithThrown(). If the Writable\n    //       from createWebSocketStream() were instead used, exceptions\n    //       from the outboundStream result in the Writable closing the\n    //       the websocket before the error message can be sent.\n    pipeline(\n      Readable.from(outboundStream),\n      new Writable({\n        objectMode: true,\n        write: (downstream: Downstream, _encoding, callback) =>\n          this.send(downstream, callback),\n      }),\n      e =>\n        e\n          ? this.#closeWithThrown(e)\n          : this.close(`downstream closed by ViewSyncer`),\n    );\n  }\n\n  #closeWithThrown(e: unknown) {\n    const errorBody =\n      findProtocolError(e)?.errorBody ?? wrapWithProtocolError(e).errorBody;\n\n    this.#closeWithError(errorBody, e);\n  }\n\n  #closeWithError(errorBody: ErrorBody, thrown?: unknown) {\n    this.sendError(errorBody, thrown);\n    this.close(\n      `${errorBody.kind} (${errorBody.origin}): ${errorBody.message}`,\n      errorBody,\n    );\n  }\n\n  #lastDownstreamMsgTime = Date.now();\n\n  #maybeSendPong = () => {\n    if (Date.now() - this.#lastDownstreamMsgTime > DOWNSTREAM_MSG_INTERVAL_MS) {\n      this.#lc.debug?.('manually sending pong');\n      this.send(['pong', {}], 'ignore-backpressure');\n    }\n  };\n\n  send(\n    data: Downstream,\n    callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n  ) {\n    this.#lastDownstreamMsgTime = Date.now();\n    return send(this.#lc, this.#ws, data, callback);\n  }\n\n  sendError(errorBody: ErrorBody, thrown?: unknown) {\n    sendError(this.#lc, this.#ws, errorBody, thrown);\n  }\n}\n\nexport type WebSocketLike = Pick<WebSocket, 'readyState'> & {\n  send(data: string, cb?: (err?: Error) => void): void;\n};\n\n// Exported for testing purposes.\nexport function send(\n  lc: LogContext,\n  ws: WebSocketLike,\n  data: Downstream,\n  callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n) {\n  if (ws.readyState === WebSocket.OPEN) {\n    const serialized = JSON.stringify(data);\n    if (callback === 'ignore-backpressure') {\n      ws.send(serialized);\n      return;\n    }\n\n    let completed = false;\n    const timer = setTimeout(() => {\n      complete(\n        new ProtocolErrorWithLevel(\n          {\n            kind: ErrorKind.Internal,\n            message: `WebSocket send timed out after ${WEBSOCKET_SEND_TIMEOUT_MS} ms`,\n            origin: ErrorOrigin.ZeroCache,\n          },\n          'info',\n        ),\n      );\n    }, WEBSOCKET_SEND_TIMEOUT_MS);\n    timer.unref();\n\n    const complete = (error?: Error | null) => {\n      if (completed) {\n        return;\n      }\n      completed = true;\n      clearTimeout(timer);\n      callback(error);\n    };\n\n    ws.send(serialized, complete);\n  } else {\n    lc.debug?.(`Dropping outbound message on ws (state: ${ws.readyState})`, {\n      dropped: data,\n    });\n    if (callback !== 'ignore-backpressure') {\n      callback(\n        new ProtocolErrorWithLevel(\n          {\n            kind: ErrorKind.Internal,\n            message: 'WebSocket closed',\n            origin: ErrorOrigin.ZeroCache,\n          },\n          'info',\n        ),\n      );\n    }\n  }\n}\n\nexport function sendError(\n  lc: LogContext,\n  ws: WebSocket,\n  errorBody: ErrorBody,\n  thrown?: unknown,\n) {\n  lc = lc.withContext('errorKind', errorBody.kind);\n\n  let logLevel: LogLevel;\n\n  // If the thrown error is a ProtocolErrorWithLevel, its explicit logLevel takes precedence\n  if (thrown instanceof ProtocolErrorWithLevel) {\n    logLevel = thrown.logLevel;\n  }\n  // Errors with errno or transient socket codes are low-level, transient I/O issues\n  // (e.g., EPIPE, ECONNRESET) and should be warnings, not errors\n  else if (\n    hasErrno(thrown) ||\n    hasTransientSocketCode(thrown) ||\n    isTransientSocketMessage(errorBody.message)\n  ) {\n    logLevel = 'warn';\n  }\n  // Fallback: check errorBody.kind for errors that weren't thrown as ProtocolErrorWithLevel\n  else if (\n    errorBody.kind === ErrorKind.ClientNotFound ||\n    errorBody.kind === ErrorKind.TransformFailed\n  ) {\n    logLevel = 'warn';\n  } else {\n    logLevel = thrown ? getLogLevel(thrown) : 'info';\n  }\n\n  lc[logLevel]?.('Sending error on WebSocket', errorBody, thrown ?? '');\n  send(lc, ws, ['error', errorBody], 'ignore-backpressure');\n}\n\nexport function findProtocolError(error: unknown): ProtocolError | undefined {\n  if (isProtocolError(error)) {\n    return error;\n  }\n  if (error instanceof Error && error.cause) {\n    return findProtocolError(error.cause);\n  }\n  return undefined;\n}\n\nfunction hasErrno(error: unknown): boolean {\n  return Boolean(\n    error &&\n    typeof error === 'object' &&\n    'errno' in error &&\n    typeof (error as {errno: unknown}).errno !== 'undefined',\n  );\n}\n\n// System error codes that indicate transient socket conditions.\n// These are checked via the `code` property on errors.\nconst TRANSIENT_SOCKET_ERROR_CODES = new Set([\n  'EPIPE',\n  'ECONNRESET',\n  'ECANCELED',\n]);\n\n// Error messages that indicate transient socket conditions but don't have\n// standard error codes (e.g., WebSocket library errors).\nconst TRANSIENT_SOCKET_MESSAGE_PATTERNS = [\n  'socket was closed while data was being compressed',\n];\n\nfunction hasTransientSocketCode(error: unknown): boolean {\n  if (!error || typeof error !== 'object') {\n    return false;\n  }\n  const maybeCode =\n    'code' in error ? String((error as {code?: unknown}).code) : undefined;\n  return Boolean(\n    maybeCode && TRANSIENT_SOCKET_ERROR_CODES.has(maybeCode.toUpperCase()),\n  );\n}\n\nfunction isTransientSocketMessage(message: string | undefined): boolean {\n  if (!message) {\n    return false;\n  }\n  const lower = message.toLowerCase();\n  return TRANSIENT_SOCKET_MESSAGE_PATTERNS.some(pattern =>\n    lower.includes(pattern),\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"connection.js","names":["#ws","#wsID","#protocolVersion","#lc","#onClose","#messageHandler","#downstreamSender","#downstreamMsgTimer","#webSocketErrors","#handleClose","#handleError","#proxyInbound","#maybeSendPong","#closeWithError","#closed","#viewSyncerOutboundStream","#pusherOutboundStream","#handleMessage","#handleMessageResult","#closeWithThrown","#proxyOutbound","#recordWebSocketError","#lastDownstreamMsgTime","#pokeChunkEncoder","#sendPokePart","#sendPokeEnd"],"sources":["../../../../../zero-cache/src/workers/connection.ts"],"sourcesContent":["import {pipeline, Readable, Writable} from 'node:stream';\nimport type {LogContext, LogLevel} from '@rocicorp/logger';\nimport type {CloseEvent, Data, ErrorEvent} from 'ws';\nimport WebSocket, {createWebSocketStream} from 'ws';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport * as valita from '../../../shared/src/valita.ts';\nimport type {ConnectedMessage} from '../../../zero-protocol/src/connect.ts';\nimport type {Downstream} from '../../../zero-protocol/src/down.ts';\nimport {ErrorKind} from '../../../zero-protocol/src/error-kind.ts';\nimport {ErrorOrigin} from '../../../zero-protocol/src/error-origin.ts';\nimport type {ErrorBody} from '../../../zero-protocol/src/error.ts';\nimport {\n  isProtocolError,\n  type ProtocolError,\n} from '../../../zero-protocol/src/error.ts';\nimport {\n  POKE_CHUNK_PROTOCOL_VERSION,\n  type PokeChunk,\n  type PokeEndMessage,\n  type PokePartMessage,\n} from '../../../zero-protocol/src/poke.ts';\nimport {\n  MIN_SERVER_SUPPORTED_SYNC_PROTOCOL,\n  PROTOCOL_VERSION,\n} from '../../../zero-protocol/src/protocol-version.ts';\nimport {upstreamSchema, type Upstream} from '../../../zero-protocol/src/up.ts';\nimport {getOrCreateCounter} from '../observability/metrics.ts';\nimport type {ViewSyncerDownstream} from '../types/downstream.ts';\nimport {\n  ProtocolErrorWithLevel,\n  getLogLevel,\n  wrapWithProtocolError,\n} from '../types/error-with-level.ts';\nimport {PokeChunkEncoder} from '../types/poke-chunk.ts';\nimport type {Source} from '../types/streams.ts';\nimport type {ConnectParams} from './connect-params.ts';\n\nexport type HandlerResult =\n  | {\n      type: 'ok';\n    }\n  | {\n      type: 'fatal';\n      error: ErrorBody;\n    }\n  | {\n      type: 'transient';\n      errors: ErrorBody[];\n    }\n  | StreamResult;\n\nexport type StreamResult =\n  | {\n      type: 'stream';\n      source: 'viewSyncer';\n      stream: Source<ViewSyncerDownstream>;\n    }\n  | {\n      type: 'stream';\n      source: 'pusher';\n      stream: Source<Downstream>;\n    };\n\nexport interface MessageHandler {\n  handleMessage(msg: Upstream): Promise<HandlerResult[]>;\n}\n\n// Ensures that a downstream message is sent at least every interval, sending a\n// 'pong' if necessary. This is set to be slightly longer than the client-side\n// PING_INTERVAL of 5 seconds, so that in the common case, 'pong's are sent in\n// response to client-initiated 'ping's. However, if the inbound stream is\n// backed up because a command is taking a long time to process, the pings\n// will be stuck in the queue (i.e. back-pressured), in which case pongs will\n// be manually sent to notify the client of server liveness.\n//\n// This is equivalent to what is done for Postgres keepalives on the\n// replication stream (which can similarly be back-pressured):\n// https://github.com/rocicorp/mono/blob/f98cb369a2dbb15650328859c732db358f187ef0/packages/zero-cache/src/services/change-source/pg/logical-replication/stream.ts#L21\nconst DOWNSTREAM_MSG_INTERVAL_MS = 6_000;\nexport const WEBSOCKET_SEND_TIMEOUT_MS = 10_000;\nconst PROTOCOL_VERSION_ATTRIBUTE = 'protocol.version';\nconst EVENT_TYPE_ATTRIBUTE = 'event.type';\n\n/**\n * Represents a connection between the client and server.\n *\n * Handles incoming messages on the connection and dispatches\n * them to the correct service.\n *\n * Listens to the ViewSyncer and sends messages to the client.\n */\nexport class Connection {\n  readonly #ws: WebSocket;\n  readonly #wsID: string;\n  readonly #protocolVersion: number;\n  readonly #lc: LogContext;\n  readonly #onClose: () => void;\n  readonly #messageHandler: MessageHandler;\n  readonly #downstreamSender: DownstreamSender;\n  readonly #downstreamMsgTimer: NodeJS.Timeout | undefined;\n  readonly #webSocketErrors = getOrCreateCounter(\n    'sync',\n    'websocket.errors',\n    'Client WebSocket error events.',\n  );\n\n  #viewSyncerOutboundStream: Source<ViewSyncerDownstream> | undefined;\n  #pusherOutboundStream: Source<Downstream> | undefined;\n  #closed = false;\n\n  constructor(\n    lc: LogContext,\n    connectParams: ConnectParams,\n    ws: WebSocket,\n    messageHandler: MessageHandler,\n    onClose: () => void,\n  ) {\n    const {clientGroupID, clientID, wsID, protocolVersion} = connectParams;\n    this.#messageHandler = messageHandler;\n\n    this.#ws = ws;\n    this.#wsID = wsID;\n    this.#protocolVersion = protocolVersion;\n\n    this.#lc = lc\n      .withContext('connection')\n      .withContext('clientID', clientID)\n      .withContext('clientGroupID', clientGroupID)\n      .withContext('wsID', wsID);\n    this.#downstreamSender = new DownstreamSender(\n      this.#lc,\n      ws,\n      protocolVersion,\n    );\n    this.#lc.debug?.('new connection');\n    this.#onClose = onClose;\n\n    this.#ws.addEventListener('close', this.#handleClose);\n    this.#ws.addEventListener('error', this.#handleError);\n\n    this.#proxyInbound();\n    this.#downstreamMsgTimer = setInterval(\n      this.#maybeSendPong,\n      DOWNSTREAM_MSG_INTERVAL_MS / 2,\n    );\n  }\n\n  /**\n   * Checks the protocol version and errors for unsupported protocols,\n   * sending the initial `connected` response on success.\n   *\n   * This is early in the connection lifecycle because {@link #handleMessage}\n   * will only parse messages with schema(s) of supported protocol versions.\n   */\n  init(): boolean {\n    if (\n      this.#protocolVersion > PROTOCOL_VERSION ||\n      this.#protocolVersion < MIN_SERVER_SUPPORTED_SYNC_PROTOCOL\n    ) {\n      this.#closeWithError({\n        kind: ErrorKind.VersionNotSupported,\n        message: `server is at sync protocol v${PROTOCOL_VERSION} and does not support v${\n          this.#protocolVersion\n        }. The ${\n          this.#protocolVersion > PROTOCOL_VERSION ? 'server' : 'client'\n        } must be updated to a newer release.`,\n        origin: ErrorOrigin.ZeroCache,\n      });\n    } else {\n      const connectedMessage: ConnectedMessage = [\n        'connected',\n        {wsid: this.#wsID, timestamp: Date.now()},\n      ];\n      this.send(connectedMessage, 'ignore-backpressure');\n      return true;\n    }\n    return false;\n  }\n\n  close(reason: string, ...args: unknown[]) {\n    if (this.#closed) {\n      return;\n    }\n    this.#closed = true;\n    this.#lc.info?.(`closing connection: ${reason}`, ...args);\n    this.#ws.removeEventListener('close', this.#handleClose);\n    this.#ws.removeEventListener('error', this.#handleError);\n    this.#viewSyncerOutboundStream?.cancel();\n    this.#viewSyncerOutboundStream = undefined;\n    this.#pusherOutboundStream?.cancel();\n    this.#pusherOutboundStream = undefined;\n    this.#onClose();\n    if (this.#ws.readyState !== this.#ws.CLOSED) {\n      this.#ws.close();\n    }\n    clearTimeout(this.#downstreamMsgTimer);\n\n    // spin down services if we have\n    // no more client connections for the client group?\n  }\n\n  handleInitConnection(initConnectionMsg: string) {\n    return this.#handleMessage({data: initConnectionMsg});\n  }\n\n  #handleMessage = async (event: {data: Data}) => {\n    const data = event.data.toString();\n    if (this.#closed) {\n      this.#lc.debug?.('Ignoring message received after closed', data);\n      return;\n    }\n\n    let msg;\n    try {\n      const value = JSON.parse(data);\n      msg = valita.parse(value, upstreamSchema);\n    } catch (e) {\n      const errorBody = {\n        kind: ErrorKind.InvalidMessage,\n        message: String(e),\n        origin: ErrorOrigin.ZeroCache,\n      } as const;\n      this.#closeWithError(\n        errorBody,\n        new ProtocolErrorWithLevel(errorBody, 'warn'),\n      );\n      return;\n    }\n\n    try {\n      const msgType = msg[0];\n      if (msgType === 'ping') {\n        this.send(['pong', {}], 'ignore-backpressure');\n        return;\n      }\n\n      const result = await this.#messageHandler.handleMessage(msg);\n      for (const r of result) {\n        this.#handleMessageResult(r);\n      }\n    } catch (e) {\n      this.#closeWithThrown(e);\n    }\n  };\n\n  #handleMessageResult(result: HandlerResult): void {\n    switch (result.type) {\n      case 'fatal':\n        this.#closeWithError(result.error);\n        break;\n      case 'ok':\n        break;\n      case 'stream': {\n        switch (result.source) {\n          case 'viewSyncer':\n            assert(\n              this.#viewSyncerOutboundStream === undefined,\n              'Outbound stream already set for this connection!',\n            );\n            this.#viewSyncerOutboundStream = result.stream;\n            break;\n          case 'pusher':\n            assert(\n              this.#pusherOutboundStream === undefined,\n              'Outbound stream already set for this connection!',\n            );\n            this.#pusherOutboundStream = result.stream;\n            break;\n        }\n        if (result.source === 'viewSyncer') {\n          this.#proxyOutbound(result.stream, (downstream, callback) =>\n            this.send(downstream.message, callback, downstream.serialized),\n          );\n        } else {\n          this.#proxyOutbound(result.stream, (downstream, callback) =>\n            this.send(downstream, callback),\n          );\n        }\n        break;\n      }\n      case 'transient': {\n        for (const error of result.errors) {\n          this.sendError(error);\n        }\n      }\n    }\n  }\n\n  #handleClose = (e: CloseEvent) => {\n    const {code, reason, wasClean} = e;\n    if (!wasClean) {\n      this.#recordWebSocketError('unclean_close');\n    }\n    this.close('WebSocket close event', {code, reason, wasClean});\n  };\n\n  #handleError = (e: ErrorEvent) => {\n    this.#recordWebSocketError('error_event');\n    this.#lc.warn?.('WebSocket error event', e.message, e.error);\n  };\n\n  #recordWebSocketError(eventType: string) {\n    this.#webSocketErrors.add(1, {\n      [PROTOCOL_VERSION_ATTRIBUTE]: this.#protocolVersion,\n      [EVENT_TYPE_ATTRIBUTE]: eventType,\n    });\n  }\n\n  #proxyInbound() {\n    pipeline(\n      createWebSocketStream(this.#ws),\n      new Writable({\n        write: (data, _encoding, callback) => {\n          this.#handleMessage({data}).then(() => callback(), callback);\n        },\n      }),\n      // The done callback is not used, as #handleClose and #handleError,\n      // configured on the underlying WebSocket, provide more complete\n      // information.\n      () => {},\n    );\n  }\n\n  #proxyOutbound<T>(\n    outboundStream: Source<T>,\n    sendMessage: (\n      downstream: T,\n      callback: (err?: Error | null) => void,\n    ) => void,\n  ) {\n    // Note: createWebSocketStream() is avoided here in order to control\n    //       exception handling with #closeWithThrown(). If the Writable\n    //       from createWebSocketStream() were instead used, exceptions\n    //       from the outboundStream result in the Writable closing the\n    //       the websocket before the error message can be sent.\n    pipeline(\n      Readable.from(outboundStream),\n      new Writable({\n        objectMode: true,\n        write: (downstream: T, _encoding, callback) =>\n          sendMessage(downstream, callback),\n      }),\n      e =>\n        e\n          ? this.#closeWithThrown(e)\n          : this.close(`downstream closed by ViewSyncer`),\n    );\n  }\n\n  #closeWithThrown(e: unknown) {\n    const errorBody =\n      findProtocolError(e)?.errorBody ?? wrapWithProtocolError(e).errorBody;\n\n    this.#closeWithError(errorBody, e);\n  }\n\n  #closeWithError(errorBody: ErrorBody, thrown?: unknown) {\n    this.sendError(errorBody, thrown);\n    this.close(\n      `${errorBody.kind} (${errorBody.origin}): ${errorBody.message}`,\n      errorBody,\n    );\n  }\n\n  #lastDownstreamMsgTime = Date.now();\n\n  #maybeSendPong = () => {\n    if (Date.now() - this.#lastDownstreamMsgTime > DOWNSTREAM_MSG_INTERVAL_MS) {\n      this.#lc.debug?.('manually sending pong');\n      this.send(['pong', {}], 'ignore-backpressure');\n    }\n  };\n\n  send(\n    data: Downstream,\n    callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n    serialized?: string | undefined,\n  ) {\n    this.#lastDownstreamMsgTime = Date.now();\n    this.#downstreamSender.send(data, callback, serialized);\n  }\n\n  sendError(errorBody: ErrorBody, thrown?: unknown) {\n    sendError(this.#lc, this.#ws, errorBody, thrown);\n  }\n}\n\nexport type WebSocketLike = Pick<WebSocket, 'readyState'> & {\n  send(data: string | PokeChunk, cb?: (err?: Error) => void): void;\n};\n\n// Exported for testing purposes.\nexport function send(\n  lc: LogContext,\n  ws: WebSocketLike,\n  data: Downstream,\n  callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n  serialized?: string | undefined,\n) {\n  if (ws.readyState === WebSocket.OPEN) {\n    serialized ??= JSON.stringify(data);\n    if (callback === 'ignore-backpressure') {\n      ws.send(serialized);\n      return;\n    }\n\n    let completed = false;\n    const timer = setTimeout(() => {\n      complete(webSocketSendTimeoutError());\n    }, WEBSOCKET_SEND_TIMEOUT_MS);\n    timer.unref();\n\n    const complete = (error?: Error | null) => {\n      if (completed) {\n        return;\n      }\n      completed = true;\n      clearTimeout(timer);\n      callback(error);\n    };\n\n    ws.send(serialized, complete);\n  } else {\n    lc.debug?.(`Dropping outbound message on ws (state: ${ws.readyState})`, {\n      dropped: data,\n    });\n    if (callback !== 'ignore-backpressure') {\n      callback(\n        new ProtocolErrorWithLevel(\n          {\n            kind: ErrorKind.Internal,\n            message: 'WebSocket closed',\n            origin: ErrorOrigin.ZeroCache,\n          },\n          'info',\n        ),\n      );\n    }\n  }\n}\n\n/**\n * Sends downstream messages in the format supported by a connection's sync\n * protocol version. Keep version forks contained here so the view-syncer can\n * continue producing one canonical poke representation.\n *\n * Exported for compatibility testing.\n */\nexport class DownstreamSender {\n  readonly #lc: LogContext;\n  readonly #ws: WebSocketLike;\n  readonly #protocolVersion: number;\n  #pokeChunkEncoder: PokeChunkEncoder | undefined;\n\n  constructor(lc: LogContext, ws: WebSocketLike, protocolVersion: number) {\n    this.#lc = lc;\n    this.#ws = ws;\n    this.#protocolVersion = protocolVersion;\n  }\n\n  send(\n    data: Downstream,\n    callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n    serialized?: string | undefined,\n  ): void {\n    if (this.#protocolVersion >= POKE_CHUNK_PROTOCOL_VERSION) {\n      switch (data[0]) {\n        case 'pokeStart':\n          assert(\n            this.#pokeChunkEncoder === undefined,\n            'cannot start a poke while another poke is in progress',\n          );\n          this.#pokeChunkEncoder = new PokeChunkEncoder();\n          break;\n        case 'pokePart':\n          this.#sendPokePart(data, callback, serialized);\n          return;\n        case 'pokeEnd':\n          this.#sendPokeEnd(data, callback);\n          return;\n      }\n    }\n    send(this.#lc, this.#ws, data, callback, serialized);\n  }\n\n  #sendPokePart(\n    pokePart: PokePartMessage,\n    callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n    serialized?: string | undefined,\n  ): void {\n    const encoder = this.#pokeChunkEncoder;\n    assert(encoder, 'pokePart received without a pokeStart');\n\n    serialized ??= JSON.stringify(pokePart);\n    assert(\n      serialized.startsWith(POKE_PART_PREFIX) && serialized.endsWith(']'),\n      'invalid serialized pokePart',\n    );\n    void encoder\n      .addPatch(serialized.slice(POKE_PART_PREFIX.length, -1), chunk =>\n        sendBinary(this.#lc, this.#ws, chunk),\n      )\n      .then(\n        () => invokeCallback(callback),\n        error => invokeCallback(callback, toError(error)),\n      );\n  }\n\n  #sendPokeEnd(\n    pokeEnd: PokeEndMessage,\n    callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n  ): void {\n    const encoder = this.#pokeChunkEncoder;\n    assert(encoder, 'pokeEnd received without a pokeStart');\n    this.#pokeChunkEncoder = undefined;\n\n    if (pokeEnd[1].cancel) {\n      encoder.cancel();\n      send(this.#lc, this.#ws, pokeEnd, callback);\n      return;\n    }\n\n    void encoder\n      .finish(chunk => sendBinary(this.#lc, this.#ws, chunk))\n      .then(() => sendAsync(this.#lc, this.#ws, pokeEnd))\n      .then(\n        () => invokeCallback(callback),\n        error => invokeCallback(callback, toError(error)),\n      );\n  }\n}\n\nconst POKE_PART_PREFIX = '[\"pokePart\",';\n\nfunction sendAsync(\n  lc: LogContext,\n  ws: WebSocketLike,\n  data: Downstream,\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    send(lc, ws, data, error => (error ? reject(error) : resolve()));\n  });\n}\n\nfunction sendBinary(\n  lc: LogContext,\n  ws: WebSocketLike,\n  chunk: PokeChunk,\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (ws.readyState !== WebSocket.OPEN) {\n      const error = webSocketClosedError();\n      lc.debug?.(\n        `Dropping outbound binary message on ws (state: ${ws.readyState})`,\n      );\n      reject(error);\n      return;\n    }\n    let completed = false;\n    const timer = setTimeout(\n      () => complete(webSocketSendTimeoutError()),\n      WEBSOCKET_SEND_TIMEOUT_MS,\n    );\n    timer.unref();\n\n    const complete = (error?: Error | null) => {\n      if (completed) {\n        return;\n      }\n      completed = true;\n      clearTimeout(timer);\n      error ? reject(error) : resolve();\n    };\n\n    ws.send(chunk, complete);\n  });\n}\n\nfunction invokeCallback(\n  callback: ((err?: Error | null) => void) | 'ignore-backpressure',\n  error?: Error,\n): void {\n  if (callback !== 'ignore-backpressure') {\n    callback(error);\n  }\n}\n\nfunction toError(error: unknown): Error {\n  return error instanceof Error ? error : new Error(String(error));\n}\n\nfunction webSocketClosedError(): ProtocolErrorWithLevel {\n  return new ProtocolErrorWithLevel(\n    {\n      kind: ErrorKind.Internal,\n      message: 'WebSocket closed',\n      origin: ErrorOrigin.ZeroCache,\n    },\n    'info',\n  );\n}\n\nfunction webSocketSendTimeoutError(): ProtocolErrorWithLevel {\n  return new ProtocolErrorWithLevel(\n    {\n      kind: ErrorKind.Internal,\n      message: `WebSocket send timed out after ${WEBSOCKET_SEND_TIMEOUT_MS} ms`,\n      origin: ErrorOrigin.ZeroCache,\n    },\n    'info',\n  );\n}\n\nexport function sendError(\n  lc: LogContext,\n  ws: WebSocket,\n  errorBody: ErrorBody,\n  thrown?: unknown,\n) {\n  lc = lc.withContext('errorKind', errorBody.kind);\n\n  let logLevel: LogLevel;\n\n  // If the thrown error is a ProtocolErrorWithLevel, its explicit logLevel takes precedence\n  if (thrown instanceof ProtocolErrorWithLevel) {\n    logLevel = thrown.logLevel;\n  }\n  // Errors with errno or transient socket codes are low-level, transient I/O issues\n  // (e.g., EPIPE, ECONNRESET) and should be warnings, not errors\n  else if (\n    hasErrno(thrown) ||\n    hasTransientSocketCode(thrown) ||\n    isTransientSocketMessage(errorBody.message)\n  ) {\n    logLevel = 'warn';\n  }\n  // Fallback: check errorBody.kind for errors that weren't thrown as ProtocolErrorWithLevel\n  else if (\n    errorBody.kind === ErrorKind.ClientNotFound ||\n    errorBody.kind === ErrorKind.TransformFailed\n  ) {\n    logLevel = 'warn';\n  } else {\n    logLevel = thrown ? getLogLevel(thrown) : 'info';\n  }\n\n  lc[logLevel]?.('Sending error on WebSocket', errorBody, thrown ?? '');\n  send(lc, ws, ['error', errorBody], 'ignore-backpressure');\n}\n\nexport function findProtocolError(error: unknown): ProtocolError | undefined {\n  if (isProtocolError(error)) {\n    return error;\n  }\n  if (error instanceof Error && error.cause) {\n    return findProtocolError(error.cause);\n  }\n  return undefined;\n}\n\nfunction hasErrno(error: unknown): boolean {\n  return Boolean(\n    error &&\n    typeof error === 'object' &&\n    'errno' in error &&\n    typeof (error as {errno: unknown}).errno !== 'undefined',\n  );\n}\n\n// System error codes that indicate transient socket conditions.\n// These are checked via the `code` property on errors.\nconst TRANSIENT_SOCKET_ERROR_CODES = new Set([\n  'EPIPE',\n  'ECONNRESET',\n  'ECANCELED',\n]);\n\n// Error messages that indicate transient socket conditions but don't have\n// standard error codes (e.g., WebSocket library errors).\nconst TRANSIENT_SOCKET_MESSAGE_PATTERNS = [\n  'socket was closed while data was being compressed',\n];\n\nfunction hasTransientSocketCode(error: unknown): boolean {\n  if (!error || typeof error !== 'object') {\n    return false;\n  }\n  const maybeCode =\n    'code' in error ? String((error as {code?: unknown}).code) : undefined;\n  return Boolean(\n    maybeCode && TRANSIENT_SOCKET_ERROR_CODES.has(maybeCode.toUpperCase()),\n  );\n}\n\nfunction isTransientSocketMessage(message: string | undefined): boolean {\n  if (!message) {\n    return false;\n  }\n  const lower = message.toLowerCase();\n  return TRANSIENT_SOCKET_MESSAGE_PATTERNS.some(pattern =>\n    lower.includes(pattern),\n  );\n}\n"],"mappings":"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"}

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

@@ -43,6 +43,7 @@ export declare function getPragmaConfig(mode: ReplicaFileMode): PragmaConfig;
 export declare function setupReplica(lc: LogContext, mode: ReplicaFileMode, replicaOptions: ReplicaOptions): Promise<{
     file: string;
     walMode: WalMode;
+    pageSize: number;
 }>;
 export declare function setUpMessageHandlers(lc: LogContext, replicator: Replicator, parent: Worker): void;
 export declare function handleSubscriptionsFrom(lc: LogContext, subscriber: Worker, notifier: ReplicaStateNotifier): void;

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

@@ -1 +1 @@
-{"version":3,"file":"replicator.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/replicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AAEnD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAC;AAI7D,OAAO,EAAC,QAAQ,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACpB,UAAU,EACX,MAAM,sCAAsC,CAAC;AAK9C,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAElD,eAAO,MAAM,qBAAqB,+CAIjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAErC,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,UAEzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM,GACb,OAAO,CAMT;AA4FD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,CAMnE;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,eAAe,EACrB,cAAc,EAAE,cAAc;UAlGd,MAAM;aAAW,OAAO;GAiIzC;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,QAGf;AAID,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,oBAAoB,QA8B/B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACvC,QAAQ,CAOV;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,QAE1D"}
+{"version":3,"file":"replicator.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/replicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AAEnD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAC;AAI7D,OAAO,EAAC,QAAQ,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACpB,UAAU,EACX,MAAM,sCAAsC,CAAC;AAK9C,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAElD,eAAO,MAAM,qBAAqB,+CAIjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAErC,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,UAEzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM,GACb,OAAO,CAMT;AA2FD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,CAMnE;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,eAAe,EACrB,cAAc,EAAE,cAAc;UAjGd,MAAM;aAAW,OAAO;cAAY,MAAM;GAgI3D;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,QAGf;AAID,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,oBAAoB,QA8B/B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACvC,QAAQ,CAOV;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,QAE1D"}

package/out/zero-cache/src/workers/replicator.js

@@ -48,9 +48,10 @@ var MB = 1024 * 1024;
 async function prepare(lc, { file, vacuumIntervalHours }, walMode, mode) {
 	await upgradeReplica(lc, `${mode}-replica`, file);
 	const replica = new Database(lc, file);
+	let pageSize;
 	try {
 		await setJournalMode(lc, replica, "delete");
-		const [{ page_size: pageSize }] = replica.pragma("page_size");
+		[{page_size: pageSize}] = replica.pragma("page_size");
 		const [{ page_count: pageCount }] = replica.pragma("page_count");
 		const [{ freelist_count: freelistCount }] = replica.pragma("freelist_count");
 		const dbSize = (pageCount * pageSize / MB).toFixed(2);
@@ -80,7 +81,8 @@ async function prepare(lc, { file, vacuumIntervalHours }, walMode, mode) {
 	}
 	return {
 		file,
-		walMode
+		walMode,
+		pageSize
 	};
 }
 async function setJournalMode(lc, replica, mode) {