@rocicorp/zero 0.25.0-canary.7 → 0.25.0-canary.8

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

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

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

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

package/out/zero-cache/src/types/url-params.js

@@ -1,35 +1,40 @@
-export class URLParams {
-    url;
-    constructor(url) {
-        this.url = url;
+class URLParams {
+  url;
+  constructor(url) {
+    this.url = url;
+  }
+  get(name, required) {
+    const value = this.url.searchParams.get(name);
+    if (value === "" || value === null) {
+      if (required) {
+        throw new Error(`invalid querystring - missing ${name}`);
+      }
+      return null;
     }
-    get(name, required) {
-        const value = this.url.searchParams.get(name);
-        if (value === '' || value === null) {
-            if (required) {
-                throw new Error(`invalid querystring - missing ${name}`);
-            }
-            return null;
-        }
-        return value;
+    return value;
+  }
+  getInteger(name, required) {
+    const value = this.get(name, required);
+    if (value === null) {
+      return null;
     }
-    getInteger(name, required) {
-        const value = this.get(name, required);
-        if (value === null) {
-            return null;
-        }
-        const int = parseInt(value);
-        if (isNaN(int)) {
-            throw new Error(`invalid querystring parameter ${name}, got: ${value}, url: ${this.url}`);
-        }
-        return int;
+    const int = parseInt(value);
+    if (isNaN(int)) {
+      throw new Error(
+        `invalid querystring parameter ${name}, got: ${value}, url: ${this.url}`
+      );
     }
-    getBoolean(name) {
-        const value = this.get(name, false);
-        if (value === null) {
-            return false;
-        }
-        return value === 'true';
+    return int;
+  }
+  getBoolean(name) {
+    const value = this.get(name, false);
+    if (value === null) {
+      return false;
     }
+    return value === "true";
+  }
 }
-//# sourceMappingURL=url-params.js.map
+export {
+  URLParams
+};
+//# sourceMappingURL=url-params.js.map

package/out/zero-cache/src/types/url-params.js.map

@@ -1 +1 @@
-{"version":3,"file":"url-params.js","sourceRoot":"","sources":["../../../../../zero-cache/src/types/url-params.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,SAAS;IACX,GAAG,CAAM;IAElB,YAAY,GAAQ;QAClB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAID,GAAG,CAAC,IAAY,EAAE,QAAiB;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnC,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,EAAE,CAAC,CAAC;YAC3D,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAID,UAAU,CAAC,IAAY,EAAE,QAAiB;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACvC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CACb,iCAAiC,IAAI,UAAU,KAAK,UAAU,IAAI,CAAC,GAAG,EAAE,CACzE,CAAC;QACJ,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,UAAU,CAAC,IAAY;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACpC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,KAAK,KAAK,MAAM,CAAC;IAC1B,CAAC;CACF"}
+{"version":3,"file":"url-params.js","sources":["../../../../../zero-cache/src/types/url-params.ts"],"sourcesContent":["export class URLParams {\n  readonly url: URL;\n\n  constructor(url: URL) {\n    this.url = url;\n  }\n\n  get(name: string, required: true): string;\n  get(name: string, required: boolean): string | null;\n  get(name: string, required: boolean) {\n    const value = this.url.searchParams.get(name);\n    if (value === '' || value === null) {\n      if (required) {\n        throw new Error(`invalid querystring - missing ${name}`);\n      }\n      return null;\n    }\n    return value;\n  }\n\n  getInteger(name: string, required: true): number;\n  getInteger(name: string, required: boolean): number | null;\n  getInteger(name: string, required: boolean) {\n    const value = this.get(name, required);\n    if (value === null) {\n      return null;\n    }\n    const int = parseInt(value);\n    if (isNaN(int)) {\n      throw new Error(\n        `invalid querystring parameter ${name}, got: ${value}, url: ${this.url}`,\n      );\n    }\n    return int;\n  }\n\n  getBoolean(name: string): boolean {\n    const value = this.get(name, false);\n    if (value === null) {\n      return false;\n    }\n    return value === 'true';\n  }\n}\n"],"names":[],"mappings":"AAAO,MAAM,UAAU;AAAA,EACZ;AAAA,EAET,YAAY,KAAU;AACpB,SAAK,MAAM;AAAA,EACb;AAAA,EAIA,IAAI,MAAc,UAAmB;AACnC,UAAM,QAAQ,KAAK,IAAI,aAAa,IAAI,IAAI;AAC5C,QAAI,UAAU,MAAM,UAAU,MAAM;AAClC,UAAI,UAAU;AACZ,cAAM,IAAI,MAAM,iCAAiC,IAAI,EAAE;AAAA,MACzD;AACA,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAIA,WAAW,MAAc,UAAmB;AAC1C,UAAM,QAAQ,KAAK,IAAI,MAAM,QAAQ;AACrC,QAAI,UAAU,MAAM;AAClB,aAAO;AAAA,IACT;AACA,UAAM,MAAM,SAAS,KAAK;AAC1B,QAAI,MAAM,GAAG,GAAG;AACd,YAAM,IAAI;AAAA,QACR,iCAAiC,IAAI,UAAU,KAAK,UAAU,KAAK,GAAG;AAAA,MAAA;AAAA,IAE1E;AACA,WAAO;AAAA,EACT;AAAA,EAEA,WAAW,MAAuB;AAChC,UAAM,QAAQ,KAAK,IAAI,MAAM,KAAK;AAClC,QAAI,UAAU,MAAM;AAClB,aAAO;AAAA,IACT;AACA,WAAO,UAAU;AAAA,EACnB;AACF;"}

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

@@ -1,9 +1,10 @@
 import type { LogContext } from '@rocicorp/logger';
 import { Server } from 'node:http';
-import { Socket } from 'node:net';
+import type { Socket } from 'node:net';
 import { WebSocketServer, type ServerOptions, type WebSocket } from 'ws';
 import { type IncomingMessageSubset } from './http.ts';
-import { MESSAGE_TYPES, type Receiver, type Sender, type Worker } from './processes.ts';
+import type { MESSAGE_TYPES } from './processes.ts';
+import { type Receiver, type Sender, type Worker } from './processes.ts';
 export type HandoffSpec<P> = {
     payload: P;
     sender: Sender;