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

package/out/zero-cache/src/services/change-source/pg/initial-sync.d.ts

@@ -1,155 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { JSONObject } from '../../../../../shared/src/bigint-json.ts';
-import type { DownloadStatus } from '../../../../../zero-events/src/status.ts';
-import { Database } from '../../../../../zqlite/src/db.ts';
-import type { IndexSpec, PublishedTableSpec } from '../../../db/specs.ts';
-import { type PostgresDB } from '../../../types/pg.ts';
-import type { ShardConfig } from '../../../types/shards.ts';
-import { ReplicationStatusPublisher } from '../../replicator/replication-status.ts';
-import type { InitCleanup } from '../common/init-cleanup.ts';
-import { type ReplicaState } from './schema/shard.ts';
-export type InitialSyncOptions = {
-    tableCopyWorkers: number;
-    profileCopy?: boolean | undefined;
-    textCopy?: boolean | undefined;
-    replicationSlotFailover?: boolean | undefined;
-    installPartialIndexTriggers?: boolean | undefined;
-    /**
-     * When set, run initial sync in "shadow" mode for verification: skip all
-     * upstream mutations (no replication slot, no addReplica, no dropShard, no
-     * slot drop on failure), suppress status events, and optionally sample
-     * rows from each table via TABLESAMPLE BERNOULLI + LIMIT. The caller is
-     * responsible for providing (and discarding) a throwaway SQLite `tx`.
-     */
-    shadow?: {
-        /** 0 < rate <= 1. When 1, no TABLESAMPLE clause is added. */
-        sampleRate: number;
-        /**
-         * LIMIT N cap appended after TABLESAMPLE. Required: shadow sync is
-         * for verification only, so every run must commit to a row budget.
-         */
-        maxRowsPerTable: number;
-    } | undefined;
-};
-export type ReplicaOptions = {
-    epoch: number;
-    backupV5: boolean;
-    /**
-     * Whether the replica's slot is acked only after transactions are stored in
-     * the PG change log (see `pgChangeLog` in `ReplicaState`). Defaults to
-     * false, i.e. unknown.
-     */
-    pgChangeLog: boolean;
-};
-/** Server context to store with the initial sync metadata for debugging. */
-export type ServerContext = JSONObject;
-/**
- * @returns The {@link ReplicaState} of the initialized replica, or `undefined`
- *          for a shadow sync.
- */
-export declare function initialSync(lc: LogContext, shard: ShardConfig, tx: Database, upstreamURI: string, syncOptions: InitialSyncOptions, context: ServerContext, { epoch, backupV5, pgChangeLog }?: ReplicaOptions, cleanup?: InitCleanup): Promise<ReplicaState | undefined>;
-export type ShadowSyncOptions = {
-    sampleRate: number;
-    maxRowsPerTable: number;
-    /**
-     * Parent directory for the throwaway SQLite replica. Defaults to the OS
-     * tmpdir. Primarily for tests that need to isolate the scratch directory.
-     */
-    parentDir?: string | undefined;
-};
-/**
- * Exercises the initial-sync code path against a sample of rows from every
- * published table, writing into a throwaway SQLite database that is deleted
- * when the run ends. Produces zero upstream mutations: no replication slot,
- * no `addReplica`, no `dropShard`, no status events.
- *
- * Intended to be invoked periodically so that if a customer ever needs a
- * full reset, we have recent confidence that `initialSync` still works.
- * The shard must already be initialized upstream.
- */
-export declare function shadowInitialSync(lc: LogContext, shard: ShardConfig, upstreamURI: string, shadow: ShadowSyncOptions, context: ServerContext, syncOptions?: Pick<InitialSyncOptions, 'textCopy'>): Promise<void>;
-/**
- * Creates the `indices`, publishing progress before each one.
- *
- * @returns The milliseconds spent creating the indexes, excluding the time
- *          spent publishing progress.
- *
- * Exported for testing.
- */
-export declare function createLiteIndices(lc: LogContext, tx: Database, indices: IndexSpec[], statusPublisher: ReplicationStatusPublisher): Promise<number>;
-/**
- * Runs structural assertions over a just-synced replica and throws if any
- * fail. Only called in shadow mode — a successful return means the replica
- * is schema-complete, row-count consistent, and its column metadata is in
- * sync with its lite schema.
- *
- * Note: this intentionally does NOT verify ZQL-queryability. Tables that
- * `computeZqlSpecs` drops (no PK / no all-NOT-NULL unique index, unsupported
- * column types, etc.) are silently skipped in production too — there's
- * nothing shadow-specific about them, so failing here would diverge from
- * prod over an upstream-schema condition prod accepts.
- *
- * Exported for testing.
- */
-export declare function verifyShadowReplica(lc: LogContext, db: Database, published: {
-    tables: PublishedTableSpec[];
-    indexes: IndexSpec[];
-}, rowsByTable: ReadonlyMap<string, number>): void;
-/**
- * The row filter of the table's publications, as a parenthesized boolean
- * expression, or `null` if the table is published without a filter.
- */
-export declare function publicationRowFilter(table: PublishedTableSpec): string | null;
-export declare const INSERT_BATCH_SIZE = 50;
-export type DownloadStatements = {
-    select: string;
-    getTotalRows: string;
-    getTotalBytes: string;
-};
-/**
- * Returns the SELECT column expressions for binary COPY, casting columns
- * without a known binary decoder to `::text`.
- */
-export declare function makeBinarySelectExprs(table: PublishedTableSpec, cols: string[]): string[];
-/**
- * Orders the downloaded rows, and optionally restricts them to a suffix of
- * that order. Used by resumable backfills; see `backfill-resume.ts`.
- */
-export type DownloadOrder = {
-    /**
-     * The `ORDER BY` expression, e.g. from `orderByRowKey()`. If unset, the
-     * natural order of the scan is used (e.g. physical order for `ctid`-based
-     * resumption).
-     */
-    readonly by?: string | undefined;
-    /**
-     * A boolean SQL expression restricting the download to rows after a mark,
-     * e.g. from `resumeWhere()`. It is ANDed with the publication row filter,
-     * and applies to the row and byte totals as well, so that a resumed run
-     * reports the progress of what remains.
-     */
-    readonly after?: string | undefined;
-};
-export declare function makeDownloadStatements(table: PublishedTableSpec, cols: string[], sampleRate?: number | undefined, maxRowsPerTable?: number | undefined, selectExprs?: string[] | undefined, order?: DownloadOrder | undefined): DownloadStatements;
-type DownloadState = {
-    spec: PublishedTableSpec;
-    status: DownloadStatus;
-};
-type CopyFormat = 'binary' | 'text';
-type InitialSyncMode = 'initial' | 'shadow';
-type InitialSyncMetricAttrs = {
-    syncMode: InitialSyncMode;
-    copyFormat: CopyFormat;
-};
-export declare const COPY_METRIC_BATCH_BYTES: number;
-export declare function createCopyMetricBatcher(record: (bytes: number, chunks: number) => void): {
-    add(chunkBytes: number): void;
-    flush: () => void;
-};
-export declare function initialSyncCopyMetrics(attrs: InitialSyncMetricAttrs): {
-    add(chunkBytes: number): void;
-    flush: () => void;
-};
-export declare function getInitialDownloadState(lc: LogContext, sql: PostgresDB, spec: PublishedTableSpec, skipTotals: boolean): Promise<DownloadState>;
-export {};
-//# sourceMappingURL=initial-sync.d.ts.map

package/out/zero-cache/src/services/change-source/pg/initial-sync.d.ts.map

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

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

@@ -1,17 +0,0 @@
-export declare class BinaryReader {
-    #private;
-    constructor(b: Uint8Array);
-    readUint8(): number;
-    readInt16(): number;
-    readInt32(): number;
-    readString(): string;
-    decodeText(strBuf: Uint8Array): string;
-    read(n: number): Uint8Array<ArrayBufferLike>;
-    checkSize(n: number): void;
-    array<T>(length: number, fn: () => T): T[];
-    readLsn(): string | null;
-    readTime(): bigint;
-    readUint64(): bigint;
-    readUint32(): number;
-}
-//# sourceMappingURL=binary-reader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"binary-reader.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/logical-replication/binary-reader.ts"],"names":[],"mappings":"AAMA,qBAAa,YAAY;;IAIvB,YAAY,CAAC,EAAE,UAAU,EAExB;IAED,SAAS,WAIR;IAED,SAAS,WAIR;IAED,SAAS,WASR;IAED,UAAU,WAYT;IAED,UAAU,CAAC,MAAM,EAAE,UAAU,UAE5B;IAED,IAAI,CAAC,CAAC,EAAE,MAAM,+BAIb;IAED,SAAS,CAAC,CAAC,EAAE,MAAM,QAKlB;IAED,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAEzC;IAGD,OAAO,kBAWN;IAED,QAAQ,WAGP;IAED,UAAU,WAIT;IAED,UAAU,WAET;CACF"}

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

@@ -1,28 +0,0 @@
-export type TypeParser = (val: string) => unknown;
-import type { TypeParsers } from '../../../../db/pg-type-parser.ts';
-import type { Message, MessageRelation } from './pgoutput.types.ts';
-export declare class PgoutputParser {
-    #private;
-    _typeCache: Map<number, {
-        typeSchema: string;
-        typeName: string;
-    }>;
-    _relationCache: Map<number, MessageRelation>;
-    constructor(typeParsers: TypeParsers);
-    parse(buf: Buffer): Message;
-    private msgBegin;
-    private msgOrigin;
-    private msgType;
-    private msgRelation;
-    private readRelationReplicaIdentity;
-    private readRelationColumn;
-    private msgInsert;
-    private msgUpdate;
-    private msgDelete;
-    private readKeyTuple;
-    private readTuple;
-    private msgTruncate;
-    private msgMessage;
-    private msgCommit;
-}
-//# sourceMappingURL=pgoutput-parser.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pgoutput-parser.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/logical-replication/pgoutput-parser.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAElD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EACV,OAAO,EAOP,eAAe,EAKhB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,cAAc;;IACzB,UAAU;oBAAgC,MAAM;kBAAY,MAAM;OAAK;IACvE,cAAc,+BAAsC;IAIpD,YAAY,WAAW,EAAE,WAAW,EAEnC;IAMM,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CA4BjC;IAED,OAAO,CAAC,QAAQ;IAahB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,OAAO;IAWf,OAAO,CAAC,WAAW;IA4BnB,OAAO,CAAC,2BAA2B;IAkBnC,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,SAAS;IA6BjB,OAAO,CAAC,SAAS;IAsBjB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,SAAS;IAwCjB,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,SAAS;CASlB"}

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

@@ -1,76 +0,0 @@
-export type Message = MessageBegin | MessageCommit | MessageDelete | MessageInsert | MessageMessage | MessageOrigin | MessageRelation | MessageTruncate | MessageType | MessageUpdate;
-export interface MessageBegin {
-    tag: 'begin';
-    commitLsn: string | null;
-    commitTime: bigint;
-    xid: number;
-}
-export interface MessageCommit {
-    tag: 'commit';
-    flags: number;
-    commitLsn: string | null;
-    commitEndLsn: string | null;
-    commitTime: bigint;
-}
-export interface MessageDelete {
-    tag: 'delete';
-    relation: MessageRelation;
-    key: Record<string, any> | null;
-    old: Record<string, any> | null;
-}
-export interface MessageInsert {
-    tag: 'insert';
-    relation: MessageRelation;
-    new: Record<string, any>;
-}
-export interface MessageMessage {
-    tag: 'message';
-    flags: number;
-    transactional: boolean;
-    messageLsn: string | null;
-    prefix: string;
-    content: Uint8Array;
-}
-export interface MessageOrigin {
-    tag: 'origin';
-    originLsn: string | null;
-    originName: string;
-}
-export interface MessageRelation {
-    tag: 'relation';
-    relationOid: number;
-    schema: string;
-    name: string;
-    replicaIdentity: 'default' | 'nothing' | 'full' | 'index';
-    columns: RelationColumn[];
-    keyColumns: string[];
-}
-export interface RelationColumn {
-    name: string;
-    flags: number;
-    typeOid: number;
-    typeMod: number;
-    typeSchema: string | null;
-    typeName: string | null;
-    parser: (raw: any) => any;
-}
-export interface MessageTruncate {
-    tag: 'truncate';
-    cascade: boolean;
-    restartIdentity: boolean;
-    relations: MessageRelation[];
-}
-export interface MessageType {
-    tag: 'type';
-    typeOid: number;
-    typeSchema: string;
-    typeName: string;
-}
-export interface MessageUpdate {
-    tag: 'update';
-    relation: MessageRelation;
-    key: Record<string, any> | null;
-    old: Record<string, any> | null;
-    new: Record<string, any>;
-}
-//# sourceMappingURL=pgoutput.types.d.ts.map

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

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

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