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

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,14 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { NormalizedZeroConfig } from '../../config/normalize.ts';
-import { BackupMonitor } from './backup-monitor.ts';
-import type { ChangeStreamerService } from './change-streamer.ts';
-import { type BackupStateVerifier } from './litestream3-prometheus-poller.ts';
-export type BackupCleanupMonitorFactoryOptions = {
-    lc: LogContext;
-    config: NormalizedZeroConfig;
-    replicaFile: string;
-    changeStreamer: ChangeStreamerService;
-    verifyBackupState?: BackupStateVerifier | undefined;
-};
-export declare function createBackupCleanupMonitor({ lc, config, replicaFile, changeStreamer, 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;AAMpE,OAAO,EAAyB,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAEhE,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,cAAc,EAAE,qBAAqB,CAAC;IACtC,iBAAiB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,EACzC,EAAE,EACF,MAAM,EACN,WAAW,EACX,cAAc,EACd,iBAAiB,GAClB,EAAE,kCAAkC,GAAG,aAAa,CAyBpD"}

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

@@ -1,18 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Source } from '../../types/streams.ts';
-import type { SingletonService } from '../service.ts';
-import type { ChangeStreamerService } from './change-streamer.ts';
-export type BackedUpWatermark = {
-    watermark: string;
-    writeTimeMs?: number | undefined;
-    backupTimeMs: number;
-};
-export declare class BackupMonitor implements SingletonService {
-    #private;
-    readonly id = "backup-monitor";
-    constructor(lc: LogContext, watermarks: Source<BackedUpWatermark>, changeStreamer: ChangeStreamerService, replicaFile: string);
-    firstBackupReceived(): Promise<void>;
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=backup-monitor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backup-monitor.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,qBAAa,aAAc,YAAW,gBAAgB;;IACpD,QAAQ,CAAC,EAAE,oBAAoB;IAiB/B,YACE,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,CAAC,iBAAiB,CAAC,EACrC,cAAc,EAAE,qBAAqB,EACrC,WAAW,EAAE,MAAM,EAMpB;IAED,mBAAmB,kBAElB;IAEK,GAAG,kBA8BR;IAqDD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAGpB;CA+BF"}

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

@@ -1,98 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type PreSerialized } from '../../types/streams.ts';
-import type { WatermarkedChange } from './change-streamer.ts';
-import type { Subscriber } from './subscriber.ts';
-export type BroadcastReleaseMode = 'all-subscribers' | 'consensus-timeout';
-export type PreSerializedBatch = PreSerialized & {
-    readonly changes: readonly WatermarkedChange[];
-};
-export declare function isPreSerializedBatch(val: unknown): val is PreSerializedBatch;
-export declare function preSerializeBatch(changes: readonly WatermarkedChange[]): PreSerializedBatch;
-/**
- * Enables event-driven early release of a {@link Broadcast}. When provided and a
- * majority has acked, the broadcast schedules its own consensus-timeout release
- * proportional to how long the majority took to ack, instead of relying on the
- * Forwarder's periodic progress tick.
- */
-export type EarlyReleaseOptions = {
-    /** Time to wait, proportional to majority completion, before releasing. */
-    consensusTimeoutProportion: number;
-    /** Injectable timer, for deterministic testing. */
-    setTimeoutFn?: typeof setTimeout;
-    /** Injectable timer cancellation, for deterministic testing. */
-    clearTimeoutFn?: typeof clearTimeout;
-};
-/**
- * Initiates and tracks the progress of a change broadcasted to
- * a set of subscribers, implementing **consensus-based timeouts**
- * to effect short-term graceful degradation when a minority of
- * subscribers are behind.
- *
- * ### Background
- *
- * The purpose of flow control is to pull upstream replication changes
- * no faster than the rate they are processed by downstream subscribers
- * in the steady state. In the change-streamer, this is done by occasionally
- * waiting for ACKs from subscribers before continuing; without doing so,
- * I/O buffers fill up and cause the system to spend most of its time in GC.
- *
- * However, the naive algorithm of always waiting for all subscribers (e.g.
- * `Promise.all()`) can behave poorly in scenarios where subscribers
- * are imbalanced:
- * * New subscribers may have a backlog of changes to catch up with.
- *   Having all subscribers wait for the new subscriber to catch up results
- *   in delaying the entire application.
- * * Broken TCP connections similarly require all subscribers to wait until
- *   connection liveness checks kick in and disconnect the subscriber.
- *
- * A simplistic approach is to add a limit to the amount of time waiting for
- * subscribers, i.e. an ack timeout. However, deciding what this timeout
- * should be is non-trivial because of the heterogeneous nature of changes;
- * while most changes operate on single rows and are relatively predictable
- * in terms of running time, some changes are table-wide operations and can
- * legitimately take an arbitrary amount of time. In such scenarios, a
- * timeout that is too short can stop progress on replication altogether.
- *
- * ### Consensus-based Timeout Algorithm
- *
- * To address these shortcomings, a "consensus-based timeout" algorithm is
- * used:
- * * Wait for more than half of the subscribers to finish. (In
- *   case of a single node, or the case of one replication-manager
- *   and one view-syncer, this reduces to waiting for all subscribers.)
- * * Once more than half of the subscribers have finished, proceed after
- *   the configured timeout, proportional to the time it took for the
- *   majority of subscribers to ack, even if not all subscribers have
- *   finished.
- *
- * In other words, the subscribers themselves are used to determine the
- * timeout of each batch of changes; the majority determines this when
- * they complete, upon which a timeout is logically started.
- *
- * In the common case, the remaining subscribers finish soon afterward and
- * the timeout never elapses. However, in pathological cases where a minority
- * of subscribers have a disproportionate amount of load, some will still
- * be processing (or otherwise unresponsive). These subscribers are given
- * a bounded amount of time to catch up at each flushed batch, up to the
- * timeout interval. This guarantees eventual catchup because the
- * subscribers with a backlog of changes necessarily have a higher
- * processing rate than the subscribers that finished (and are made to wait).
- */
-export declare class Broadcast {
-    #private;
-    /**
-     * Sends the change to the subscribers without the tracking machinery.
-     * This is suitable for fire-and-forget (i.e. pipelined) sends.
-     */
-    static withoutTracking(subscribers: Iterable<Subscriber>, change: WatermarkedChange | readonly WatermarkedChange[]): void;
-    /**
-     * Broadcasts the `change` to the `subscribers` and tracks their
-     * completion.
-     */
-    constructor(lc: LogContext, subscribers: Iterable<Subscriber>, change: WatermarkedChange | readonly WatermarkedChange[], earlyRelease?: EarlyReleaseOptions);
-    get isDone(): boolean;
-    get done(): Promise<void>;
-    get releaseMode(): BroadcastReleaseMode;
-    logSlowRequests(now: number): void;
-}
-//# sourceMappingURL=broadcast.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAkB,KAAK,aAAa,EAAC,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAEhD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAE3E,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAChD,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAE5E;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,iBAAiB,EAAE,GACpC,kBAAkB,CAYpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAC;IACnC,mDAAmD;IACnD,YAAY,CAAC,EAAE,OAAO,UAAU,CAAC;IACjC,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,YAAY,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,qBAAa,SAAS;;IACpB;;;OAGG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,QAOzD;IA0BD;;;OAGG;IACH,YACE,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,EACxD,YAAY,CAAC,EAAE,mBAAmB,EA+BnC;IAwDD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAExB;IAED,IAAI,WAAW,IAAI,oBAAoB,CAEtC;IAED,eAAe,CAAC,GAAG,EAAE,MAAM,QAa1B;CAiBF"}

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

@@ -1,34 +0,0 @@
-import type { ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
-import type { ChangeTag, WatermarkedChange } from './change-streamer.ts';
-export type ChangeLogEntry = {
-    watermark: string;
-    tag: string;
-    change: string;
-};
-export type SerializedChangeStreamData = {
-    /** The canonical downstream representation forwarded to subscribers. */
-    readonly json: string;
-    /** The already-serialized change tuple element stored in change logs. */
-    readonly change: string;
-};
-/**
- * Serializes a data-plane message and its stored change payload in one pass.
- *
- * Change logs retain only the second tuple element for backwards
- * compatibility. Serializing that element first avoids stringifying the full
- * message and then copying the payload back out of the resulting string on the
- * replication hot path.
- */
-export declare function serializeChangeStreamDataWithChange(data: ChangeStreamData): SerializedChangeStreamData;
-/** Serializes a data-plane message to the canonical downstream JSON form. */
-export declare function serializeChangeStreamData(data: ChangeStreamData): string;
-/**
- * Extracts the second tuple element for callers that only have the canonical
- * downstream JSON. The live write path uses
- * {@link serializeChangeStreamDataWithChange} and does not scan or copy the
- * completed message.
- */
-export declare function extractChangeSubstring(streamMessageJSON: string, tag: ChangeTag | undefined): string;
-/** Reconstructs the canonical downstream JSON around a stored change. */
-export declare function reconstructWatermarkedChange(entry: ChangeLogEntry): WatermarkedChange;
-//# sourceMappingURL=change-log-codec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-codec.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-codec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAC,SAAS,EAAE,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAEvE,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,gBAAgB,GACrB,0BAA0B,CAc5B;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,MAAM,EACzB,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,MAAM,CAkBR;AAED,yEAAyE;AACzE,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,cAAc,GACpB,iBAAiB,CAqBnB"}

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

@@ -1,34 +0,0 @@
-/**
- * Pure building blocks for comparing catchup output between the Postgres and
- * SQLite change logs: how to reduce a catchup range to a single comparable
- * digest. Which transactions to sample is `isSampledForShard`, in
- * `shard-sampling.ts`.
- *
- * Nothing here touches either store. The comparator service supplies the
- * batches.
- */
-import type { WatermarkedChange } from './change-streamer.ts';
-export type CatchupRangeDigest = {
-    readonly digest: string;
-    readonly rows: number;
-    /** Change text hashed. This is the payload cost of the range. */
-    readonly bytes: number;
-    /** A row or byte limit was reached before the closing commit. */
-    readonly limitReached: boolean;
-};
-/**
- * Builds one ordered digest for a catchup range.
- *
- * The row position makes missing, extra, changed, and reordered rows change the digest.
- * The digest omits `precommit` because a commit already includes its watermark.
- *
- * The change text is hashed as stored. Both logs write the same
- * `extractChangeSubstring` output, and the Postgres column is `json`, which
- * keeps the input text exactly, so the two sides are byte-comparable without
- * reparsing. Comparing the stored text also catches an encoding difference
- * that a semantic comparison would hide.
- *
- * The read stops at `maxRows` or at `maxBytes`, whichever comes first.
- */
-export declare function digestCatchupRange(batches: AsyncIterable<readonly WatermarkedChange[]>, throughWatermark: string, maxRows: number, maxBytes: number): Promise<CatchupRangeDigest>;
-//# sourceMappingURL=change-log-compare-digest.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-compare-digest.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-compare-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,CAAC,SAAS,iBAAiB,EAAE,CAAC,EACpD,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,kBAAkB,CAAC,CAsC7B"}

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

@@ -1,158 +0,0 @@
-/**
- * Where a stream connection's initialization parameters come from.
- *
- * A change-streamer starts a stream from three things read at one position: the
- * watermark to resume at, the {@link BackfillRequest}s to hand the change
- * source, and the cookie set those requests were derived from. Postgres has
- * always supplied all three (`Storer.getStartStreamInitializationParameters()`).
- * The point of this workstream is that a restored replica can supply them
- * instead, which is what lets the `cdc` schema be decommissioned.
- *
- * This is the two-source stage. Both are computed on every stream connection,
- * compared, and Postgres's is used — so the replica-derived path runs in
- * production, at full rate, before anything depends on it. The flip is
- * `initFromPgChangeLog: false`, not a rewrite.
- *
- * The shape is {@link UpstreamAcker}'s, deliberately: two stores, one output, a
- * flag per store, and the Postgres flag carrying the marker that retires it.
- * That class solved the identical problem for upstream ACKs earlier in this
- * workstream.
- *
- * ### Why the comparison is a fold and not an equality
- *
- * The replica is a subscriber downstream of the change-streamer's write loop,
- * so its state version trails the log's head by however long the replicator is
- * behind. A raw difference between the two cookie sets is therefore the normal
- * case and says nothing. What is checked instead is that the replica's set,
- * carried forward over exactly the schema changes the log holds in the interval,
- * equals Postgres's set at Postgres's watermark. The log holds precisely those
- * transactions, schema changes are rare, and the check is exact rather than
- * approximate — so it also happens to be the strongest available test of the
- * premise that three interpreters of one fold agree.
- */
-import type { LogContext } from '@rocicorp/logger';
-import { Database } from '../../../../zqlite/src/db.ts';
-import type { BackfillRequest } from '../change-source/protocol/current/upstream.ts';
-import { type CookieSet } from '../replicator/change-log-cookies.ts';
-import { type ChangeLogResumePoint } from '../replicator/change-log-db.ts';
-/** Everything one stream connection starts from, read at one position. */
-export type InitializationParameters = {
-    readonly lastWatermark: string;
-    readonly backfillRequests: BackfillRequest[];
-    readonly cookies: CookieSet;
-};
-/**
- * - `equal` — the two stores were at the same watermark and held the same
- *   cookies. Nothing had to be folded, which is the strongest of the four.
- * - `equal-after-fold` — the replica trailed, and carrying its set forward over
- *   the log's schema changes in the interval reproduced Postgres's exactly.
- *   The expected steady-state result.
- * - `divergent` — the two disagree at the same position. Alert; investigate
- *   individually.
- * - `inconclusive` — the log does not span the interval, so the fold cannot be
- *   performed. Routine on a cold log, and not a finding.
- * - `error` — the comparison itself failed: the replica could not be read, or
- *   the fold threw. Not one of the four classifications, because it is a
- *   statement about this process rather than about the two stores. Kept
- *   separate rather than folded into `inconclusive` so that a change-streamer
- *   that has silently stopped being able to read its replica is visible before
- *   that read becomes the only source.
- */
-export type InitComparisonResult = 'equal' | 'equal-after-fold' | 'divergent' | 'inconclusive' | 'error';
-export type ChangeLogInitializerSources = {
-    /** `Storer.getStartStreamInitializationParameters()`. */
-    readonly pgChangeLog: () => Promise<InitializationParameters>;
-    /** Typically {@link replicaInitializationSource}. */
-    readonly replica: () => InitializationParameters;
-    /**
-     * Reconciles the SQLite change log and returns its current resume point.
-     *
-     * When `resumeFrom` is present, it supplies the resume point. Otherwise, a
-     * valid log uses its own head. A new or invalid log uses `seed`.
-     *
-     * Returns `undefined` when the writer is disabled or unavailable.
-     */
-    readonly reconcileChangeLog: (resumeFrom: ChangeLogResumePoint | undefined, seed: () => ChangeLogResumePoint) => ChangeLogResumePoint | undefined;
-    /**
-     * The change log, for the fold. `undefined` before the stream loop's first
-     * reconcile has created it, and again once the writer has failed soft and
-     * deleted it — both of which make the comparison `inconclusive` rather than
-     * an error, since neither says anything about the two stores.
-     */
-    readonly changeLog: () => Database | undefined;
-    /**
-     * Re-initializes the Postgres change log from the replica's resume point
-     * (taking ownership of it) if it does not contain all of the replica's
-     * changes, re-checking under lock. Typically
-     * `Storer.reinitializeFromReplica()`.
-     *
-     * Supplied only when the change log's head is behind the position of the
-     * replication slot from which replication resumes, i.e. when it may be
-     * missing transactions that the slot will not stream. Otherwise, a replica
-     * that is ahead of the change log (as changes are forwarded before they are
-     * stored) is caught up by the change stream, which resumes from the change
-     * log's head.
-     */
-    readonly reinitializePgChangeLog?: ((params: {
-        watermark: string;
-        cookies: CookieSet;
-    }) => Promise<'reinitialized' | 'maintained'>) | undefined;
-};
-type Opts = {
-    /**
-     * When true, Postgres supplies the resume point and the cookies for a new
-     * change log.
-     *
-     * When false, a valid log resumes from its own head. The replica supplies the
-     * resume point for a new or invalid log.
-     */
-    readonly initFromPgChangeLog: boolean;
-    /**
-     * Derive the parameters from the replica. When Postgres is enabled, these
-     * parameters are used only for comparison.
-     *
-     * When Postgres is disabled, the replica supplies the seed and the fallback
-     * resume point.
-     */
-    readonly initFromReplica: boolean;
-};
-export declare class ChangeLogInitializer {
-    #private;
-    constructor(lc: LogContext, { initFromPgChangeLog, initFromReplica }: Opts, sources: ChangeLogInitializerSources);
-    /**
-     * Returns the comparison result from the most recent {@link initialize}
-     * call. Returns `undefined` when that call used only one source.
-     *
-     * Tests and metrics use this result. It does not affect initialization.
-     */
-    lastComparison(): InitComparisonResult | undefined;
-    /**
-     * Returns the initialization parameters for one stream connection after it
-     * reconciles the change log.
-     *
-     * The selected source determines how reconciliation works. Keeping both
-     * operations here hides that choice from the caller.
-     */
-    initialize(): Promise<InitializationParameters>;
-}
-/**
- * Reads the replica's initialization parameters in one snapshot, which is
- * invariant 15 on the replica side: the state version and the cookies are only
- * meaningful together.
- */
-export declare function readReplicaInitializationParameters(db: Database): InitializationParameters;
-/**
- * The replica source for {@link ChangeLogInitializer}, opening and closing the
- * file per stream connection rather than holding a handle on a database another
- * process owns.
- *
- * The handle is read-only, which is invariant 19 stated in the API: the
- * replica's cookie tables are written by the change-processor and by nothing
- * else. Note that a read-only SQLite connection still needs to attach the
- * WAL's `-shm`, so this can fail if it opens at a moment when no writer holds
- * the replica; that surfaces as the `error` classification, which is the point
- * of running the path under observation before anything depends on it.
- */
-export declare function replicaInitializationSource(lc: LogContext, replicaFile: string): () => InitializationParameters;
-export {};
-//# sourceMappingURL=change-log-initializer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-initializer.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-initializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAIjD,OAAO,EAAC,QAAQ,EAAC,MAAM,8BAA8B,CAAC;AAKtD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+CAA+C,CAAC;AACnF,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,gCAAgC,CAAC;AAQxC,0EAA0E;AAC1E,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,oBAAoB,GAC5B,OAAO,GACP,kBAAkB,GAClB,WAAW,GACX,cAAc,GACd,OAAO,CAAC;AAEZ,MAAM,MAAM,2BAA2B,GAAG;IACxC,yDAAyD;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC9D,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,wBAAwB,CAAC;IACjD;;;;;;;OAOG;IACH,QAAQ,CAAC,kBAAkB,EAAE,CAC3B,UAAU,EAAE,oBAAoB,GAAG,SAAS,EAC5C,IAAI,EAAE,MAAM,oBAAoB,KAC7B,oBAAoB,GAAG,SAAS,CAAC;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,QAAQ,GAAG,SAAS,CAAC;IAC/C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAC7B,CAAC,CAAC,MAAM,EAAE;QACR,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,SAAS,CAAC;KACpB,KAAK,OAAO,CAAC,eAAe,GAAG,YAAY,CAAC,CAAC,GAC9C,SAAS,CAAC;CACf,CAAC;AAEF,KAAK,IAAI,GAAG;IACV;;;;;;OAMG;IAEH,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAcF,qBAAa,oBAAoB;;IAqB/B,YACE,EAAE,EAAE,UAAU,EACd,EAAC,mBAAmB,EAAE,eAAe,EAAC,EAAE,IAAI,EAC5C,OAAO,EAAE,2BAA2B,EAUrC;IAED;;;;;OAKG;IACH,cAAc,IAAI,oBAAoB,GAAG,SAAS,CAEjD;IAED;;;;;;OAMG;IACG,UAAU,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAqCpD;CA2JF;AAUD;;;;GAIG;AACH,wBAAgB,mCAAmC,CACjD,EAAE,EAAE,QAAQ,GACX,wBAAwB,CAc1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,MAAM,GAClB,MAAM,wBAAwB,CAahC"}

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

@@ -1,19 +0,0 @@
-export type ChangeLogHashRow = {
-    readonly watermark: string;
-    readonly pos: number;
-    readonly tag: string;
-    readonly change: string;
-    readonly precommit: string | null;
-};
-/**
- * Computes a stable digest over the fields shared by the Postgres and SQLite
- * change logs. Values are length-prefixed so different field boundaries cannot
- * produce the same byte stream.
- */
-export declare class ChangeLogTransactionHasher {
-    #private;
-    constructor();
-    add(row: ChangeLogHashRow): void;
-    digest(): string;
-}
-//# sourceMappingURL=change-log-transaction-hash.d.ts.map