@rocicorp/zero 0.0.0-202410031711

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=specs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"specs.js","sourceRoot":"","sources":["../../../../../zero-cache/src/types/specs.ts"],"names":[],"mappings":""}

package/out/zero-cache/src/types/sql.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Escapes the identifier with double quotes, as per:
+ *
+ * https://www.postgresql.org/docs/16/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
+ */
+export declare function id(name: string): string;
+/**
+ * Escapes and comma-separates a list of identifiers.
+ */
+export declare function idList(names: Iterable<string>): string;
+//# sourceMappingURL=sql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/sql.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,CAEtD"}

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

@@ -0,0 +1,15 @@
+/**
+ * Escapes the identifier with double quotes, as per:
+ *
+ * https://www.postgresql.org/docs/16/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
+ */
+export function id(name) {
+    return '"' + name.replace(/"/g, '""') + '"'; //.replace(/\./g, '"."') + '"';
+}
+/**
+ * Escapes and comma-separates a list of identifiers.
+ */
+export function idList(names) {
+    return Array.from(names, name => id(name)).join(',');
+}
+//# sourceMappingURL=sql.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql.js","sourceRoot":"","sources":["../../../../../zero-cache/src/types/sql.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,EAAE,CAAC,IAAY;IAC7B,OAAO,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,+BAA+B;AAC9E,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,MAAM,CAAC,KAAuB;IAC5C,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACvD,CAAC"}

package/out/zero-cache/src/types/streams.d.ts

@@ -0,0 +1,33 @@
+import type { LogContext } from '@rocicorp/logger';
+import * as v from '../../../shared/src/valita.js';
+import type { WebSocket } from 'ws';
+import { type JSONValue } from './bigint-json.js';
+export type Source<T> = AsyncIterable<T> & {
+    /**
+     * Immediately terminates all current iterations (i.e. {@link AsyncIterator.next next()})
+     * will return `{value: undefined, done: true}`), and prevents any subsequent iterations
+     * from yielding any values.
+     */
+    cancel: () => void;
+    /**
+     * The presence of a `pipeline` iterable allows the usual "consumed-on-iterate" semantics
+     * to be overridden.
+     *
+     * This is suitable for transport layers that serialize messages across processes, such
+     * as the {@link streamOut()} method; pipelining allows the transport to send messages
+     * as they arrive without waiting for the previous message to be acked, streaming
+     * them to the receiving process where they are presumably queued and processed without
+     * a per-message ack delay. The receiving end of the transport then responds with acks
+     * asynchronously as the receiving end processes the messages.
+     */
+    pipeline?: AsyncIterable<{
+        value: T;
+        consumed: () => void;
+    }> | undefined;
+};
+export type Sink<T> = {
+    push(message: T): void;
+};
+export declare function streamOut<T extends JSONValue>(lc: LogContext, source: Source<T>, sink: WebSocket): Promise<void>;
+export declare function streamIn<T extends JSONValue>(lc: LogContext, source: WebSocket, schema: v.Type<T>): Source<T>;
+//# sourceMappingURL=streams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/streams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,KAAK,EAAuC,SAAS,EAAC,MAAM,IAAI,CAAC;AACxE,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAG5D,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG;IACzC;;;;OAIG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAAC;CACxE,CAAC;AAEF,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;IACpB,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;CACxB,CAAC;AAcF,wBAAsB,SAAS,CAAC,CAAC,SAAS,SAAS,EACjD,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,IAAI,CAAC,CAsDf;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,EAC1C,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAChB,MAAM,CAAC,CAAC,CAAC,CAkCX"}

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

@@ -0,0 +1,141 @@
+import { Queue } from '../../../shared/src/queue.js';
+import * as v from '../../../shared/src/valita.js';
+import { BigIntJSON } from './bigint-json.js';
+import { Subscription } from './subscription.js';
+const ackSchema = v.object({ ack: v.number() });
+export async function streamOut(lc, source, sink) {
+    const closer = new WebSocketCloser(lc, sink, source);
+    const acks = new Queue();
+    sink.addEventListener('message', ({ data }) => {
+        try {
+            if (typeof data !== 'string') {
+                throw new Error('Expected string message');
+            }
+            void acks.enqueue(v.parse(JSON.parse(data), ackSchema));
+        }
+        catch (e) {
+            lc.error?.(`error parsing ack`, e);
+            closer.close(e);
+        }
+    });
+    try {
+        let nextID = 0;
+        const { pipeline } = source;
+        if (pipeline) {
+            lc.debug?.(`started pipelined outbound stream`);
+            for await (const { value: msg, consumed } of pipeline) {
+                const id = ++nextID;
+                const data = BigIntJSON.stringify({ msg, id });
+                // Enable for debugging. Otherwise too verbose.
+                // lc.debug?.(`pipelining`, data);
+                sink.send(data);
+                void acks.dequeue().then(({ ack }) => {
+                    // lc.debug?.(`received ack`, ack);
+                    if (ack !== id) {
+                        throw new Error(`Unexpected ack for ${id}: ${ack}`);
+                    }
+                    consumed();
+                });
+            }
+        }
+        else {
+            for await (const msg of source) {
+                const id = ++nextID;
+                const data = BigIntJSON.stringify({ msg, id });
+                // Enable for debugging. Otherwise too verbose.
+                // lc.debug?.(`sending`, data);
+                sink.send(data);
+                const { ack } = await acks.dequeue();
+                if (ack !== id) {
+                    throw new Error(`Unexpected ack for ${id}: ${ack}`);
+                }
+            }
+        }
+        closer.close();
+    }
+    catch (e) {
+        closer.close(e);
+    }
+}
+export function streamIn(lc, source, schema) {
+    const streamedSchema = v.object({
+        msg: schema,
+        id: v.number(),
+    });
+    const sink = new Subscription({
+        consumed: ({ id }) => source.send(JSON.stringify({ ack: id })),
+        cleanup: () => closer.close(),
+    }, ({ msg }) => msg);
+    const closer = new WebSocketCloser(lc, source, sink, handleMessage);
+    function handleMessage(event) {
+        const data = event.data.toString();
+        if (closer.closed()) {
+            lc.debug?.('Ignoring message received after closed', data);
+            return;
+        }
+        try {
+            const value = BigIntJSON.parse(data);
+            const msg = v.parse(value, streamedSchema, 'passthrough');
+            // Enable for debugging. Otherwise too verbose.
+            // lc.debug?.(`received`, data);
+            sink.push(msg);
+        }
+        catch (e) {
+            closer.close(e);
+        }
+    }
+    return sink;
+}
+class WebSocketCloser {
+    #lc;
+    #ws;
+    #stream;
+    #closeHandler;
+    #errorHandler;
+    #messageHandler;
+    #closed = false;
+    constructor(lc, ws, stream, messageHandler) {
+        this.#lc = lc;
+        this.#ws = ws;
+        this.#stream = stream;
+        this.#messageHandler = messageHandler ?? null;
+        this.#closeHandler = e => this.#handleClose(e);
+        this.#errorHandler = e => this.#handleError(e);
+        ws.addEventListener('close', this.#closeHandler);
+        ws.addEventListener('error', this.#errorHandler);
+        if (this.#messageHandler) {
+            ws.addEventListener('message', this.#messageHandler);
+        }
+    }
+    #handleClose(e) {
+        const { code, reason, wasClean } = e;
+        this.#lc.info?.('WebSocket close event', { code, reason, wasClean });
+        this.close();
+    }
+    #handleError(e) {
+        this.#lc.error?.('WebSocket error event', e.message, e.error);
+        // Should we close here?
+    }
+    close(err) {
+        if (this.#closed) {
+            return;
+        }
+        if (err) {
+            this.#lc.error?.(`closing stream with error`, err);
+        }
+        this.#closed = true;
+        this.#ws.removeEventListener('close', this.#closeHandler);
+        this.#ws.removeEventListener('error', this.#errorHandler);
+        if (this.#messageHandler) {
+            this.#ws.removeEventListener('message', this.#messageHandler);
+        }
+        this.#stream.cancel();
+        if (this.#ws.readyState !== this.#ws.CLOSED) {
+            this.#ws.close();
+        }
+    }
+    closed() {
+        return this.#closed;
+    }
+}
+//# sourceMappingURL=streams.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streams.js","sourceRoot":"","sources":["../../../../../zero-cache/src/types/streams.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,158 @@
+import type { Sink, Source } from './streams.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 declare class Subscription<T, M = T> implements Source<T>, Sink<M> {
+    #private;
+    /**
+     * 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<T, M extends T = T>(options?: Options<M>, publish?: (m: M) => T): Subscription<T, M>;
+    /**
+     * @param publish function for converting the internally pushed / coalesced message
+     *        of type `M` to the external type `T` exposed via async iteration.
+     */
+    constructor(options: Options<M> | undefined, publish: (m: M) => T);
+    /**
+     * 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: M): PendingResult;
+    /** False if the subscription has been canceled or has failed. */
+    get active(): boolean;
+    /** The number messages waiting to be consumed. This is largely for testing. */
+    get queued(): number;
+    /** Cancels the subscription, cleans up, and terminates any iteration. */
+    cancel(): void;
+    /** Fails the subscription, cleans up, and throws from any iteration. */
+    fail(err: Error): void;
+    get pipeline(): AsyncIterable<{
+        value: T;
+        consumed: () => void;
+    }> | undefined;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+type Options<M> = {
+    /**
+     * Coalesces messages waiting to be consumed. This is useful for "watermark" type
+     * subscriptions in which the consumer is only interested in the cumulative state
+     * change since the last processed message. When a `coalesce` function is specified,
+     * there is guaranteed to be at most one message waiting to be consumed.
+     *
+     * Note that the `curr` argument comes before `prev`. This facilitates a common
+     * scenario in which coalescing just means using the newest value; in such a case,
+     * `coalesce` can simply be the identity function (e.g. `msg => msg`).
+     */
+    coalesce?: (curr: M, prev: M) => M;
+    /**
+     * Called on the previous message in an iteration (1) when the next message is requested,
+     * or (2) when the iteration is terminated. This allows the producer to perform
+     * per-message cleanup.
+     *
+     * Note that when a {@link Options.coalesce coalesce} function is defined,
+     * `consumed` is _not_ called on the `prev` message; it is the responsibility of
+     * producers requiring both coalescing and consumption notification to perform any
+     * necessary cleanup of `prev` messages when coalescing.
+     */
+    consumed?: (prev: M) => void;
+    /**
+     * `cleanup` is called exactly once when the subscription is terminated via a failure or
+     * cancelation (whichever happens first), which includes implicit cancelation when
+     * the consumer exits an iteration via a `break`, `return`, or `throw` statement.
+     *
+     * Note that the `err` argument will only reflect an explicit cancelation via a call
+     * to {@link Subscription.fail()}. On the other hand, if the iteration is canceled via
+     * a `throw` statement, the thrown reason is not reflected in the `err` parameter, as that
+     * information is not made available to the AsyncIterator implementation.
+     */
+    cleanup?: (unconsumed: M[], err?: Error) => void;
+    /**
+     * Enable or disable pipelining when streaming messages over a websocket.
+     *
+     * If unspecified, pipelining is enabled if there is no {@link Options.coalesce coalesce}
+     * method, as pipelining is counter to the semantics of coalescing. However, the
+     * application can explicitly enable pipelining even if there is a coalesce method
+     * by specifying `true` for this option. This assumes that coalescing is either
+     * not important for websocket semantics, or that the receiving end of the websocket
+     * transport performs the desired coalescing.
+     */
+    pipeline?: boolean;
+};
+/** Post-queueing results of messages. */
+export type Result = 'consumed' | 'coalesced' | 'unconsumed';
+/**
+ * {@link Subscription.subscribe()} wraps the `Promise<Result>` in a `PendingResult`
+ * object to avoid forcing all callers to handle the Promise, as most logic does not
+ * need to.
+ */
+export type PendingResult = {
+    result: Promise<Result>;
+};
+export {};
+//# sourceMappingURL=subscription.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"AACA,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;IAmB/B;;;OAGG;gBACS,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAK,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAoC1D;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa;IAoB7B,iEAAiE;IACjE,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,+EAA+E;IAC/E,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,yEAAyE;IACzE,MAAM;IAIN,wEAAwE;IACxE,IAAI,CAAC,GAAG,EAAE,KAAK;IAyBf,IAAI,QAAQ,IAAI,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAI1E;IA0CD,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CA0B3C;AAED,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB;;;;;;;;;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

@@ -0,0 +1,233 @@
+import { resolver } from '@rocicorp/resolver';
+/**
+ * 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);
+    }
+    // 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;
+    }
+    /**
+     * 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) {
+            const prev = this.#messages[0];
+            this.#messages[0] = { value: this.#coalesce(entry, prev), resolve };
+        }
+        else {
+            this.#messages.push(entry);
+        }
+        return { result };
+    }
+    /** False if the subscription has been canceled or has failed. */
+    get active() {
+        return this.#sentinel === undefined;
+    }
+    /** The number messages waiting to be consumed. This is largely for testing. */
+    get queued() {
+        return this.#messages.length;
+    }
+    /** Cancels the subscription, 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, 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);
+            }
+        }
+    }
+    get pipeline() {
+        return this.#pipelineEnabled
+            ? { [Symbol.asyncIterator]: () => this.#pipeline() }
+            : undefined;
+    }
+    #pipeline() {
+        return {
+            next: async () => {
+                const entry = this.#messages.shift();
+                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 });
+            },
+        };
+    }
+}
+//# sourceMappingURL=subscription.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"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"}

package/out/zero-cache/src/types/timeout.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolves to the the string `"timed-out"` if `timeoutMs` elapses before
+ * the specified `promise` resolves.
+ */
+export declare function orTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | 'timed-out'>;
+/**
+ * Resolves to the specified `timeoutValue` if `timeoutMs` elapses before
+ * the specified `promise` resolves.
+ */
+export declare function orTimeoutWith<T, U>(promise: Promise<T>, timeoutMs: number, timeoutValue: U): Promise<T | U>;
+//# sourceMappingURL=timeout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/timeout.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,CAAC,GAAG,WAAW,CAAC,CAE1B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,CAAC,EAAE,CAAC,EACtC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,CAAC,GACd,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAQhB"}