@rocicorp/zero 1.12.0-canary.5 → 1.12.0-canary.7

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

@@ -1,485 +0,0 @@
-/**
- * The `subscribe` API (protocol v7+) merges the previous `/snapshot` and
- * `/changes` connections into a single bidirectional WebSocket, so that the
- * replication-manager that reserves change-log entries for a soon-to-be
- * subscriber is the same replication-manager that serves the subscription.
- *
- * The connection is driven by an upstream (view-syncer → replication-manager)
- * application message that selects the flow:
- *
- * - **Fresh startup:** the view-syncer sends `['reserve-snapshot', {taskID}]`.
- *   The change-streamer opens a snapshot reservation (pinning the change log)
- *   and replies downstream with a single `['reserved', …]` message telling the
- *   view-syncer where to restore the backup from and the watermark from which
- *   catchup is possible. Once the backup is restored, the view-syncer sends
- *   `['start-subscription', ctx]`, which transitions the same connection into
- *   the subscription phase (change stream downstream). The reservation is
- *   released only after the subscriber is registered, so there is never a gap
- *   in which the change-streamer does not know the client's watermark.
- *
- * - **Reconnect (replica already valid):** the view-syncer sends
- *   `['start-subscription', ctx]` immediately, with no reservation.
- *
- * The reservation status uses a distinct `'reserved'` tag (rather than the
- * change stream's `'status'`) so the downstream union is unambiguous under
- * passthrough parsing.
- */
-import * as v from '../../../../shared/src/valita.ts';
-declare const snapshotStatusSchema: v.ObjectType<Omit<{
-    tag: v.Type<"status">;
-    backupURL: v.Type<string>;
-    replicaVersion: v.Type<string>;
-    minWatermark: v.Type<string>;
-    replicaSize: v.Optional<number>;
-}, "tag"> & {
-    tag: v.Type<"snapshot">;
-}, undefined>;
-export type SnapshotStatus = v.Infer<typeof snapshotStatusSchema>;
-/**
- * The state of the replica on the subscriber's disk, if any. This allows the
- * replication-manager to distinguish a subscriber that is replacing its
- * replica (i.e. one that was serving, see `RestoreAdmission`) from one that
- * is restoring onto an empty disk.
- */
-export declare const localReplicaSchema: v.ObjectType<{
-    replicaVersion: v.Type<string>;
-    watermark: v.Type<string>;
-}, undefined>;
-export type LocalReplica = v.Infer<typeof localReplicaSchema>;
-export declare const reserveSnapshotMessageSchema: v.TupleType<[v.Type<"reserve-snapshot">, v.ObjectType<{
-    taskID: v.Type<string>;
-    localReplica: v.Optional<{
-        replicaVersion: string;
-        watermark: string;
-    }>;
-}, undefined>]>;
-/**
- * The subscription-initialization context, sent in the `start-subscription`
- * message. Equivalent to the previous URL-encoded `SubscriberContext`, minus
- * the fields that are now implicit on the merged connection:
- * - `protocolVersion` comes from the request path.
- * - `wsBatched` is always on (the transport batches internally).
- *
- * Parsed in `passthrough` mode so a forthcoming, orthogonal change can add
- * arbitrary table/column/backfill state without a protocol bump.
- */
-export declare const subscribeContextSchema: v.ObjectType<{
-    /** Task ID, links the subscription to a preceding snapshot reservation. */
-    taskID: v.Type<string>;
-    /** Subscriber id (debugging only). */
-    id: v.Type<string>;
-    /** 'serving' (user-facing) or 'backup' (in-RM replicator). */
-    mode: v.UnionType<[v.Type<"serving">, v.Type<"backup">]>;
-    /** The replica version the subscriber restored / is running. */
-    replicaVersion: v.Type<string>;
-    /** The watermark up to which the subscriber is up to date. */
-    watermark: v.Type<string>;
-    /**
-     * The subscriber's pending backfills (and their progress) as of its
-     * `watermark`. This should be considered non-optional as of protocol v8;
-     * it is only absent from v7 subscribers.
-     */
-    backfills: v.Optional<{
-        table: {
-            schema: string;
-            name: string;
-            metadata: {
-                [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
-                rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
-            } | null;
-        };
-        columns: Record<string, {
-            id: Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>;
-            progress?: {
-                [x: string]: string | number;
-                progressMark: string;
-                timeline?: string | undefined;
-            } | undefined;
-        }>;
-    }[]>;
-    /** See `SubscriberContext.drainable`. */
-    drainable: v.Optional<boolean>;
-    /** See `SubscriberContext.switchover`. */
-    switchover: v.Optional<boolean>;
-}, undefined>;
-export type SubscribeContext = v.Infer<typeof subscribeContextSchema>;
-export declare const startSubscriptionMessageSchema: v.TupleType<[v.Type<"start-subscription">, v.ObjectType<{
-    /** Task ID, links the subscription to a preceding snapshot reservation. */
-    taskID: v.Type<string>;
-    /** Subscriber id (debugging only). */
-    id: v.Type<string>;
-    /** 'serving' (user-facing) or 'backup' (in-RM replicator). */
-    mode: v.UnionType<[v.Type<"serving">, v.Type<"backup">]>;
-    /** The replica version the subscriber restored / is running. */
-    replicaVersion: v.Type<string>;
-    /** The watermark up to which the subscriber is up to date. */
-    watermark: v.Type<string>;
-    /**
-     * The subscriber's pending backfills (and their progress) as of its
-     * `watermark`. This should be considered non-optional as of protocol v8;
-     * it is only absent from v7 subscribers.
-     */
-    backfills: v.Optional<{
-        table: {
-            schema: string;
-            name: string;
-            metadata: {
-                [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
-                rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
-            } | null;
-        };
-        columns: Record<string, {
-            id: Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>;
-            progress?: {
-                [x: string]: string | number;
-                progressMark: string;
-                timeline?: string | undefined;
-            } | undefined;
-        }>;
-    }[]>;
-    /** See `SubscriberContext.drainable`. */
-    drainable: v.Optional<boolean>;
-    /** See `SubscriberContext.switchover`. */
-    switchover: v.Optional<boolean>;
-}, undefined>]>;
-export declare const subscribeUpstreamSchema: v.UnionType<[v.TupleType<[v.Type<"reserve-snapshot">, v.ObjectType<{
-    taskID: v.Type<string>;
-    localReplica: v.Optional<{
-        replicaVersion: string;
-        watermark: string;
-    }>;
-}, undefined>]>, v.TupleType<[v.Type<"start-subscription">, v.ObjectType<{
-    /** Task ID, links the subscription to a preceding snapshot reservation. */
-    taskID: v.Type<string>;
-    /** Subscriber id (debugging only). */
-    id: v.Type<string>;
-    /** 'serving' (user-facing) or 'backup' (in-RM replicator). */
-    mode: v.UnionType<[v.Type<"serving">, v.Type<"backup">]>;
-    /** The replica version the subscriber restored / is running. */
-    replicaVersion: v.Type<string>;
-    /** The watermark up to which the subscriber is up to date. */
-    watermark: v.Type<string>;
-    /**
-     * The subscriber's pending backfills (and their progress) as of its
-     * `watermark`. This should be considered non-optional as of protocol v8;
-     * it is only absent from v7 subscribers.
-     */
-    backfills: v.Optional<{
-        table: {
-            schema: string;
-            name: string;
-            metadata: {
-                [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
-                rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
-            } | null;
-        };
-        columns: Record<string, {
-            id: Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>;
-            progress?: {
-                [x: string]: string | number;
-                progressMark: string;
-                timeline?: string | undefined;
-            } | undefined;
-        }>;
-    }[]>;
-    /** See `SubscriberContext.drainable`. */
-    drainable: v.Optional<boolean>;
-    /** See `SubscriberContext.switchover`. */
-    switchover: v.Optional<boolean>;
-}, undefined>]>]>;
-export type SubscribeUpstream = v.Infer<typeof subscribeUpstreamSchema>;
-/**
- * The reservation confirmation. Carries the same payload as the legacy
- * `/snapshot` status (`backupURL`, `replicaVersion`, `minWatermark`,
- * `replicaSize?`) but under a distinct `'reserved'` tag so it does not collide
- * with the change stream's `['status', …]` message.
- */
-export declare const reservedMessageSchema: v.TupleType<[v.Type<"reserved">, v.ObjectType<Omit<{
-    tag: v.Type<"status">;
-    backupURL: v.Type<string>;
-    replicaVersion: v.Type<string>;
-    minWatermark: v.Type<string>;
-    replicaSize: v.Optional<number>;
-}, "tag"> & {
-    tag: v.Type<"snapshot">;
-}, undefined>]>;
-export type ReservedMessage = v.Infer<typeof reservedMessageSchema>;
-export declare const subscribeDownstreamSchema: v.UnionType<[v.TupleType<[v.Type<"reserved">, v.ObjectType<Omit<{
-    tag: v.Type<"status">;
-    backupURL: v.Type<string>;
-    replicaVersion: v.Type<string>;
-    minWatermark: v.Type<string>;
-    replicaSize: v.Optional<number>;
-}, "tag"> & {
-    tag: v.Type<"snapshot">;
-}, undefined>]>, 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;
-    }>;
-    draining: v.Optional<boolean>;
-    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>;
-    replicaVersion: v.Optional<string>;
-}, undefined>]>]>]>;
-export type SubscribeDownstream = v.Infer<typeof subscribeDownstreamSchema>;
-export {};
-//# sourceMappingURL=subscribe.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/subscribe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,CAAC,MAAM,kCAAkC,CAAC;AAKtD,QAAA,MAAM,oBAAoB;;;;;;;;aAExB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;aAG7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,4BAA4B;;;;;;eAMvC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;IACjC,2EAA2E;;IAE3E,sCAAsC;;IAEtC,8DAA8D;;IAE9D,gEAAgE;;IAEhE,8DAA8D;;IAE9D;;;;OAIG;;;;;;;;;;;;;;;;;;;IAEH,yCAAyC;;IAEzC,0CAA0C;;aAE1C,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,8BAA8B;IAxBzC,2EAA2E;;IAE3E,sCAAsC;;IAEtC,8DAA8D;;IAE9D,gEAAgE;;IAEhE,8DAA8D;;IAE9D;;;;OAIG;;;;;;;;;;;;;;;;;;;IAEH,yCAAyC;;IAEzC,0CAA0C;;eAS1C,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;IA7BlC,2EAA2E;;IAE3E,sCAAsC;;IAEtC,8DAA8D;;IAE9D,gEAAgE;;IAEhE,8DAA8D;;IAE9D;;;;OAIG;;;;;;;;;;;;;;;;;;;IAEH,yCAAyC;;IAEzC,0CAA0C;;iBAc3C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;eAGhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

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

@@ -1,194 +0,0 @@
-import type { Enum } from '../../../../shared/src/enum.ts';
-import type { Subscription } from '../../types/subscription.ts';
-import type { ReplicatorMode } from '../replicator/replicator.ts';
-import type { BackfillState } from './backfill-state.ts';
-import type { PreSerializedBatch } from './broadcast.ts';
-import type { ChangeTag, Status, WatermarkedChange } from './change-streamer.ts';
-import type * as ErrorType from './error-type-enum.ts';
-type ErrorType = Enum<typeof ErrorType>;
-export type SubscriberOptions = {
-    backlogHighWaterBytes?: number | undefined;
-    backlogLowWaterRatio?: number | undefined;
-    wsBatched?: boolean | undefined;
-    /**
-     * Called whenever the subscriber's acked watermark advances, i.e. when it
-     * has confirmed that a commit was durably applied to its replica. The ACK
-     * therefore lags the subscriber's replica rather than leading it.
-     */
-    onAck?: ((watermark: string) => void) | undefined;
-    /**
-     * The subscriber's pending backfills (protocol v8+), which are tracked
-     * over the changes sent to the subscriber.
-     */
-    backfills?: BackfillState | undefined;
-    /**
-     * Called once the subscriber has been sent all changes up to the head of
-     * the stream, i.e. its catchup and backlog have been flushed. From this
-     * point on, the subscriber's tracked {@link backfills} reflect the same
-     * position in the stream as that of the change-streamer.
-     */
-    onAligned?: ((subscriber: Subscriber) => void) | undefined;
-    /**
-     * Called when a `backfill` or `backfill-completed` message is ignored for
-     * some of the subscriber's pending backfill columns, after the subscriber
-     * is aligned.
-     */
-    onBackfillIgnored?: ((columns: string[]) => void) | undefined;
-    /**
-     * Resolves to whether lag reporting is disabled upstream. If so, a
-     * {@link LAG_REPORTING_DISABLED} status is sent once the subscriber is
-     * aligned, as a stand-in for the lag reports that a subscriber would
-     * otherwise use to determine that it is caught up (e.g. to advertise
-     * readiness to serve traffic).
-     */
-    lagReportingDisabled?: Promise<boolean> | undefined;
-    /**
-     * Whether the subscriber switches over to another replication-manager
-     * when this one drains (see `DrainTracker`).
-     */
-    drainable?: boolean | undefined;
-};
-export type BacklogFullWait = {
-    readonly promise: Promise<void>;
-    cancel(): void;
-};
-export type SubscriberStats = {
-    processRate: number;
-    pending: number;
-    backlog: number;
-    backlogBytes: number;
-    totalBufferedBytes: number;
-    missedLastTimeout: boolean;
-};
-/**
- * Encapsulates a subscriber to changes. All subscribers start in a
- * "catchup" phase in which changes are buffered in a backlog while the
- * storer is queried to send any changes that were committed since the
- * subscriber's watermark. Once the catchup is complete, calls to
- * {@link send()} result in immediately sending the change.
- */
-export declare class Subscriber {
-    #private;
-    readonly id: string;
-    readonly mode: ReplicatorMode;
-    readonly drainable: boolean;
-    constructor(protocolVersion: number, id: string, mode: ReplicatorMode, watermark: string, downstream: Subscription<string | PreSerializedBatch>, options?: SubscriberOptions);
-    /**
-     * The subscriber's tracked pending backfills, or `undefined` if the
-     * subscriber does not report them (i.e. protocol < v8).
-     */
-    get backfills(): BackfillState | undefined;
-    /**
-     * Whether the subscriber has been sent all changes up to the head of the
-     * stream (see {@link SubscriberOptions.onAligned}).
-     */
-    get aligned(): boolean;
-    /**
-     * Resolves once the subscriber has caught up, i.e. once it has acked
-     * (durably applied) all changes up to the head of the stream at the time
-     * it was {@link aligned}. Never resolves if the subscriber is closed first.
-     */
-    get caughtUp(): Promise<void>;
-    get watermark(): string;
-    get acked(): string;
-    /**
-     * Whether the backlog of live changes buffered during catchup has reached the
-     * point at which {@link send()} stops resolving. Past it the subscriber is no
-     * longer free: it holds up every subsequent flush, and with no other
-     * subscriber to form a majority it stalls replication outright.
-     */
-    get backlogFull(): boolean;
-    /**
-     * @returns whether the subscriber is currently sending backlogged messages,
-     *          vs caught up and sending the "head" of the replication stream.
-     */
-    isBacklogged(): boolean;
-    /**
-     * Resolves the first time {@link backlogFull} becomes true, so that a caller
-     * holding the subscriber in catchup can give up at the moment the subscriber
-     * starts costing replication rather than on a timer. Call cancel() when the
-     * wait is no longer needed so the subscriber does not retain it.
-     */
-    whenBacklogFull(): BacklogFullWait;
-    send(change: WatermarkedChange): Promise<void>;
-    sendBatch(changes: readonly WatermarkedChange[], preSerialized?: PreSerializedBatch | undefined): Promise<void>;
-    /**
-     * Sends a status message (e.g. a lag report) downstream. While the
-     * subscriber is catching up, the status is queued in the backlog behind
-     * the changes that preceded it in the replication stream, so that the
-     * subscriber processes it in stream order. This is necessary for lag
-     * reports to measure the lag of the subscriber, including its catchup.
-     *
-     * Status messages received before the subscriber is initialized are
-     * dropped.
-     */
-    sendStatus(status: Status): void;
-    /**
-     * Sends a control status (e.g. `draining` or `restore`) downstream
-     * immediately, regardless of whether the subscriber is initialized or
-     * catching up. Unlike {@link sendStatus}, such statuses are not tied to a
-     * position in the replication stream.
-     */
-    sendControlStatus(status: Status): void;
-    /** catchup() is called on ChangeEntries loaded from the store. */
-    catchup(change: WatermarkedChange): Promise<void>;
-    /**
-     * Marks the Subscribe as "caught up" and flushes any backlog of
-     * entries that were received during the catchup.
-     */
-    setCaughtUp(): Promise<void>;
-    /**
-     * The number of downstream messages that have yet to be acked.
-     */
-    get numPending(): number;
-    /**
-     * The total number of downstream messages that the subscriber has
-     * processed (i.e. acked).
-     */
-    get numProcessed(): number;
-    /**
-     * Records a new history entry for the number of messages processed,
-     * keeping the number of samples bounded to `maxSamples`.
-     */
-    sampleProcessRate(now: number, maxSamples?: number): this;
-    getStats(): SubscriberStats;
-    trackResponseResult(result: 'on-time' | 'timed-out'): void;
-    /**
-     * Reports the change rate of a slow subscriber (i.e. that missed the last
-     * timeout) compared to the change rate of the (slowest) subscriber that
-     * responded on time.
-     *
-     * * `lagging` indicates that this subscriber is slower
-     * * `catching-up` indicates that it is faster
-     *
-     * Returns the total duration in which subscriber has been continuously
-     * reported as `lagging`.
-     */
-    reportChangeRate(now: number, status: 'lagging' | 'catching-up'): number;
-    supportsMessage(tag: ChangeTag): boolean;
-    /**
-     * Ends the subscription without sending a downstream `['error', ...]`.
-     *
-     * This is deliberate, and not the same as reporting the failure to the
-     * subscriber: `IncrementalSyncer` treats any `['error', ...]` as terminal and
-     * shuts down to restore a fresh replica from litestream, whereas a clean end
-     * backs off and re-subscribes. The failures routed here -- storer catchup
-     * errors, backlog drain errors, backup-monitor errors -- are transient, so a
-     * reconnect is the proportionate response and a fleet-wide restore is not.
-     *
-     * Callers are responsible for logging `err`; it is not carried downstream.
-     */
-    fail(_err?: unknown): void;
-    close(error?: ErrorType, message?: string, details?: {
-        replicaVersion?: string | undefined;
-    }): void;
-}
-/**
- * Sent to an aligned subscriber when lag reporting is disabled upstream,
- * signaling that the subscriber is caught up. This is a lag report with a
- * `nextSendTimeMs` of 0 and no `lastTimings`, so that no lag is measured
- * (see `isLagReportingDisabledSignal()` in the replicator's recorder).
- */
-export declare const LAG_REPORTING_DISABLED: Status;
-export {};
-//# sourceMappingURL=subscriber.d.ts.map