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

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

@@ -1,57 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Source } from '../../types/streams.ts';
-import type { SingletonService } from '../service.ts';
-export type BackedUpWatermark = {
-    watermark: string;
-    writeTimeMs?: number | undefined;
-    backupTimeMs: number;
-};
-/**
- * Determines which watermarks of the replica are backed up, by whatever means
- * the backup (or its absence) allows.
- */
-export interface BackupPoller {
-    /**
-     * Starts polling, returning the stream of backed-up watermarks. Must only
-     * be called once.
-     */
-    start(): Source<BackedUpWatermark>;
-    /**
-     * Requests that the replica be backed up through `watermark` promptly,
-     * rather than at the poller's regular cadence, once the replica has reached
-     * it. The resulting watermark is emitted on the stream as usual. Pollers
-     * that cannot initiate backups do not implement this.
-     */
-    requestSync?(watermark: string): void;
-}
-/**
- * The interface through which the change-streamer consumes backed-up
- * watermarks and requests prompt backups (see {@link BackupMonitor}).
- */
-export type BackupSource = Pick<BackupMonitor, 'backups' | 'requestSync'>;
-/**
- * Relays the watermarks backed up by a {@link BackupPoller} to the
- * change-streamer, which consumes them (see {@link backups}) and requests
- * prompt backups (see {@link requestSync}) as needed.
- */
-export declare class BackupMonitor implements SingletonService {
-    #private;
-    readonly id = "backup-monitor";
-    constructor(lc: LogContext, poller: BackupPoller, replicaFile: string);
-    firstBackupReceived(): Promise<void>;
-    /**
-     * The stream of backed-up watermarks, each later than the last, coalesced
-     * to the latest one that has not been consumed. It ends when the monitor
-     * stops.
-     */
-    backups(): Source<BackedUpWatermark>;
-    /**
-     * Requests that the replica be backed up through `watermark` promptly, if
-     * the poller supports it (see {@link BackupPoller.requestSync}). A no-op
-     * unless the monitor is running.
-     */
-    requestSync(watermark: string): 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;AAEnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAEpD,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;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,IAAI,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,WAAW,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,aAAa,CAAC,CAAC;AAE1E;;;;GAIG;AACH,qBAAa,aAAc,YAAW,gBAAgB;;IACpD,QAAQ,CAAC,EAAE,oBAAoB;IAwB/B,YAAY,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAIpE;IAED,mBAAmB,kBAElB;IAED;;;;OAIG;IACH,OAAO,IAAI,MAAM,CAAC,iBAAiB,CAAC,CAEnC;IAED;;;;OAIG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,QAY5B;IAEK,GAAG,kBAsCR;IAqDD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAKpB;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(watermark: string, entryTag: string, change: string): 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,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,iBAAiB,CAoBnB"}

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-transaction-hash.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-transaction-hash.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,0BAA0B;;IAGrC,cAGC;IAED,GAAG,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAW/B;IAED,MAAM,IAAI,MAAM,CAEf;CACF"}

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

@@ -1,78 +0,0 @@
-import type { IncomingMessage } from 'node:http';
-import type { LogContext } from '@rocicorp/logger';
-import type { NormalizedZeroConfig } from '../../config/normalize.ts';
-import { type Worker } from '../../types/processes.ts';
-import { type ShardID } from '../../types/shards.ts';
-import { type Sized, type Source } from '../../types/streams.ts';
-import { Subscription } from '../../types/subscription.ts';
-import { HttpService, type Options as HttpOptions } from '../http-service.ts';
-import { type ChangeStreamer, type ChangeStreamerService, type SubscriberContext } from './change-streamer.ts';
-import { type LocalReplica, type SnapshotStatus, type SubscribeDownstream, type SubscribeUpstream } from './subscribe.ts';
-type Options = HttpOptions & {
-    startupDelayMs: number;
-    config?: Pick<NormalizedZeroConfig, 'adminPassword' | 'operatorPassword'> | undefined;
-    getProfileWorker?: (() => Promise<Worker>) | undefined;
-};
-export declare class ChangeStreamerHttpServer extends HttpService {
-    #private;
-    readonly id = "change-streamer-http-server";
-    constructor(lc: LogContext, opts: Options, parent: Worker, changeStreamer: ChangeStreamerService);
-    protected _onStart(): void;
-    /**
-     * Signals (drainable) subscribers to switch over to another
-     * replication-manager, resolving when they have disconnected. Subscribers
-     * continue to be served in the meantime, but new connections (e.g.
-     * switchover attempts, reconnects, and snapshot reservations) are refused,
-     * so that they are routed to another replication-manager.
-     */
-    drain(): Promise<void>;
-    protected _onStop(): Promise<void>;
-}
-export interface SnapshotReserver {
-    reserveSnapshot(taskID: string, localReplica?: LocalReplica | undefined): Promise<{
-        reserved: SnapshotStatus;
-        followup: ReservationFollowup;
-    }>;
-}
-export interface SubscriptionStarter {
-    subscribe(ctx: SubscriberContext): Promise<Source<Sized<SubscribeDownstream>>>;
-}
-export interface ReservationFollowup extends SubscriptionStarter {
-    /**
-     * A signal to indicate that the followup is no longer valid (i.e. the
-     * connection to the reserving task has been severed).
-     */
-    readonly signal: AbortSignal;
-    /**
-     * Abandons the reservation without subscribing, closing the connection that
-     * was held open to pin the change-log floor. Used when the caller cannot
-     * proceed to `subscribe()` (e.g. process shutdown while a restore is in
-     * progress) and must not leave the reservation's connection open forever.
-     */
-    cancel(reason?: Error): void;
-}
-export declare class ChangeStreamerHttpClient implements ChangeStreamer, SnapshotReserver, SubscriptionStarter {
-    #private;
-    constructor(lc: LogContext, shardID: ShardID, changeDB: string, changeStreamerURI: string | undefined);
-    reserveSnapshot(taskID: string, localReplica?: LocalReplica | undefined): Promise<{
-        reserved: SnapshotStatus;
-        followup: ReservationFollowup;
-    }>;
-    subscribe(ctx: SubscriberContext): Promise<Source<Sized<SubscribeDownstream>>>;
-    /**
-     * Opens a merged v7 `/subscribe` connection (see subscribe.ts). Returns the
-     * inbound change/reservation stream and an `outbound` sink into which the
-     * caller pushes the `reserve-snapshot` / `start-subscription` control
-     * messages that drive the connection's phases. The single connection spans
-     * the reservation, backup restore, and subscription, so the reserving
-     * replication-manager is the one that serves the subscription.
-     */
-    connect(taskID: string): Promise<{
-        instream: Source<Sized<SubscribeDownstream>>;
-        outbound: Subscription<SubscribeUpstream>;
-    }>;
-}
-type RequestHeaders = Pick<IncomingMessage, 'url' | 'headers'>;
-export declare function getSubscriberContext(req: RequestHeaders): SubscriberContext;
-export {};
-//# sourceMappingURL=change-streamer-http.d.ts.map

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

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