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

package/out/zero-cache/src/services/change-source/pg/logical-replication/stream.d.ts

@@ -1,169 +0,0 @@
-import { Readable } from 'node:stream';
-import type { LogContext } from '@rocicorp/logger';
-import postgres from 'postgres';
-import type { SlotKeeperConfig } from '../../../../server/slot-keeper.ts';
-import { type PostgresDB } from '../../../../types/pg.ts';
-import { type Worker } from '../../../../types/processes.ts';
-import { type Sink, type Source } from '../../../../types/streams.ts';
-import type { Message } from './pgoutput.types.ts';
-export declare const DEFAULT_RETRIES_IF_REPLICATION_SLOT_ACTIVE = 5;
-export type StreamMessage = [
-    lsn: bigint,
-    Message | {
-        tag: 'keepalive';
-        shouldRespond: boolean;
-    }
-];
-type SourceWithPendingQueue<T> = Source<T> & {
-    queued: number;
-};
-export declare function createReplicationSessionFor(db: PostgresDB, applicationName: string): postgres.Sql<{}>;
-export declare function subscribe(lc: LogContext, db: PostgresDB, slot: string, publications: string[], lsn: bigint, retriesIfReplicationSlotActive?: number, applicationName?: string, inboundTimeoutOverrideMs?: number | undefined): Promise<{
-    messages: SourceWithPendingQueue<StreamMessage>;
-    acks: Sink<bigint>;
-}>;
-/**
- * Measures how long upstream takes to decode the WAL between the slot's
- * `restart_lsn` and the start of the stream, during which the stream
- * delivers nothing but keepalives. This span can be large, e.g. for a slot
- * that was created (or last acked) long before the requested start LSN.
- *
- * The walsender streams from `max(lsn, confirmed_flush_lsn)`, but must
- * decode from `restart_lsn` to rebuild its transaction state. The decode is
- * considered complete upon the first message at or past the start:
- * * any XLogData message, since only transactions committed after the
- *   start are sent, or
- * * a keepalive at or past the start. Keepalives report the decoding
- *   position, except for the first one of the stream, which reports the
- *   slot's `confirmed_flush_lsn` and is thus ignored if it is at or past the
- *   start.
- *
- * Note that on an idle upstream, a walsender whose start is already
- * confirmed may not send a keepalive until other WAL is written or the
- * periodic keepalive (`wal_sender_timeout / 2`) is due, so the measured
- * time is an upper bound when completed by a keepalive.
- */
-export declare class InitialDecodeTracker {
-    #private;
-    static start(lc: LogContext, session: postgres.Sql, slot: string, lsn: bigint): Promise<InitialDecodeTracker>;
-    constructor(lc: LogContext, lsn: bigint, restartLSN: bigint | undefined, confirmedFlushLSN: bigint | undefined, startTime: number);
-    /**
-     * Observes a received message, returning the elapsed decode time (ms) if
-     * this message completed the initial decode.
-     */
-    observe([lsn, msg]: StreamMessage, now: number): number | undefined;
-}
-/**
- * Derives the timings for the replication liveness timer from the server's
- * `wal_sender_timeout` (in milliseconds).
- *
- * Postgres treats `wal_sender_timeout = 0` as "disabled": it will neither
- * terminate an idle wal sender nor emit the periodic keepalives it otherwise
- * sends at roughly `wal_sender_timeout / 2`. Every timing below is derived from
- * that interval, so a disabled timeout disables the liveness machinery entirely
- * (`enabled: false`). Otherwise the derived thresholds would all collapse to 0,
- * inverting the intended meaning: the inbound watchdog would fire on the very
- * first tick and destroy the stream, while the timer itself would busy-spin at
- * a 0ms interval — together producing a continuous reconnect storm.
- *
- * An `inboundTimeoutOverrideMs` (when positive) replaces the default
- * `2x wal_sender_timeout` inbound threshold. The two timeouts protect
- * different parties with asymmetric false-positive costs: `wal_sender_timeout`
- * is the server reaping dead clients (a false positive there costs a cheap
- * reconnect), while the inbound watchdog tears down the stream and replays the
- * in-flight transaction — expensive, and self-defeating when the wal sender is
- * legitimately silent for long stretches (e.g. decoding through WAL from
- * unpublished tables, or assembling a large transaction that pgoutput only
- * sends at commit). Operators who don't own the server setting (e.g. managed
- * or operator-provisioned Postgres with an aggressive cluster-wide
- * `wal_sender_timeout`) can widen the client-side fuse independently.
- *
- * The override has no effect when `wal_sender_timeout` is disabled (0): the
- * server then sends no periodic keepalives, so inbound silence is normal even
- * on an idle healthy connection and any silence-based watchdog would
- * false-positive.
- *
- * https://www.postgresql.org/docs/current/runtime-config-replication.html#GUC-WAL-SENDER-TIMEOUT
- */
-export declare function computeLivenessTimings(walSenderTimeoutMs: number, inboundTimeoutOverrideMs?: number | undefined): {
-    enabled: boolean;
-    manualKeepaliveTimeout: number;
-    inboundTimeoutMs: number;
-    timerIntervalMs: number;
-};
-/**
- * Pure decision for the inbound-liveness watchdog, given the time since the
- * last inbound message, the timeout threshold, and the number of messages
- * currently queued downstream (see {@link SourceWithPendingQueue.queued}).
- *
- * A non-empty downstream queue means we have received data we haven't yet
- * consumed: the reason we aren't receiving *more* is our own back-pressure, not
- * upstream silence. In that case we `resetWindow` (treat the backlog as
- * liveness evidence) rather than counting the stall against the connection.
- * This both suppresses false timeouts during back-pressure and — crucially —
- * keeps `lastReceivedTime` fresh so the drain transition (queue emptying after
- * a long stall) doesn't fire the watchdog against a stale timestamp on the very
- * next tick.
- *
- * Only when the queue is empty (consumption has caught up, so reading — and
- * thus keepalives — should be flowing again) does an over-threshold gap
- * indicate a genuinely dead inbound half.
- */
-export declare function evaluateInboundLiveness({ sinceLastReceived, inboundTimeoutMs, queued, }: {
-    sinceLastReceived: number;
-    inboundTimeoutMs: number;
-    queued: number;
-}): {
-    resetWindow: boolean;
-    timedOut: boolean;
-};
-export declare function startReplicationStream(lc: LogContext, session: postgres.Sql, slot: string, publications: string[], lsn: bigint, maxAttempts?: number): Promise<[Readable, import("stream").Writable]>;
-/**
- * Starts a "dummy" replication session for the specified `slot` which:
- * * does not consume any records
- * * keeps the session alive by sending status messages at the starting LSN
- *
- * This essentially reserves the replication slot for this process by marking
- * it as "active" in pg_replication_slots, allowing replication slot cleanup
- * logic to distinguish a new-but-initializing replication slot from one that
- * has been abandoned / orphaned.
- *
- * When initialization (e.g. initial-sync) has finished, the server should take
- * over the replication slot using pg_terminate_backend, which will close the
- * session.
- *
- * Note that caller should not close the supplied `session`, as that will
- * also terminate the dummy replication session.
- */
-export declare class SlotReservationHandle extends Readable {
-    #private;
-    constructor(worker: Worker);
-    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
-    end(timeoutMs?: number): Promise<void>;
-}
-export declare function endSession(session?: Readable): Promise<void>;
-export type PgConnectionConfig = {
-    host?: string | string[] | undefined;
-    port?: number | number[] | undefined;
-    path?: string | undefined;
-    database?: string | undefined;
-    user?: string | undefined;
-    pass?: string | null | undefined;
-    ssl?: boolean | string | {
-        rejectUnauthorized?: boolean | undefined;
-    } | undefined;
-};
-export declare function extractConnectionConfig(session: postgres.Sql): PgConnectionConfig;
-/**
- * Starts a "dummy" replication session for the specified `slot` which:
- * * does not consume any records
- * * keeps the session alive by sending status messages at the starting LSN
- *
- * Runs in a separate process with its own event loop and connection reconnect
- * loop to prevent slot drop races during heavy initial sync table copy or
- * SQLite index building.
- */
-export declare function keepSlotActiveUntilTakenOver(lc: LogContext, config: SlotKeeperConfig): Promise<Readable>;
-export declare function makeAck(lsn: bigint): Buffer;
-export {};
-//# sourceMappingURL=stream.d.ts.map

package/out/zero-cache/src/services/change-source/pg/logical-replication/stream.d.ts.map

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

package/out/zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.d.ts

@@ -1,16 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { PostgresDB } from '../../../types/pg.ts';
-import type { ShardID } from '../../../types/shards.ts';
-type Options = {
-    inactiveSlotCleanupTimeoutMs?: number | undefined;
-    pollIntervalMs?: number | undefined;
-};
-export declare class ReplicationSlotCleanupMonitor {
-    #private;
-    constructor(lc: LogContext, shard: ShardID, upstream: PostgresDB, upstreamPgServerVersionNum: number, currentSlot: string, { inactiveSlotCleanupTimeoutMs, pollIntervalMs }?: Options);
-    start(): void;
-    stop(): void;
-    getSlotsToCleanup(now: Date): Promise<string[]>;
-}
-export {};
-//# sourceMappingURL=replication-slot-cleanup-monitor.d.ts.map

package/out/zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replication-slot-cleanup-monitor.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slot-cleanup-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAItD,KAAK,OAAO,GAAG;IACb,4BAA4B,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC,CAAC;AAKF,qBAAa,6BAA6B;;IAkCxC,YACE,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,UAAU,EACpB,0BAA0B,EAAE,MAAM,EAClC,WAAW,EAAE,MAAM,EACnB,EAAC,4BAA4B,EAAE,cAAc,EAAC,GAAE,OAAY,EAW7D;IAED,KAAK,SAYJ;IAED,IAAI,SAIH;IAiBK,iBAAiB,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAqEpD;CACF"}

package/out/zero-cache/src/services/change-source/pg/replication-slot-health.d.ts

@@ -1,15 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { PostgresDB } from '../../../types/pg.ts';
-declare const SLOT_HEALTH_STATUSES: readonly ['ok', 'unreserved', 'lost', 'missing', 'unknown'];
-export type SlotHealthStatus = (typeof SLOT_HEALTH_STATUSES)[number];
-export type SlotHealthRow = {
-    readonly restartLSN: string | null;
-    readonly walStatus: string | null;
-    readonly retainedWalBytes: number | null;
-    readonly safeWalBytes: number | null;
-};
-export declare function slotHealthStatus(row: Pick<SlotHealthRow, 'restartLSN' | 'walStatus'> | undefined): SlotHealthStatus;
-export declare function registerReplicationSlotHealthMetrics(lc: LogContext, db: PostgresDB, slot: string, isStopped: () => boolean): void;
-export declare function queryReplicationSlotHealth(db: PostgresDB, slot: string): Promise<SlotHealthRow | undefined>;
-export {};
-//# sourceMappingURL=replication-slot-health.d.ts.map

package/out/zero-cache/src/services/change-source/pg/replication-slot-health.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replication-slot-health.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slot-health.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAErD,QAAA,MAAM,oBAAoB,YACxB,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,SAAS,EACT,SAAS,CACD,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAErE,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,WAAW,CAAC,GAAG,SAAS,GAC/D,gBAAgB,CAgBlB;AAED,wBAAgB,oCAAoC,CAClD,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,OAAO,GACvB,IAAI,CAoCN;AAwBD,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAapC"}

package/out/zero-cache/src/services/change-source/pg/replication-slots.d.ts

@@ -1,127 +0,0 @@
-import type { Readable } from 'node:stream';
-import type { LogContext } from '@rocicorp/logger';
-import postgres from 'postgres';
-import { type PostgresDB } from '../../../types/pg.ts';
-import { type ShardID } from '../../../types/shards.ts';
-import { type ReplicaStage } from './schema/replica-stage-enum.ts';
-import { type BackupOptions, type ReplicaState } from './schema/shard.ts';
-export type ReplicationSlot = {
-    slot_name: string;
-    consistent_point: string;
-    snapshot_name: string;
-    output_plugin: string;
-};
-export type ReplicationSlotResult<T> = {
-    slot: ReplicationSlot;
-    capturedSnapshot: T;
-    initialSession: Readable;
-    replica: ReplicaState;
-};
-export type ReservedSlot = {
-    slot: string;
-    reservation: Readable;
-    replica: ReplicaState;
-};
-export type CreateSlotSpec = {
-    slotName: string;
-    failover?: boolean;
-    temporary?: boolean;
-    lockTimeout?: number | undefined;
-    diagnosticsDB?: PostgresDB | undefined;
-};
-export declare const CREATE_REPLICATION_SLOT_TIMEOUT_MS = 60000;
-/** Thrown when the client-side timeout for creating a slot is reached. */
-export declare class SlotCreationTimeoutError extends Error {
-    readonly name = "SlotCreationTimeoutError";
-}
-export declare function createReplicationSlot(lc: LogContext, session: postgres.Sql, { slotName, failover, temporary, lockTimeout, diagnosticsDB, }: CreateSlotSpec): Promise<ReplicationSlot>;
-/**
- * Best-effort logging of what a timed out CREATE_REPLICATION_SLOT was waiting
- * on: the walsender's wait event and blocking pids, and the oldest
- * transactions holding an xid. Slot creation waits for every such transaction
- * on the instance (in all databases), each with its own lock_timeout, so a
- * chain of overlapping transactions can exceed the client-side timeout
- * without the lock_timeout ever firing.
- *
- * Query text is deliberately omitted since it can contain row values.
- *
- * Exported for testing.
- */
-export declare function logSlotCreationBlockers(lc: LogContext, sql: PostgresDB, walsenderPID: number, slotName: string): Promise<void>;
-export type CreateReplicaAndSlotOptions = {
-    lockTimeout?: number | undefined;
-    maxBlockedMs?: number | undefined;
-    retryDelayMs?: number | undefined;
-};
-/**
- * Replica and slot creation involves several sessions for proper
- * coordination with other replica management logic:
- *
- * * A dedicated session acquires a (session-level) advisory lock for
- *   replica slot management. This is the same lock that cleanup logic
- *   acquires before cleaning up replication slots. The lock is held
- *   outside of a transaction so that the session is not "idle in
- *   transaction" while slot creation waits on upstream transactions,
- *   which some upstreams terminate (e.g. idle_in_transaction_session_timeout).
- * * With the lock held, a new replication slot is created in a
- *   replication session. The API of CREATE_REPLICATION_SLOT is such
- *   that it cannot be done in a transaction, and cannot be followed by
- *   any writes, or else its snapshot (which is needed for initial sync)
- *   would be invalidated.
- * * Once the slot is created, the slot and replica information are recorded
- *   in the `replicas` table before releasing the lock.
- *
- * Slot creation waits for all transactions on the upstream instance that
- * hold an xid, so it can be blocked by long-running transactions. A blocked
- * attempt is abandoned (see {@link CREATE_REPLICATION_SLOT_TIMEOUT_MS}) and
- * retried in-process, as it leaves no durable state: the `replicas` row is
- * only inserted after the slot has been created. Retries continue until the
- * slot is created or until `maxBlockedMs` has elapsed, after which the error
- * is thrown.
- *
- * This locking ensures that:
- * 1. multiple replication managers attempting to create a replication slot
- *    will not use the same name for the replication slot (which is selected
- *    from a pool of reused names).
- * 2. Running replication managers (which use an earlier replica of a lower
- *    rank) will not delete the new slot during their cleanup logic, since
- *    the slot will belong to a replica of a higher rank.
- *
- * When the replication slot is created, `captureSnapshot` callback is first
- * run while the snapshot at the consistent point is available. The callback
- * must capture the snapshot in postgres (e.g. `SET TRANSACTION SNAPSHOT`)
- * in order to use it. Once the callback completes, a placeholder replication
- * session (i.e. that does not consume any messages) is started, in order to
- * reserve the slot by mark it "active", effectively distinguishing the
- * initializing session from a failed or abandoned session.
- *
- * Note that starting the replication session releases the initial snapshot,
- * which is why the callback must capture it synchronously, before the
- * replication session is started.
- *
- * The placeholder replication session is closed when the
- * PostgresChangeSource takes over the slot to process the stream in earnest.
- * It is also returned for cleanup in the case of failures (and for control
- * in unit tests).
- *
- * For replica's created in the `Restore` stage, the `generation` is
- * initialized to an empty string instead of the slot's consistent point,
- * since the slot is not being used for initial sync. It is the
- * responsibiliy of the caller to call {@link initRestoreReplica} when
- * the source replica has been selected for restoring, which will carry
- * over the `generation` and other relevant values from the source.
- */
-export declare function createReplicaAndSlot<T>(lc: LogContext, sql: PostgresDB, sessionName: string, shard: ShardID, epoch: number, replicaID: string, failover: boolean, backupOptions: BackupOptions, captureSnapshot: (snapshot: string) => Promise<T>, stage: ReplicaStage, { lockTimeout, maxBlockedMs, retryDelayMs, }?: CreateReplicaAndSlotOptions): Promise<ReplicationSlotResult<T>>;
-/**
- * Claims the inactive slot of the given replica for use by this task, opening
- * a replication session to mark it as active. The process should follow up by
- * taking over the slot via the PostgresChangeSource.
- *
- * The replica is identified by its ID (and not just its slot) because rows of
- * replicas whose slots were dropped outside of zero-cache's control may share
- * the slot name.
- */
-export declare function claimSlotForResumption(lc: LogContext, sql: PostgresDB, shard: ShardID, _sessionName: string, { id: replicaID, slot }: Pick<ReplicaState, 'id' | 'slot'>): Promise<ReservedSlot | null>;
-export declare function dropInactiveSlotsAndReplicas(lc: LogContext, sql: PostgresDB, shard: ShardID, slots: string[]): Promise<void>;
-export declare function slotPoolSuffix(n: number): string;
-//# sourceMappingURL=replication-slots.d.ts.map

package/out/zero-cache/src/services/change-source/pg/replication-slots.d.ts.map

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

package/out/zero-cache/src/services/change-source/pg/schema/init.d.ts

@@ -1,9 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { PostgresDB } from '../../../../types/pg.ts';
-import { type ShardConfig } from '../../../../types/shards.ts';
-/**
- * Ensures that a shard is set up for initial sync.
- */
-export declare function ensureShardSchema(lc: LogContext, db: PostgresDB, shard: ShardConfig, installPartialIndexTriggers?: boolean): Promise<void>;
-export declare const CURRENT_SCHEMA_VERSION: number;
-//# sourceMappingURL=init.d.ts.map

package/out/zero-cache/src/services/change-source/pg/schema/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAQjD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAiB,KAAK,WAAW,EAAC,MAAM,6BAA6B,CAAC;AAa7E;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,WAAW,EAClB,2BAA2B,UAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAiBf;AA8SD,eAAO,MAAM,sBAAsB,QASwB,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/backfill-progress.d.ts

@@ -1,68 +0,0 @@
-import type { BackfillProgressMark, BackfillRequest } from './current.ts';
-/**
- * The result of applying a backfill message to a column's tracked progress.
- * If `accept` is true, `progress` is the column's new progress.
- */
-export type AcceptResult = {
-    accept: true;
-    progress: BackfillProgressMark | undefined;
-} | {
-    accept: false;
-};
-/**
- * Applies the continuity policy of `backfill` (and `backfill-completed`)
- * messages to a column's `own` tracked progress, where `undefined` means that
- * the column has not received any backfill data (i.e. it needs a backfill
- * from scratch).
- *
- * * Messages without `progressMarks` are from pre-v8 replication-managers
- *   and are accepted unconditionally (i.e. the legacy behavior), with no
- *   change to the tracked progress.
- * * A message without a `previous` mark starts a backfill from scratch (or on
- *   a new timeline), and is always accepted.
- * * Otherwise, the message is only accepted if it is on the same timeline as
- *   `own`, and continues from a position at or before `own` (i.e. it does not
- *   create a gap).
- *
- * `current` is unset for `backfill-completed` messages, which do not advance
- * the progress.
- */
-export declare function acceptBackfill(own: BackfillProgressMark | undefined, marks: {
-    previous?: BackfillProgressMark | undefined;
-    current?: BackfillProgressMark;
-} | undefined): AcceptResult;
-/**
- * Returns whether a stream whose progress (for a column) is at `stream`
- * will deliver all of the data needed by a subscriber whose progress (for the
- * same column) is at `subscriber`. A `stream` progress of `undefined` indicates
- * a backfill that will start from scratch, which covers all subscribers.
- */
-export declare function covers(stream: BackfillProgressMark | undefined, subscriber: BackfillProgressMark | undefined): boolean;
-/**
- * Returns the position from which a backfill for the `req` must start
- * in order to satisfy the progress of all of its columns, i.e. the earliest
- * progress mark, or `undefined` (i.e. from scratch) if any column has no
- * progress or if the columns are on different timelines.
- */
-export declare function resumePoint(req: BackfillRequest): BackfillProgressMark | undefined;
-/**
- * Returns a copy of the `req` with the progress of every column set to
- * the request's {@link resumePoint}, i.e. the position from which the
- * backfill of the request will actually start.
- */
-export declare function withResumePoint(req: BackfillRequest): BackfillRequest;
-/**
- * Merges two BackfillRequests for the same table into one that satisfies
- * both. Both requests are expected to reflect the same (current) upstream
- * schema. For columns in both requests, the earlier progress mark is chosen,
- * or no progress mark (i.e. from scratch) if they are on different timelines.
- * If a column's backfill IDs differ (which is unexpected), the ID of `req1`
- * is chosen, and the column is backfilled from scratch.
- */
-export declare function getTableSuperset(req1: BackfillRequest, req2: BackfillRequest): BackfillRequest;
-/**
- * Merges the BackfillRequests of multiple parties (e.g. subscribers) into
- * one request per table, using {@link getTableSuperset}.
- */
-export declare function getSuperset(...requestSets: Iterable<BackfillRequest>[]): BackfillRequest[];
-//# sourceMappingURL=backfill-progress.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/backfill-progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-progress.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/protocol/backfill-progress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EAEhB,MAAM,cAAc,CAAC;AAyBtB;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB;IAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,oBAAoB,GAAG,SAAS,CAAA;CAAC,GAC1D;IAAC,MAAM,EAAE,KAAK,CAAA;CAAC,CAAC;AAEpB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,oBAAoB,GAAG,SAAS,EACrC,KAAK,EACD;IACE,QAAQ,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC5C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC,GACD,SAAS,GACZ,YAAY,CAyBd;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,UAAU,EAAE,oBAAoB,GAAG,SAAS,GAC3C,OAAO,CAOT;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,eAAe,GACnB,oBAAoB,GAAG,SAAS,CAelC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,eAAe,CAWrE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,eAAe,GACpB,eAAe,CA4BjB;AAMD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,WAAW,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,GAC1C,eAAe,EAAE,CAUnB"}

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

@@ -1,72 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-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 { PreSerializedBatch } from './broadcast.ts';
-import type { SubscriberContext } from './change-streamer.ts';
-import type { Subscriber, SubscriberOptions } from './subscriber.ts';
-export type SubscriberBackfillOptions = Pick<SubscriberOptions, 'backfills' | 'onAligned' | 'onBackfillIgnored'>;
-/**
- * Tracks the pending backfills (and their progress) of the change log, the
- * subscribers, and the current change stream, in order to determine:
- *
- * * the BackfillRequests with which to start a change stream, i.e. the
- *   superset of the pending backfills of the change log and all aligned
- *   subscribers, starting from the earliest progress, and
- * * whether (and why) the change stream must be restarted, i.e. when a
- *   newly aligned subscriber's pending backfills are not covered by the
- *   current stream.
- *
- * The change-streamer calls {@link startStream()} whenever it starts a change
- * stream, {@link track()} for every change that it forwards, and restarts
- * the stream at the next transaction boundary whenever a
- * {@link restartReason} is set.
- */
-export declare class BackfillStateTracker {
-    #private;
-    constructor(lc: LogContext);
-    /**
-     * The reason for which the change stream must be restarted, or `null` if
-     * it need not be. The restart should happen at the next transaction
-     * boundary, i.e. upon the next `commit`, or `status` message outside of a
-     * transaction.
-     */
-    get restartReason(): string | null;
-    /**
-     * Computes the BackfillRequests with which to start a new change stream:
-     * the superset of the pending backfills of the change log and of all
-     * aligned subscribers, all of which are consistent with the stream's
-     * starting watermark since streams are (re)started at transaction
-     * boundaries.
-     *
-     * @param logBackfillRequests The BackfillRequests from the change log's
-     *        cookie jar, consistent with the stream's starting watermark.
-     */
-    startStream(logBackfillRequests: BackfillRequest[]): BackfillRequest[];
-    /**
-     * Tracks a change that is forwarded to subscribers. This must be called
-     * (synchronously) before the change is forwarded, so that the stream's
-     * state is never ahead of that of aligned subscribers.
-     */
-    track(change: ChangeStreamData): void;
-    /**
-     * Requests a restart of the change stream (at the next transaction
-     * boundary), e.g. to start it with BackfillRequests that it was not
-     * started with.
-     */
-    requestRestart(reason: string): void;
-    /** Logs and records a (planned) restart for the {@link restartReason}. */
-    recordRestart(): void;
-    /**
-     * Returns the backfill-related {@link SubscriberOptions} for a new
-     * subscriber, which must subsequently be passed to {@link register()}.
-     */
-    subscriberOptions(lc: LogContext, ctx: SubscriberContext): SubscriberBackfillOptions;
-    /**
-     * Registers a subscriber (created with {@link subscriberOptions()}) until
-     * its `downstream` is closed. This is a no-op for subscribers that do not
-     * report their pending backfills.
-     */
-    register(subscriber: Subscriber, downstream: Subscription<string | PreSerializedBatch>): void;
-}
-//# sourceMappingURL=backfill-state-tracker.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-state-tracker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backfill-state-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAK9D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+CAA+C,CAAC;AAEnF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAE,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,iBAAiB,EACjB,WAAW,GAAG,WAAW,GAAG,mBAAmB,CAChD,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,oBAAoB;;IA6C/B,YAAY,EAAE,EAAE,UAAU,EAEzB;IAED;;;;;OAKG;IACH,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAEjC;IAED;;;;;;;;;OASG;IACH,WAAW,CAAC,mBAAmB,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAyBrE;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,gBAAgB,QAG7B;IAED;;;;OAIG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,QAE5B;IAED,0EAA0E;IAC1E,aAAa,SAGZ;IAED;;;OAGG;IACH,iBAAiB,CACf,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,iBAAiB,GACrB,yBAAyB,CAqB3B;IAED;;;;OAIG;IACH,QAAQ,CACN,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,YAAY,CAAC,MAAM,GAAG,kBAAkB,CAAC,QAMtD;CAsBF"}

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

@@ -1,50 +0,0 @@
-import type { BackfillRequest, ChangeStreamData } from '../change-source/protocol/current.ts';
-import type { WatermarkedChange } from './change-streamer.ts';
-/**
- * Tracks the state of the pending backfills (and their progress) of a party
- * in the replication stream (e.g. a subscriber, or the change-log itself), by
- * applying the same policies that a subscriber applies to its replica:
- * schema changes are folded with the {@link cookieOps} shared by the
- * cookie jars, and `backfill` / `backfill-completed` messages are accepted
- * or ignored with the continuity policy of {@link acceptBackfill}.
- *
- * Changes are applied transactionally: the changes of a transaction are
- * discarded if it is rolled back, and {@link requests()} only reflects
- * committed transactions.
- */
-export declare class BackfillState {
-    #private;
-    constructor(requests?: readonly BackfillRequest[]);
-    /** The (committed) pending backfills. */
-    requests(): BackfillRequest[];
-    /**
-     * Returns the `requests` with the (committed) progress of this state
-     * applied to the columns that are pending in both, i.e. same table, column,
-     * and backfill ID. Other columns have no progress (i.e. from scratch).
-     */
-    withProgress(requests: readonly BackfillRequest[]): BackfillRequest[];
-    /** Whether there are no (committed) pending backfills. */
-    get empty(): boolean;
-    /**
-     * Returns the columns (as `schema.table.column` strings) with (committed)
-     * pending backfills that are not covered by the (committed) progress of the
-     * `stream`, i.e. columns for which the `stream` will not deliver all of the
-     * necessary data.
-     */
-    uncovered(stream: BackfillState): string[];
-    /**
-     * Applies a serialized change, parsing it only if it is relevant.
-     *
-     * @returns The columns (as `schema.table.column` strings) of a backfill
-     *          message that were ignored due to the continuity policy.
-     */
-    applySerialized([, tag, json]: WatermarkedChange): string[];
-    /**
-     * Applies a change.
-     *
-     * @returns The columns (as `schema.table.column` strings) of a backfill
-     *          message that were ignored due to the continuity policy.
-     */
-    apply(change: ChangeStreamData): string[];
-}
-//# sourceMappingURL=backfill-state.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-state.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backfill-state.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAIjB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,KAAK,EAAY,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AA8CvE;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;;IAIxB,YAAY,QAAQ,GAAE,SAAS,eAAe,EAAO,EASpD;IAMD,yCAAyC;IACzC,QAAQ,IAAI,eAAe,EAAE,CAE5B;IAED;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,eAAe,EAAE,CAmBpE;IAED,0DAA0D;IAC1D,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAazC;IAED;;;;;OAKG;IACH,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAgB1D;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CA4DxC;CA6HF"}

package/out/zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.d.ts

@@ -1,12 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { NormalizedZeroConfig } from '../../config/normalize.ts';
-import { BackupMonitor } from './backup-monitor.ts';
-import { type BackupStateVerifier } from './litestream3-prometheus-poller.ts';
-export type BackupCleanupMonitorFactoryOptions = {
-    lc: LogContext;
-    config: NormalizedZeroConfig;
-    replicaFile: string;
-    verifyBackupState?: BackupStateVerifier | undefined;
-};
-export declare function createBackupCleanupMonitor({ lc, config, replicaFile, verifyBackupState, }: BackupCleanupMonitorFactoryOptions): BackupMonitor;
-//# sourceMappingURL=backup-cleanup-monitor-factory.d.ts.map

package/out/zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backup-cleanup-monitor-factory.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAKpE,OAAO,EAAC,aAAa,EAAoB,MAAM,qBAAqB,CAAC;AAErE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,oCAAoC,CAAC;AAG5C,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE,oBAAoB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,EACzC,EAAE,EACF,MAAM,EACN,WAAW,EACX,iBAAiB,GAClB,EAAE,kCAAkC,GAAG,aAAa,CAyBpD"}