@rocicorp/zero 1.12.0-canary.0 → 1.12.0-canary.10

package/out/zero-cache/src/services/change-streamer/change-streamer.d.ts

@@ -1,586 +0,0 @@
-import type { Enum } from '../../../../shared/src/enum.ts';
-import * as v from '../../../../shared/src/valita.ts';
-import type { PreSerialized, Sized, Source } from '../../types/streams.ts';
-import type { Subscription } from '../../types/subscription.ts';
-import { type ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
-import type { BackfillRequest } from '../change-source/protocol/current/upstream.ts';
-import type { ReplicatorMode } from '../replicator/replicator.ts';
-import type { Service } from '../service.ts';
-import type { PreSerializedBatch } from './broadcast.ts';
-import * as ErrorType from './error-type-enum.ts';
-import type { SnapshotMessage } from './snapshot-message.ts';
-import type { LocalReplica, SubscribeDownstream } from './subscribe.ts';
-type ErrorType = Enum<typeof ErrorType>;
-export type ChangeTag = ChangeStreamData[1]['tag'];
-/**
- * Internally all downstream messages (not just commits) are given a watermark.
- * These are used for internal ordering while replaying stored changes and
- * filtering changes already seen by a subscriber.
- *
- * Only commit watermarks are exposed to subscribers. The JSON string is the
- * canonical serialization shared by storage and live forwarding.
- */
-export type WatermarkedChange = [
-    watermark: string,
-    tag: ChangeTag,
-    json: string
-];
-/**
- * The ChangeStreamer is the component between replicators ("subscribers")
- * and a canonical upstream source of changes (e.g. a Postgres logical
- * replication slot). It facilitates multiple subscribers without incurring
- * the associated upstream expense (e.g. PG replication slots are resource
- * intensive) with a "forward-store-ack" procedure.
- *
- * * Changes from the upstream source are immediately **forwarded** to
- *   connected subscribers to minimize latency.
- *
- * * They are then **stored** in a separate DB to facilitate catchup
- *   of connecting subscribers that are behind.
- *
- * * **Acknowledgements** are sent upstream after they are successfully
- *   stored.
- *
- * Unlike Postgres replication slots, in which the progress of a static
- * subscriber is tracked in the replication slot, the ChangeStreamer
- * supports a dynamic set of subscribers (i.e.. zero-caches) that can
- * can continually change.
- *
- * However, it is not the case that the ChangeStreamer needs to support
- * arbitrarily old subscribers. Because the replica is continually
- * backed up to a global location and used to initialize new subscriber
- * tasks, an initial subscription request from a subscriber constitutes
- * a signal for how "behind" a new subscriber task can be. This is
- * reflected in the {@link SubscriberContext}, which indicates whether
- * the watermark corresponds to an "initial" watermark derived from the
- * replica at task startup.
- *
- * The ChangeStreamer uses a combination of this signal with ACK
- * responses from connected subscribers to determine the watermark up
- * to which it is safe to purge old change log entries.
- */
-export interface ChangeStreamer {
-    /**
-     * Subscribes to changes based on the supplied subscriber `ctx`,
-     * which indicates the watermark at which the subscriber is up to
-     * date. Each result contains parsed, validated data and its approximate
-     * serialized transport size.
-     */
-    subscribe(ctx: SubscriberContext): Promise<Source<Sized<SubscribeDownstream>>>;
-}
-export declare const PROTOCOL_VERSION = 8;
-export type SubscriberContext = {
-    /**
-     * The supported change-streamer protocol version.
-     */
-    protocolVersion: number;
-    /**
-     * Task ID. This is used to link the request with a preceding snapshot
-     * reservation.
-     */
-    taskID: string;
-    /**
-     * Subscriber id. This is only used for debugging.
-     */
-    id: string;
-    /**
-     * The ReplicatorMode of the subscriber. 'backup' indicates that the
-     * subscriber is local to the `change-streamer` in the `replication-manager`,
-     * while 'serving' indicates that user-facing requests depend on the subscriber.
-     */
-    mode: ReplicatorMode;
-    /**
-     * The ChangeStreamer will return an Error if the subscriber is
-     * on a different replica version (i.e. the initial snapshot associated
-     * with the replication slot).
-     */
-    replicaVersion: string;
-    /**
-     * The watermark up to which the subscriber is up to date.
-     * Only changes after the watermark will be streamed.
-     */
-    watermark: string;
-    /**
-     * Whether the subscriber supports batched WebSocket frames.
-     */
-    wsBatched?: boolean | undefined;
-    /**
-     * The subscriber's pending backfills as of its `watermark`. Reported by
-     * subscribers as of protocol v8. `undefined` for older subscribers.
-     */
-    backfills?: BackfillRequest[] | undefined;
-    /**
-     * Whether the subscriber understands the `draining` status, i.e. it will
-     * switch over to another replication-manager when the current one shuts
-     * down. A draining replication-manager waits for drainable subscribers to
-     * leave before exiting.
-     */
-    drainable?: boolean | undefined;
-    /**
-     * Whether the subscriber is switching over from another subscription with
-     * a replica that it is currently serving. If the replica version is
-     * incompatible, such a subscriber is held (see {@link Status.restore})
-     * rather than being immediately rejected. Subscribers that are booting up
-     * never set this.
-     */
-    switchover?: boolean | undefined;
-};
-/**
- * The StatusMessage payload for now is empty, but can be extended to
- * include meta-level information in the future.
- */
-export declare const statusSchema: v.ObjectType<{
-    tag: v.Type<"status">;
-    lagReport: v.Optional<{
-        lastTimings?: {
-            sendTimeMs: number;
-            commitTimeMs: number;
-            receiveTimeMs: number;
-        } | undefined;
-        nextSendTimeMs: number;
-    }>;
-    /**
-     * Sent by a replication-manager that is shutting down to its (drainable)
-     * serving subscribers. The subscriber should switch over to another
-     * replication-manager (see {@link SubscriberContext.switchover}) while
-     * continuing to consume this subscription until the switchover succeeds.
-     */
-    draining: v.Optional<boolean>;
-    /**
-     * Sent on a {@link SubscriberContext.switchover switchover} subscription
-     * to a replication-manager running an incompatible replica version.
-     * Rather than being immediately rejected with
-     * {@link ErrorType.WrongReplicaVersion}, the subscriber is held until it
-     * is granted permission to restore the replication-manager's backup,
-     * which limits the number of subscribers that are restoring (and thus not
-     * serving) at the same time.
-     *
-     * * `queued`: the subscriber is waiting for permission to restore. It
-     *   should continue consuming its existing subscription (if any).
-     * * `granted`: the subscriber should (gracefully) restart to restore a
-     *   new replica.
-     */
-    restore: v.Optional<{
-        state: "queued";
-        position: number;
-    } | {
-        state: "granted";
-    }>;
-}, undefined>;
-export type Status = v.Infer<typeof statusSchema>;
-export declare const statusMessageSchema: v.TupleType<[v.Type<"status">, v.ObjectType<{
-    tag: v.Type<"status">;
-    lagReport: v.Optional<{
-        lastTimings?: {
-            sendTimeMs: number;
-            commitTimeMs: number;
-            receiveTimeMs: number;
-        } | undefined;
-        nextSendTimeMs: number;
-    }>;
-    /**
-     * Sent by a replication-manager that is shutting down to its (drainable)
-     * serving subscribers. The subscriber should switch over to another
-     * replication-manager (see {@link SubscriberContext.switchover}) while
-     * continuing to consume this subscription until the switchover succeeds.
-     */
-    draining: v.Optional<boolean>;
-    /**
-     * Sent on a {@link SubscriberContext.switchover switchover} subscription
-     * to a replication-manager running an incompatible replica version.
-     * Rather than being immediately rejected with
-     * {@link ErrorType.WrongReplicaVersion}, the subscriber is held until it
-     * is granted permission to restore the replication-manager's backup,
-     * which limits the number of subscribers that are restoring (and thus not
-     * serving) at the same time.
-     *
-     * * `queued`: the subscriber is waiting for permission to restore. It
-     *   should continue consuming its existing subscription (if any).
-     * * `granted`: the subscriber should (gracefully) restart to restore a
-     *   new replica.
-     */
-    restore: v.Optional<{
-        state: "queued";
-        position: number;
-    } | {
-        state: "granted";
-    }>;
-}, undefined>]>;
-/**
- * A StatusMessage will be immediately sent on a (v2+) subscription to
- * indicate that the subscription is valid (i.e. starting at the requested
- * watermark). Invalid subscriptions will instead result in a
- * SubscriptionError as the first message.
- */
-export type StatusMessage = v.Infer<typeof statusMessageSchema>;
-declare const subscriptionErrorSchema: v.ObjectType<{
-    type: v.Type<number>;
-    message: v.Optional<string>;
-    /**
-     * The replica version of the replication-manager, sent with
-     * {@link ErrorType.WrongReplicaVersion} so that a subscriber with a newer
-     * replica can avoid restoring an older one.
-     */
-    replicaVersion: v.Optional<string>;
-}, undefined>;
-export type SubscriptionError = v.Infer<typeof subscriptionErrorSchema>;
-declare const errorSchema: v.TupleType<[v.Type<"error">, v.ObjectType<{
-    type: v.Type<number>;
-    message: v.Optional<string>;
-    /**
-     * The replica version of the replication-manager, sent with
-     * {@link ErrorType.WrongReplicaVersion} so that a subscriber with a newer
-     * replica can avoid restoring an older one.
-     */
-    replicaVersion: v.Optional<string>;
-}, undefined>]>;
-export declare const downstreamSchema: v.UnionType<[v.TupleType<[v.Type<"status">, v.ObjectType<{
-    tag: v.Type<"status">;
-    lagReport: v.Optional<{
-        lastTimings?: {
-            sendTimeMs: number;
-            commitTimeMs: number;
-            receiveTimeMs: number;
-        } | undefined;
-        nextSendTimeMs: number;
-    }>;
-    /**
-     * Sent by a replication-manager that is shutting down to its (drainable)
-     * serving subscribers. The subscriber should switch over to another
-     * replication-manager (see {@link SubscriberContext.switchover}) while
-     * continuing to consume this subscription until the switchover succeeds.
-     */
-    draining: v.Optional<boolean>;
-    /**
-     * Sent on a {@link SubscriberContext.switchover switchover} subscription
-     * to a replication-manager running an incompatible replica version.
-     * Rather than being immediately rejected with
-     * {@link ErrorType.WrongReplicaVersion}, the subscriber is held until it
-     * is granted permission to restore the replication-manager's backup,
-     * which limits the number of subscribers that are restoring (and thus not
-     * serving) at the same time.
-     *
-     * * `queued`: the subscriber is waiting for permission to restore. It
-     *   should continue consuming its existing subscription (if any).
-     * * `granted`: the subscriber should (gracefully) restart to restore a
-     *   new replica.
-     */
-    restore: v.Optional<{
-        state: "queued";
-        position: number;
-    } | {
-        state: "granted";
-    }>;
-}, undefined>]>, v.UnionType<[v.TupleType<[v.Type<"begin">, v.ObjectType<{
-    tag: v.Type<"begin">;
-    json: v.Optional<"p" | "s">;
-    skipAck: v.Optional<boolean>;
-}, undefined>, v.ObjectType<{
-    commitWatermark: v.Type<string>;
-}, undefined>]>, v.TupleType<[v.Type<"data">, v.UnionType<[v.UnionType<[v.ObjectType<{
-    tag: v.Type<"insert">;
-    relation: v.Type<{
-        schema: string;
-        name: string;
-        keyColumns?: string[] | undefined;
-        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
-        rowKey: {
-            columns: string[];
-            type?: "default" | "full" | "index" | "nothing" | undefined;
-        };
-    }>;
-    new: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"update">;
-    relation: v.Type<{
-        schema: string;
-        name: string;
-        keyColumns?: string[] | undefined;
-        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
-        rowKey: {
-            columns: string[];
-            type?: "default" | "full" | "index" | "nothing" | undefined;
-        };
-    }>;
-    key: v.UnionType<[v.Type<null>, v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>]>;
-    new: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"delete">;
-    relation: v.Type<{
-        schema: string;
-        name: string;
-        keyColumns?: string[] | undefined;
-        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
-        rowKey: {
-            columns: string[];
-            type?: "default" | "full" | "index" | "nothing" | undefined;
-        };
-    }>;
-    key: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"truncate">;
-    relations: v.ArrayType<v.Type<{
-        schema: string;
-        name: string;
-        keyColumns?: string[] | undefined;
-        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
-        rowKey: {
-            columns: string[];
-            type?: "default" | "full" | "index" | "nothing" | undefined;
-        };
-    }>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"backfill">;
-    relation: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-        rowKey: v.ObjectType<{
-            columns: v.ArrayType<v.Type<string>>;
-            type: v.Optional<"default" | "full" | "index" | "nothing">;
-        }, undefined>;
-    }, undefined>;
-    columns: v.ArrayType<v.Type<string>>;
-    watermark: v.Type<string>;
-    rowValues: v.ArrayType<v.ArrayType<v.Type<import("../../../../shared/src/bigint-json.ts").JSONValue>>>;
-    progressMarks: v.Optional<{
-        previous?: {
-            [x: string]: string | number;
-            progressMark: string;
-            timeline?: string | undefined;
-        } | undefined;
-        current: {
-            [x: string]: string | number;
-            progressMark: string;
-            timeline?: string | undefined;
-        };
-    }>;
-    status: v.Optional<{
-        rows: number;
-        totalRows: number;
-        totalBytes?: number | undefined;
-    }>;
-}, undefined>]>, v.UnionType<[v.ObjectType<{
-    tag: v.Type<"create-table">;
-    spec: v.ObjectType<Omit<{
-        name: v.Type<string>;
-        columns: v.Type<Record<string, {
-            pos: number;
-            dataType: string;
-            pgTypeClass?: "b" | "c" | "d" | "e" | "m" | "p" | "r" | undefined;
-            elemPgTypeClass?: "b" | "c" | "d" | "e" | "m" | "p" | "r" | null | undefined;
-            characterMaximumLength?: number | null | undefined;
-            notNull?: boolean | null | undefined;
-            dflt?: string | null | undefined;
-        }>>;
-        primaryKey: v.Optional<string[]>;
-    }, "schema"> & {
-        schema: v.Type<string>;
-    }, undefined>;
-    metadata: v.Optional<{
-        [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
-        rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
-    }>;
-    backfill: v.Optional<Record<string, Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"rename-table">;
-    old: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-    new: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"update-table-metadata">;
-    table: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-    old: v.ObjectType<{
-        rowKey: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, v.Type<import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-    new: v.ObjectType<{
-        rowKey: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-    }, v.Type<import("../../../../shared/src/bigint-json.ts").JSONValue>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"add-column">;
-    table: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-    column: v.ObjectType<{
-        name: v.Type<string>;
-        spec: v.ObjectType<{
-            pos: v.Type<number>;
-            dataType: v.Type<string>;
-            pgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r">;
-            elemPgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r" | null>;
-            characterMaximumLength: v.Optional<number | null>;
-            notNull: v.Optional<boolean | null>;
-            dflt: v.Optional<string | null>;
-        }, undefined>;
-    }, undefined>;
-    tableMetadata: v.Optional<{
-        [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
-        rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
-    }>;
-    backfill: v.Optional<Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"update-column">;
-    table: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-    old: v.ObjectType<{
-        name: v.Type<string>;
-        spec: v.ObjectType<{
-            pos: v.Type<number>;
-            dataType: v.Type<string>;
-            pgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r">;
-            elemPgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r" | null>;
-            characterMaximumLength: v.Optional<number | null>;
-            notNull: v.Optional<boolean | null>;
-            dflt: v.Optional<string | null>;
-        }, undefined>;
-    }, undefined>;
-    new: v.ObjectType<{
-        name: v.Type<string>;
-        spec: v.ObjectType<{
-            pos: v.Type<number>;
-            dataType: v.Type<string>;
-            pgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r">;
-            elemPgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r" | null>;
-            characterMaximumLength: v.Optional<number | null>;
-            notNull: v.Optional<boolean | null>;
-            dflt: v.Optional<string | null>;
-        }, undefined>;
-    }, undefined>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"drop-column">;
-    table: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-    column: v.Type<string>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"drop-table">;
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"create-index">;
-    spec: v.ObjectType<Omit<{
-        name: v.Type<string>;
-        tableName: v.Type<string>;
-        unique: v.Type<boolean>;
-        columns: v.Type<Record<string, "ASC" | "DESC">>;
-        predicate: v.Optional<import("../../db/specs.ts").IndexPredicate>;
-    }, "schema"> & {
-        schema: v.Type<string>;
-    }, undefined>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"drop-index">;
-    id: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-    }, undefined>;
-}, undefined>, v.ObjectType<{
-    tag: v.Type<"backfill-completed">;
-    relation: v.ObjectType<{
-        schema: v.Type<string>;
-        name: v.Type<string>;
-        rowKey: v.ObjectType<{
-            columns: v.ArrayType<v.Type<string>>;
-            type: v.Optional<"default" | "full" | "index" | "nothing">;
-        }, undefined>;
-    }, undefined>;
-    columns: v.ArrayType<v.Type<string>>;
-    watermark: v.Type<string>;
-    progressMarks: v.Optional<{
-        previous?: {
-            [x: string]: string | number;
-            progressMark: string;
-            timeline?: string | undefined;
-        } | undefined;
-    }>;
-    status: v.Optional<{
-        rows: number;
-        totalRows: number;
-        totalBytes?: number | undefined;
-    }>;
-}, undefined>]>]>]>, v.TupleType<[v.Type<"commit">, v.ObjectType<{
-    tag: v.Type<"commit">;
-    commitTimeMs: v.Optional<number>;
-}, undefined>, v.ObjectType<{
-    watermark: v.Type<string>;
-}, undefined>]>, v.TupleType<[v.Type<"rollback">, v.ObjectType<{
-    tag: v.Type<"rollback">;
-}, undefined>]>]>, v.TupleType<[v.Type<"error">, v.ObjectType<{
-    type: v.Type<number>;
-    message: v.Optional<string>;
-    /**
-     * The replica version of the replication-manager, sent with
-     * {@link ErrorType.WrongReplicaVersion} so that a subscriber with a newer
-     * replica can avoid restoring an older one.
-     */
-    replicaVersion: v.Optional<string>;
-}, undefined>]>]>;
-export type Error = v.Infer<typeof errorSchema>;
-export declare function errorTypeToReadableName(val: ErrorType): "Unknown" | "WatermarkTooOld" | "WrongReplicaVersion";
-/**
- * A stream of transactions, each starting with a {@link Begin} message,
- * containing one or more {@link Data} messages, and ending with a
- * {@link Commit} or {@link Rollback} message. The 'commit' tuple
- * includes a `watermark` that should be stored with the committed
- * data and used for resuming a subscription (e.g. in the
- * {@link SubscriberContext}).
- *
- * A {@link SubscriptionError} indicates an unrecoverable error that requires
- * manual intervention (e.g. configuration / operational error).
- */
-export type Downstream = v.Infer<typeof downstreamSchema>;
-/** A downstream message and its approximate serialized transport size. */
-export type SizedDownstream = Sized<Downstream>;
-export interface ChangeStreamerService extends Omit<ChangeStreamer, 'subscribe'>, Service {
-    /**
-     * The server-side interface overrides `subscribe()` to return a stream
-     * of already-stringified {@link Downstream} payloads or pre-serialized Buffers.
-     *
-     * If a `downstream` subscription is supplied it is used directly as the
-     * returned Source. Otherwise, a new one is created.
-     */
-    subscribe(ctx: SubscriberContext, downstream?: Subscription<string | PreSerializedBatch>): Promise<Source<string | PreSerialized>>;
-    /**
-     * Starts a snapshot reservation to preserve change-log entries while
-     * a soon-to-be-subscriber downloads the current replica backup. Once
-     * the change-streamer knows that a backup is available
-     * (via {@link trackBackupWatermark}), it sends a confirmation
-     * SnapshotMessage and reserves the corresponding entries in the change-log
-     * until the client with that `taskID` subscribes, or if the snapshot
-     * connection terminates.
-     */
-    startSnapshotReservation(taskID: string, opts?: {
-        localReplica?: LocalReplica | undefined;
-    }): Promise<Source<SnapshotMessage>>;
-    /**
-     * Signals (drainable) serving subscribers to switch over to another
-     * replication-manager, and resolves when they have all disconnected.
-     * Subscribers continue to be served in the meantime.
-     */
-    drain?(): Promise<void>;
-    /**
-     * Informs the change-streamer of the watermark up to which the replica has
-     * been backed up. This serves two purposes:
-     * - It serves as the maximum watermark up to which the change-log can be
-     *   purged. Note that the change-streamer also takes into account the
-     *   positions of its subscribers and snapshot reservations when purging
-     *   changes in the change-log.
-     * - In RMv2, this ACK's the upstream change-source to allow its buffer of
-     *   changes (e.g. the replication_slot) to advance.
-     */
-    trackBackupWatermark(watermark: string): void;
-}
-export {};
-//# sourceMappingURL=change-streamer.d.ts.map

package/out/zero-cache/src/services/change-streamer/change-streamer.d.ts.map

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

package/out/zero-cache/src/services/change-streamer/drain-tracker.d.ts

@@ -1,24 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Subscription } from '../../types/subscription.ts';
-import type { PreSerializedBatch } from './broadcast.ts';
-import type { Subscriber } from './subscriber.ts';
-/**
- * Tracks the {@link Subscriber.drainable drainable} subscribers of the
- * change-streamer, i.e. those that switch over to another
- * replication-manager when this one drains.
- *
- * Upon {@link drain}, drainable subscribers are sent a `draining` status,
- * and the returned promise resolves once they have all disconnected.
- * Subscribers continue to be served in the meantime. (New subscribers are
- * not accepted while draining.)
- */
-export declare class DrainTracker {
-    #private;
-    constructor(lc: LogContext, setIntervalFn?: typeof setInterval, clearIntervalFn?: typeof clearInterval);
-    get draining(): boolean;
-    register(subscriber: Subscriber, downstream: Subscription<string | PreSerializedBatch>): void;
-    drain(): Promise<void>;
-    /** Resolves any pending drain, e.g. when the change-streamer stops. */
-    stop(): void;
-}
-//# sourceMappingURL=drain-tracker.d.ts.map

package/out/zero-cache/src/services/change-streamer/drain-tracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drain-tracker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/drain-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAIhD;;;;;;;;;GASG;AACH,qBAAa,YAAY;;IAOvB,YACE,EAAE,EAAE,UAAU,EAEd,aAAa,GAAE,OAAO,WAAyB,EAC/C,eAAe,GAAE,OAAO,aAA6B,EAKtD;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,QAAQ,CACN,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,YAAY,CAAC,MAAM,GAAG,kBAAkB,CAAC,QAWtD;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAuBrB;IAED,uEAAuE;IACvE,IAAI,SAEH;CAQF"}

package/out/zero-cache/src/services/change-streamer/error-type-enum.d.ts

@@ -1,15 +0,0 @@
-export declare const Unknown = 0;
-export declare const WrongReplicaVersion = 1;
-export declare const WatermarkTooOld = 2;
-/**
- * Sent on an initially live stream before disconnecting it because
- * it is too far behind. How the subscriber handles this is unspecified
- * by the server; the current implementation shuts down the process
- * with the assumption that it is in a pathological zombie state.
- */
-export declare const StreamTooFarBehind = 3;
-export type Unknown = typeof Unknown;
-export type WrongReplicaVersion = typeof WrongReplicaVersion;
-export type WatermarkTooOld = typeof WatermarkTooOld;
-export type StreamTooFarBehind = typeof StreamTooFarBehind;
-//# sourceMappingURL=error-type-enum.d.ts.map

package/out/zero-cache/src/services/change-streamer/error-type-enum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-type-enum.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/error-type-enum.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,IAAI,CAAC;AACzB,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC;AACrC,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC;AAC7D,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC"}