@rocicorp/zero 1.12.0-canary.6 → 1.12.0-canary.8

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

@@ -1 +0,0 @@
-{"version":3,"file":"pg-patch.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/pg-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAU5D"}

package/out/zero-cache/src/types/pg-versions.d.ts

@@ -1,3 +0,0 @@
-export declare const PG_15 = 150000;
-export declare const PG_17 = 170000;
-//# sourceMappingURL=pg-versions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pg-versions.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/pg-versions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,SAAS,CAAC;AAC5B,eAAO,MAAM,KAAK,SAAS,CAAC"}

package/out/zero-cache/src/types/poke-chunk.d.ts

@@ -1,18 +0,0 @@
-import { type PokeChunk } from '../../../zero-protocol/src/poke.ts';
-export declare const POKE_CHUNK_BYTES: number;
-export type EmitPokeChunk = (chunk: PokeChunk) => Promise<void>;
-/**
- * Streams a JSON array into fixed-size UTF-8 chunks.
- *
- * The emitter must finish consuming a chunk before its promise resolves. This
- * lets the encoder reuse one fixed-size buffer for the entire poke. Memory is
- * therefore O(chunk size), independent of poke size.
- */
-export declare class PokeChunkEncoder {
-    #private;
-    constructor(chunkBytes?: number);
-    addPatch(serializedPatch: string, emit: EmitPokeChunk): Promise<void>;
-    finish(emit: EmitPokeChunk): Promise<void>;
-    cancel(): void;
-}
-//# sourceMappingURL=poke-chunk.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"poke-chunk.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/poke-chunk.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,SAAS,EACf,MAAM,oCAAoC,CAAC;AAE5C,eAAO,MAAM,gBAAgB,QAAc,CAAC;AAE5C,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,qBAAa,gBAAgB;;IAO3B,YAAY,UAAU,SAAmB,EAMxC;IAEK,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1E;IAEK,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAK/C;IAED,MAAM,IAAI,IAAI,CAGb;CAwBF"}

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

@@ -1,115 +0,0 @@
-import { Readable, type DuplexOptions } from 'node:stream';
-import type { LogContext } from '@rocicorp/logger';
-import { type WebSocket } from 'ws';
-import { type JSONValue } from '../../../shared/src/bigint-json.ts';
-import * as v from '../../../shared/src/valita.ts';
-import { Subscription, type Options } from './subscription.ts';
-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.
-     *
-     * @param err Terminate the iteration by throwing the `err` instead.
-     */
-    cancel: (err?: Error) => void;
-    /**
-     * An AbortSignal that can be used to listen for termination or
-     * race a short-lived promise against the termination of the iterable
-     * (via `promiseOrAbort()`)
-     */
-    readonly signal: AbortSignal;
-    /**
-     * 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;
-    /**
-     * Pipelined batching support: eagerly drains available queued messages up to `maxBatch`.
-     */
-    pipelineBatched?: ((maxBatch?: number) => AsyncIterable<{
-        values: T[];
-        consumed: () => void;
-    }> | undefined) | undefined;
-};
-export type Sink<T> = {
-    push(message: T): void;
-};
-/**
- * Utility method for reading the first items from a {@link Source} and passing
- * the `rest` to a separate consumer. The caller should call `head.next()` to
- * pull items out of the Source, but should not call the
- * {@link AsyncIterator.return()} method, as that will cancel the Source.
- */
-export declare function readHead<T>(source: Source<T>): {
-    head: AsyncIterator<T, T, T>;
-    rest: Source<T>;
-};
-/**
- * Back-pressure-aware transformation of a WebSocket into
- * upstream and downstream {@link Subscription} objects.
- *
- * This is used for connections with external servers
- * (i.e. custom change sources). For inter-zero-cache communication,
- * see {@link streamInternal}.
- */
-export declare function stream<In extends JSONValue, Out extends JSONValue>(lc: LogContext, ws: WebSocket, inSchema: v.Type<In>, outOptions?: Options<Out>, inOptions?: Options<In>, streamOptions?: DuplexOptions): {
-    outstream: Sink<Out>;
-    instream: Source<In>;
-};
-type PipeOptions<T> = {
-    source: Readable;
-    sink: Subscription<T>;
-    parse: (buffer: Buffer) => T | null;
-    bufferMessages?: number;
-};
-export declare function pipe<T>({ source, sink, parse, bufferMessages }: PipeOptions<T>): void;
-/** A parsed value paired with its approximate serialized transport size. */
-export type Sized<T> = {
-    data: T;
-    size: number;
-};
-export type StreamOutOptions = {
-    batched?: boolean | undefined;
-    maxBatchSize?: number | undefined;
-};
-export type PreSerialized = {
-    readonly payload: Buffer;
-    readonly byteLength: number;
-};
-export declare function isPreSerialized(val: unknown): val is PreSerialized;
-/**
- * Establishes a bidirectional stream over an internal zero-cache to zero-cache
- * WebSocket. Both peers call this: each may send an outbound {@link Source}
- * (`outSource`) and receives an inbound {@link Source} (the return value).
- * Transport-level `{id, msg}` / `{ack}` framing is multiplexed in both
- * directions over the single socket.
- *
- * `inSchema` validates inbound application frames; it may be omitted by a peer
- * that expects no inbound application messages (any that arrive are a protocol
- * error).
- */
-export declare function streamInternal<In extends JSONValue, Out extends JSONValue = JSONValue>(lc: LogContext, ws: WebSocket, inSchema: v.Type<In> | undefined, outSource?: Source<Out>, options?: StreamOutOptions): Promise<Source<In>>;
-/**
- * {@link streamInternal} whose outbound `Source` carries messages that are
- * already stringified JSON or pre-serialized Buffers.
- */
-export declare function streamInternalStringified<In extends JSONValue>(lc: LogContext, ws: WebSocket, inSchema: v.Type<In> | undefined, outSource?: Source<string | PreSerialized>, options?: StreamOutOptions): Promise<Source<In>>;
-/**
- * {@link streamInternal} that retains only the transport-frame size of each
- * inbound message. The size bounds downstream batching without keeping or
- * copying the JSON.
- */
-export declare function streamInternalWithSize<In extends JSONValue, Out extends JSONValue = JSONValue>(lc: LogContext, ws: WebSocket, inSchema: v.Type<In>, outSource?: Source<Out>, options?: StreamOutOptions): Promise<Source<Sized<In>>>;
-export {};
-//# sourceMappingURL=streams.d.ts.map

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

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

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

@@ -1,197 +0,0 @@
-import type { Sink, Source } from './streams.ts';
-/**
- * A Subscription abstracts a continuous, logically infinite stream of messages intended
- * for serial processing. Unlike the more general Node `Stream` API, a Subscription has
- * a limited API with specific semantics:
- *
- * * **Serial processing**: Messages must be consumed via the {@link AsyncIterable}
- *   interface, e.g.
- *   ```ts
- *   const subscription = server.subscribe(parameters);
- *
- *   for await (const message of subscription) {
- *     await process(message);  // fully process the message before consuming the next
- *   }
- *   ```
- *
- *   Moreover, the consumer is expected to completely process each message before
- *   requesting the next. This is important for cleanup semantics (explained later).
- *
- * * **cancel()**, not close(): The underlying data in a subscription is logically infinite
- *   and only terminated when the consumer is no longer interested in receiving the messages
- *   (or requires a Subscription with a different configuration). As such, there is no API
- *   for gracefully closing the subscription after pending messages are consumed; rather,
- *   cancellation is immediate, and upon cancellation, pending messages are dropped. A
- *   Subscription can also be terminated with exceptional (i.e. `Error`) circumstances,
- *   for which the behavior is equivalent.
- *
- * * **Coalescing** (optional): A producer can configure pending messages in the Subscription
- *   to be merged together with a {@link Options.coalesce coalesce} function. This is useful
- *   for semantics in which the consumer is not necessarily interested in every incremental
- *   change, but rather the cumulative change since the last processed message. A
- *   Subscription with coalescing is guaranteed to have at most one outstanding message,
- *   regardless of how quickly messages are produced and consumed. This effectively constrains
- *   the amount of outstanding work in the system.
- *
- * ### Resource Tracking and Cleanup
- *
- * Because message consumption is constrained to the async iteration API, standard
- * control flow mechanisms allow the producer to perform bookkeeping without any
- * explicit cleanup actions on the part of the consumer. This includes:
- *
- * * **Per-message cleanup**: Each request for the {@link AsyncIterator.next next}
- *   message, or the termination of the iteration, signals that the consumer has
- *   finished processing the previous message. The producer of a Subscription can
- *   supply a {@link Options.consumed consumed} callback to receive these processed
- *   messages, allowing it to clean up attached resources (e.g. TransactionPools, etc.).
- *
- * * **Per-subscription cleanup**: The producer of a Subscription can supply a
- *   {@link Options.cleanup cleanup} callback that is invoked when the Subscription
- *   is terminated, either explicitly via {@link Subscription.cancel cancel()} /
- *   {@link Subscription.fail fail()}, or implicitly when an iteration is exited via a
- *  `break`, `return`, or `throw` statement. All unconsumed messages are passed to the
- *   call back to facilitate bookkeeping.
- *
- * @param T The external message type, published to the AsyncIterable
- * @param M The internal message type used in the producer-side interfaces
- *          (e.g. {@link push}, {@link Options.consumed}, {@link Options.coalesce},
- *          and {@link Options.cleanup}). This is often the same as the external type
- *          T, but may be diverged to facilitate internal bookkeeping.
- */
-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);
-    /**
-     * Dynamically adds a function that is called when the Subscription
-     * terminates. This will be called immediately if the Subscription is
-     * already closed.
-     *
-     * Unlike the `cleanup` handler specified in the Subscription options,
-     * this a close handler can be added to an existing Subscription object
-     * thereby avoiding a cyclic dependency, and allowing Subscription
-     * receivers to add their own cleanup logic.
-     */
-    addCloseHandler(onClose: (reason?: unknown) => void): this;
-    /**
-     * 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 of messages waiting to be dequeued. */
-    get queued(): number;
-    /** The number of messages dequeued but not yet "consumed" */
-    get consuming(): number;
-    /** Satisfies the Source interface. */
-    get signal(): AbortSignal;
-    /**
-     * 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(): void;
-    /**
-     * Cancels the subscription immediately, cleans up, and terminates any iteration.
-     * This is intended for the consumer to call when it is no longer interested
-     * in the subscription.
-     *
-     * @param err If an `err` is specified, an iteration over the Subscription /
-     *        Sink will throw the `err` (equivalent to the producer calling
-     *        {@link fail()}). If undefined, the iteration will exit gracefully.
-     */
-    cancel(err?: Error): void;
-    /** Fails the subscription, cleans up, and throws from any iteration. */
-    fail(err: Error): void;
-    get pipeline(): AsyncIterable<{
-        value: T;
-        consumed: () => void;
-    }> | undefined;
-    pipelineBatched: (maxBatch?: number) => AsyncIterable<{
-        values: T[];
-        consumed: () => void;
-    }> | undefined;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
-export 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>;
-};
-//# sourceMappingURL=subscription.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"AAGA,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,sBAG9B;IAoBD;;;OAGG;IACH,YAAY,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAK,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAazD;IAyBD;;;;;;;;;OASG;IACH,eAAe,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAOzD;IAED;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa,CA0B5B;IAED,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,SAQF;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,QAEjB;IAED,wEAAwE;IACxE,IAAI,CAAC,GAAG,EAAE,KAAK,QAEd;IA6BD,IAAI,QAAQ,IAAI,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAI1E;IAED,eAAe,yBAEZ,aAAa,CAAC;QAAC,MAAM,EAAE,CAAC,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAQ/D;IAwIF,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAyBzC;CACF;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/workers/connect-params.d.ts

@@ -1,28 +0,0 @@
-import type { IncomingHttpHeaders } from 'node:http';
-import { type InitConnectionMessage } from '../../../zero-protocol/src/connect.ts';
-export type ConnectParams = {
-    readonly protocolVersion: number;
-    readonly clientID: string;
-    readonly clientGroupID: string;
-    readonly profileID: string | null;
-    readonly baseCookie: string | null;
-    readonly timestamp: number;
-    readonly lmID: number;
-    readonly wsID: string;
-    readonly debugPerf: boolean;
-    readonly auth: string | undefined;
-    readonly userID: string | undefined;
-    readonly initConnectionMsg: InitConnectionMessage | undefined;
-    readonly httpCookie: string | undefined;
-    readonly origin: string | undefined;
-    readonly requestHeaders?: Readonly<Record<string, string>> | undefined;
-    readonly generation?: number | undefined;
-};
-export declare function getConnectParams(protocolVersion: number, url: URL, headers: IncomingHttpHeaders): {
-    params: ConnectParams;
-    error: null;
-} | {
-    params: null;
-    error: string;
-};
-//# sourceMappingURL=connect-params.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"connect-params.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/connect-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,WAAW,CAAC;AAEnD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,uCAAuC,CAAC;AAG/C,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C,CAAC;AAoBF,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,mBAAmB,GAE1B;IACE,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CA2CJ"}

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

@@ -1,77 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import WebSocket from 'ws';
-import * as valita from '../../../shared/src/valita.ts';
-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 UpstreamWithUnparsedAnalyzeQuery } 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 = {
-    type: 'ok';
-} | {
-    type: 'fatal';
-    error: ErrorBody;
-} | {
-    type: 'transient';
-    errors: ErrorBody[];
-} | StreamResult;
-export type StreamResult = {
-    type: 'stream';
-    source: 'viewSyncer';
-    stream: Source<ViewSyncerDownstream>;
-} | {
-    type: 'stream';
-    source: 'pusher';
-    stream: Source<Downstream>;
-};
-export interface MessageHandler {
-    handleMessage(msg: UpstreamWithUnparsedAnalyzeQuery): Promise<HandlerResult[]>;
-}
-export declare function parseUpstreamMessage(value: unknown, allowLegacyQueries: boolean): UpstreamWithUnparsedAnalyzeQuery | valita.UnrecognizedTuple;
-export declare const WEBSOCKET_SEND_TIMEOUT_MS = 10000;
-/**
- * Represents a connection between the client and server.
- *
- * Handles incoming messages on the connection and dispatches
- * them to the correct service.
- *
- * Listens to the ViewSyncer and sends messages to the client.
- */
-export declare class Connection {
-    #private;
-    constructor(lc: LogContext, connectParams: ConnectParams, ws: WebSocket, allowLegacyQueries: boolean, messageHandler: MessageHandler, onClose: () => void);
-    /**
-     * Checks the protocol version and errors for unsupported protocols,
-     * sending the initial `connected` response on success.
-     *
-     * This is early in the connection lifecycle because {@link #handleMessage}
-     * will only parse messages with schema(s) of supported protocol versions.
-     */
-    init(): boolean;
-    close(reason: string, ...args: unknown[]): void;
-    handleInitConnection(initConnectionMsg: string): Promise<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 | PokeChunk, cb?: (err?: Error) => void): 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 +0,0 @@
-{"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/replicator.d.ts

@@ -1,57 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import * as v from '../../../shared/src/valita.ts';
-import type { ReplicaOptions } from '../config/zero-config.ts';
-import { Notifier } from '../services/replicator/notifier.ts';
-import type { ReplicaState, ReplicaStateNotifier, Replicator } from '../services/replicator/replicator.ts';
-import { type PragmaConfig } from '../services/replicator/write-worker-client.ts';
-import type { Worker } from '../types/processes.ts';
-export declare const replicaFileModeSchema: v.Type<"backup" | "serving" | "serving-copy">;
-export type ReplicaFileMode = v.Infer<typeof replicaFileModeSchema>;
-export type WalMode = 'wal' | 'wal2';
-export declare function replicaFileName(replicaFile: string, mode: ReplicaFileMode): string;
-/**
- * Whether a replicator worker deletes the change-log file beside its replica at
- * startup.
- *
- * The change log belongs to the change-streamer, so this only ever cleans up a
- * file that nothing is writing. The predicate is deliberately the config flag
- * and nothing else: keying it on anything derived per replica -- a file mode, or
- * the retired `logsChangeStream` -- would make every replicator start unlink the
- * change-streamer's live log, because no replicator writes it any more. Paths
- * coincide whenever `fileMode !== 'serving-copy'`, so that hazard is real in the
- * shipped no-`backupURL` configuration.
- *
- * Deleting is safe when nothing writes the log: it is excluded from the
- * litestream backup, only the writer purges it, and re-enabling the writer
- * reseeds at the resume watermark.
- */
-export declare function replicatorDeletesStaleChangeLog(sqliteChangeLogMode: string): boolean;
-/**
- * The `mode=off` cleanup itself: deletes the change-log file beside `dbPath`
- * when {@link replicatorDeletesStaleChangeLog} says nothing writes it, and
- * reports whether it did. The decision and the delete live in one function so
- * that the guard test covers the call the replicator actually makes, not just
- * the predicate.
- */
-export declare function deleteStaleChangeLog(sqliteChangeLogMode: string, dbPath: string): boolean;
-/**
- * Returns the PragmaConfig for a given replica file mode.
- * This is used by both the main thread (setupReplica) and
- * the write worker thread to apply the same pragma settings.
- */
-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;
-/**
- * Creates a Notifier to relay notifications the notifier of another Worker.
- * This does not send the initial subscription message. Use {@link subscribeTo}
- * to initiate the subscription.
- */
-export declare function createNotifierFrom(_lc: LogContext, source: Worker, onNotify?: (state: ReplicaState) => void): Notifier;
-export declare function subscribeTo(_lc: LogContext, source: Worker): void;
-//# sourceMappingURL=replicator.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAGjD,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;AAwHD;;;;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;UA9Hd,MAAM;aAAW,OAAO;cAAY,MAAM;GA6J3D;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/syncer-ws-message-handler.d.ts

@@ -1,14 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { UpstreamWithUnparsedAnalyzeQuery } from '../../../zero-protocol/src/up.ts';
-import type { Mutagen } from '../services/mutagen/mutagen.ts';
-import type { Pusher } from '../services/mutagen/pusher.ts';
-import { type ConnectionContextManager } from '../services/view-syncer/connection-context-manager.ts';
-import { type ViewSyncer } from '../services/view-syncer/view-syncer.ts';
-import type { ConnectParams } from './connect-params.ts';
-import type { HandlerResult, MessageHandler } from './connection.ts';
-export declare class SyncerWsMessageHandler implements MessageHandler {
-    #private;
-    constructor(lc: LogContext, connectParams: ConnectParams, connContextManager: ConnectionContextManager, viewSyncer: ViewSyncer, mutagen: Mutagen | undefined, pusher: Pusher | undefined);
-    handleMessage(msg: UpstreamWithUnparsedAnalyzeQuery): Promise<HandlerResult[]>;
-}
-//# sourceMappingURL=syncer-ws-message-handler.d.ts.map

package/out/zero-cache/src/workers/syncer-ws-message-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"syncer-ws-message-handler.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/workers/syncer-ws-message-handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAOjD,OAAO,KAAK,EAAC,gCAAgC,EAAC,MAAM,kCAAkC,CAAC;AACvF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,gCAAgC,CAAC;AAC5D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EACL,KAAK,wBAAwB,EAE9B,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,wCAAwC,CAAC;AAEvE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAiBnE,qBAAa,sBAAuB,YAAW,cAAc;;IAW3D,YACE,EAAE,EAAE,UAAU,EACd,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,wBAAwB,EAC5C,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAkB3B;IAEK,aAAa,CACjB,GAAG,EAAE,gCAAgC,GACpC,OAAO,CAAC,aAAa,EAAE,CAAC,CA4O1B;CACF"}

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

@@ -1,67 +0,0 @@
-import type { MessagePort } from 'node:worker_threads';
-import type { LogContext } from '@rocicorp/logger';
-import { type ValidateLegacyJWT } from '../auth/auth.ts';
-import { type ZeroConfig } from '../config/zero-config.ts';
-import type { Mutagen } from '../services/mutagen/mutagen.ts';
-import type { Pusher } from '../services/mutagen/pusher.ts';
-import type { ReplicaState } from '../services/replicator/replicator.ts';
-import type { ActivityBasedService, Service, SingletonService } from '../services/service.ts';
-import type { ConnectionContextManager } from '../services/view-syncer/connection-context-manager.ts';
-import { DrainCoordinator } from '../services/view-syncer/drain-coordinator.ts';
-import type { ViewSyncer } from '../services/view-syncer/view-syncer.ts';
-import type { Worker } from '../types/processes.ts';
-import type { Subscription } from '../types/subscription.ts';
-export type SyncerWorkerData = {
-    replicatorPort: MessagePort;
-};
-export type ReplicaReadyState = {
-    readonly watermark: string;
-    readonly replicaReadyTimeMs: number;
-};
-export type ServingLagViewSyncer = Pick<ViewSyncer, 'createdAtMs' | 'servedVersion' | 'servingLagEligible'>;
-export type ServingLagStats = {
-    readonly activeClientGroups: number;
-    readonly laggingClientGroups: number;
-    readonly minMs: number;
-    readonly p50Ms: number;
-    readonly p75Ms: number;
-    readonly p99Ms: number;
-    readonly maxMs: number;
-};
-export type PipelineDedupViewSyncer = Pick<ViewSyncer, 'pipelineHashes' | 'clientSchemaKey'>;
-export type PipelineDedupStats = {
-    readonly clientTotal: number;
-    readonly internalTotal: number;
-    readonly clientHashes: ReadonlyMap<string, {
-        count: number;
-        queryName: string | undefined;
-    }>;
-    readonly internalUnique: number;
-    readonly clientSchemas: number;
-};
-export declare function computePipelineDedupStats(viewSyncers: Iterable<PipelineDedupViewSyncer>): PipelineDedupStats;
-export declare const MAX_REPLICA_READY_STATES = 10000;
-export declare function computeServingLagStatsMs(now: number, replicaReadyStates: ReplicaReadyState[], viewSyncers: Iterable<ServingLagViewSyncer>): ServingLagStats;
-export declare function computeMaxServingLagMs(now: number, replicaReadyStates: ReplicaReadyState[], viewSyncers: Iterable<ServingLagViewSyncer>): number;
-/**
- * The Syncer worker receives websocket handoffs for "/sync" connections
- * from the Dispatcher in the main thread, and creates websocket
- * {@link Connection}s with a corresponding {@link ViewSyncer}, {@link Mutagen},
- * and {@link Subscription} to version notifications from the Replicator
- * worker.
- */
-export declare class Syncer implements SingletonService {
-    #private;
-    readonly id: string;
-    constructor(lc: LogContext, config: ZeroConfig, viewSyncerFactory: (id: string, sub: Subscription<ReplicaState>, drainCoordinator: DrainCoordinator) => ViewSyncer & ActivityBasedService, mutagenFactory: ((id: string) => Mutagen & Service) | undefined, pusherFactory: ((id: string, connContextManager: ConnectionContextManager) => Pusher & Service) | undefined, parent: Worker, validateLegacyJWT: ValidateLegacyJWT | undefined);
-    run(): Promise<void>;
-    /**
-     * Graceful shutdown involves shutting down view syncers one at a time, pausing
-     * for the duration of view syncer's hydration between each one. This paces the
-     * disconnects to avoid creating a backlog of hydrations in the receiving server
-     * when the clients reconnect.
-     */
-    drain(): Promise<void>;
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=syncer.d.ts.map

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

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