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

package/out/zero-cache/src/services/mutagen/pusher.d.ts

@@ -1,63 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Downstream } from '../../../../zero-protocol/src/down.ts';
-import type { MutationID } from '../../../../zero-protocol/src/mutation-id.ts';
-import { type PushBody } from '../../../../zero-protocol/src/push.ts';
-import { type ZeroConfig } from '../../config/zero-config.ts';
-import type { Source } from '../../types/streams.ts';
-import type { HandlerResult, StreamResult } from '../../workers/connection.ts';
-import type { RefCountedService, Service } from '../service.ts';
-import type { ConnectionContext, ConnectionContextManager, ConnectionSelector } from '../view-syncer/connection-context-manager.ts';
-export interface Pusher extends RefCountedService {
-    initConnection(selector: ConnectionSelector): Source<Downstream>;
-    enqueuePush(selector: ConnectionSelector, push: PushBody): HandlerResult;
-    ackMutationResponses(requester: ConnectionSelector, upToID: MutationID): Promise<void>;
-    deleteClientMutations(requester: ConnectionSelector, clientIDs: string[]): Promise<void>;
-}
-type Config = Pick<ZeroConfig, 'app' | 'shard'>;
-/**
- * Receives push messages from zero-client and forwards
- * them the the user's API server.
- *
- * If the user's API server is taking too long to process
- * the push, the PusherService will add the push to a queue
- * and send pushes in bulk the next time the user's API server
- * is available.
- *
- * - One PusherService exists per client group.
- * - Mutations for a given client are always sent in-order
- * - Mutations for different clients in the same group may be interleaved
- */
-export declare class PusherService implements Service, Pusher {
-    #private;
-    readonly id: string;
-    constructor(appConfig: Config, lc: LogContext, clientGroupID: string, connContextManager: ConnectionContextManager);
-    initConnection(selector: ConnectionSelector): Source<Downstream>;
-    enqueuePush(selector: ConnectionSelector, push: PushBody): Exclude<HandlerResult, StreamResult>;
-    ackMutationResponses(requester: ConnectionSelector, upToID: MutationID): Promise<void>;
-    /**
-     * Bulk cleanup is routed through the requester's push context.
-     *
-     * This assumes the client group shares a compatible push endpoint/auth
-     * context.
-     */
-    deleteClientMutations(requester: ConnectionSelector, clientIDs: string[]): Promise<void>;
-    ref(): void;
-    unref(): void;
-    hasRefs(): boolean;
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}
-type PusherEntry = {
-    push: PushBody;
-    connCtx: ConnectionContext;
-};
-type PusherEntryOrStop = PusherEntry | 'stop';
-/**
- * Pushes for different clients, sockets, or auth revisions could be interleaved.
- *
- * In order to batch safely, we only combine pushes from the same
- * clientID/wsID/revision snapshot.
- */
-export declare function combinePushes(entries: readonly (PusherEntryOrStop | undefined)[]): [PusherEntry[], boolean];
-export {};
-//# sourceMappingURL=pusher.d.ts.map

package/out/zero-cache/src/services/mutagen/pusher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pusher.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/mutagen/pusher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAOjD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,uCAAuC,CAAC;AAYtE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8CAA8C,CAAC;AAG7E,OAAO,EAAC,KAAK,QAAQ,EAAC,MAAM,uCAAuC,CAAC;AAEpE,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,6BAA6B,CAAC;AAK5D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAEnD,OAAO,KAAK,EAAC,aAAa,EAAE,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAC7E,OAAO,KAAK,EAAC,iBAAiB,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EACV,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,8CAA8C,CAAC;AAEtD,MAAM,WAAW,MAAO,SAAQ,iBAAiB;IAC/C,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACjE,WAAW,CAAC,QAAQ,EAAE,kBAAkB,EAAE,IAAI,EAAE,QAAQ,GAAG,aAAa,CAAC;IACzE,oBAAoB,CAClB,SAAS,EAAE,kBAAkB,EAC7B,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,qBAAqB,CACnB,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAED,KAAK,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,OAAO,CAAC,CAAC;AAEhD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,OAAO,EAAE,MAAM;;IACnD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAUpB,YACE,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,UAAU,EACd,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,wBAAwB,EAa7C;IAED,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAAC,UAAU,CAAC,CAE/D;IAED,WAAW,CACT,QAAQ,EAAE,kBAAkB,EAC5B,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,aAAa,EAAE,YAAY,CAAC,CAStC;IAEK,oBAAoB,CACxB,SAAS,EAAE,kBAAkB,EAC7B,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CA8Cf;IAED;;;;;OAKG;IACG,qBAAqB,CACzB,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,IAAI,CAAC,CAiDf;IAED,GAAG,SAGF;IAED,KAAK,SAMJ;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAGnB;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAOpB;CACF;AAED,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AACF,KAAK,iBAAiB,GAAG,WAAW,GAAG,MAAM,CAAC;AAqW9C;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,EAAE,GAClD,CAAC,WAAW,EAAE,EAAE,OAAO,CAAC,CAgC1B"}

package/out/zero-cache/src/services/replicator/change-log-db.d.ts

@@ -1,368 +0,0 @@
-/**
- * The change log lives in its own SQLite database, `${replicaFile}-change-log`,
- * rather than in the replica file. It is a catchup cache: everything it holds is
- * either already durable in the replica's litestream backup or re-derivable from
- * the upstream replication slot, so it is deliberately excluded from the backup
- * and is never a source of truth.
- *
- * The change-streamer writes it, from the stream loop that fans changes out to
- * subscribers, and commits it before forwarding each transaction's `commit`
- * message. Its head is therefore always at or above the watermark the stream
- * would resume from, which is what {@link reconcileChangeLog} anchors on.
- *
- * Beside the buffer it holds the log's *cookie jar* — the backfill progress
- * state folded up to the same head. That is `change-log-cookies.ts`; this file
- * owns its tables' lifecycle, because a cookie set is only meaningful paired
- * with the watermark it was folded to, and so must be created, dropped, and —
- * whenever reconciliation moves the head — replaced with the anchor's, all with
- * the buffer rather than beside it.
- *
- * Because it is disposable, it has no migration framework. Any inconsistency —
- * a schema change, a leftover file from a different replica, a gap left by a
- * crash or by running with the writer disabled, a corrupt file — is resolved by
- * {@link reconcileChangeLog} and {@link openChangeLogDBForWriting}, which
- * truncate a bounded suffix or replace and reseed the log at the resume
- * watermark. The worst outcome is a `too-old` for a lagging subscriber; a
- * silently delivered gap is not reachable.
- *
- * Disk sizing: a task that writes the log needs room for the replica *plus* the
- * retained change stream — the log's main file, its wal2 sidecars, and pages a
- * purge has freed but not yet returned to the OS. The change-streamer schedules
- * purges against the same floor as the PG change log, so retention is bounded
- * by the confirmed backup watermark ANDed with the minimum retention window —
- * a function of the backup interval, not a constant: 15–30+ minutes behind an
- * RMv1 sync interval, ~60 seconds once litestream v5 backs up every 15–30 s.
- * A held snapshot reservation pins retention unboundedly for its duration, so
- * peak retained bytes is set by the slowest concurrent restore rather than by
- * the retention setting — size disk and alerts on that. The log is excluded
- * from the litestream backup, so this is local disk only and never S3.
- */
-import type { LogContext } from '@rocicorp/logger';
-import { Database } from '../../../../zqlite/src/db.ts';
-import { type CookieSet } from './change-log-cookies.ts';
-/**
- * Bumped whenever the change-log database's schema changes. Since the file is a
- * cache, a mismatch costs one reseed rather than a migration.
- *
- * v2 re-homed the writer to the change-streamer: the log anchors on the
- * watermark its stream connection resumes from rather than on the replica's
- * state version, and its meta row carries the replica's identity triple plus
- * the seed point.
- *
- * v3 added the cookie tables (see `change-log-cookies.ts`), i.e. the log's
- * second job. The reseed it costs on upgrade buys one retention window of
- * catchup reach on a log nothing reads yet.
- *
- * v4 stores each row's tag and estimated retained bytes alongside its JSON.
- * Readers can now filter without parsing arbitrary row payloads, and
- * reconciliation can bound truncation by bytes as well as rows.
- *
- * `auto_vacuum = INCREMENTAL` arrived within v2, deliberately without a bump:
- * it is a file-header property rather than a schema change, and the reseed a
- * version mismatch triggers cannot enable it (see
- * {@link applyChangeLogPragmas}), so {@link openChangeLogDBForWriting} guards
- * on the pragma itself instead of on this number.
- */
-export declare const CHANGE_LOG_DB_SCHEMA_VERSION = 4;
-export declare const CHANGE_LOG_STREAM_TABLE = "_zero.changeLogStream";
-export declare const CHANGE_LOG_STREAM_WRITE_TIME_INDEX = "_zero.changeLogStream_writeTimeMs";
-/**
- * Estimates the retained payload size of a stream row. This deliberately does
- * not claim to measure SQLite b-tree/page overhead; it is stable across the
- * write path, reconciliation, and the startup scan used by observability.
- */
-export declare function estimateChangeLogStreamRowBytes(watermark: string, tag: string, change: string, precommit?: string, hasWriteTime?: boolean): number;
-export declare const CREATE_CHANGE_LOG_STREAM_SCHEMA = "\n  CREATE TABLE \"_zero.changeLogStream\" (\n    \"watermark\"      TEXT NOT NULL,\n    \"pos\"            INTEGER NOT NULL,\n    \"tag\"            TEXT NOT NULL,\n    \"estimatedBytes\"  INTEGER NOT NULL,\n    \"change\"          TEXT NOT NULL,\n    \"precommit\"       TEXT,\n    \"writeTimeMs\"     INTEGER,\n    PRIMARY KEY (\"watermark\", \"pos\")\n  );\n\n  CREATE INDEX \"_zero.changeLogStream_writeTimeMs\"\n    ON \"_zero.changeLogStream\" (\"writeTimeMs\", \"watermark\")\n    WHERE \"writeTimeMs\" IS NOT NULL;\n";
-export declare const CHANGE_LOG_META_TABLE = "_zero.changeLogMeta";
-/**
- * `${replicaFile}-change-log`, matching the `-serving-copy` convention.
- *
- * The name outlives the writer's move into the change-streamer: the
- * change-streamer derives the path from the replica file it owns, so renaming
- * would save no plumbing and would orphan the old file on every existing
- * volume, where nothing would delete it.
- *
- * Its `-wal` / `-wal2` / `-shm` sidecars are suffixes of *this* name, so they
- * never collide with the replica's own sidecars.
- */
-export declare function changeLogFileName(replicaFile: string): string;
-/**
- * Removes the change-log database and its `-wal` / `-wal2` / `-shm` sidecars.
- * Safe to call when the file does not exist.
- */
-export declare function deleteChangeLogDB(replicaFile: string): void;
-/**
- * Which replica the log's contents belong to.
- *
- * `generation` is RMv1's `replicaVersion`: the version at which initial sync
- * copied every row. It is shared by every sibling of a forked replica, which is
- * why it cannot be the whole of the identity under RMv2 — `epoch` and
- * `replicaID` are what distinguish two siblings' logs. Both are `null` until
- * RMv2 supplies them, and a `null` matches only another `null`, so a log
- * written before they exist is still recognized as this replica's.
- */
-export type ChangeLogIdentity = {
-    readonly epoch: string | null;
-    readonly generation: string;
-    readonly replicaID: string | null;
-};
-/**
- * Where the stream connection resumes, and everything the log's state at that
- * position consists of.
- *
- * The two fields travel together because a cookie set is only meaningful paired
- * with the watermark it was folded up to (invariant 15). They are read from one
- * store, in one snapshot: `Storer.getStartStreamInitializationParameters()`
- * reads both from Postgres in a single REPEATABLE READ transaction. Pairing one
- * store's cookies with another's watermark would silently drop every backfill
- * that completed in the interval, and those rows are unrecoverable — backfill
- * transactions are synthesized by the change source rather than replayed from
- * the slot.
- */
-export type ChangeLogResumePoint = {
-    /**
-     * The watermark this stream connection resumes from. The log's own head is
-     * measured against it, and a reseed seeds a synthetic transaction at it.
-     *
-     * Deliberately *not* "the replica's state version": after the writer moved to
-     * the change-streamer, the canonical replicator is a subscriber downstream of
-     * the write loop, so its state version is a consequence of this log rather
-     * than a constraint on it.
-     */
-    readonly resumeWatermark: string;
-    /**
-     * The cookie set that belongs to {@link resumeWatermark}. Any reconciliation
-     * that moves the head invalidates the set the log was holding — the cookies
-     * are unversioned point-in-time state, and truncating the stream above `W`
-     * does not roll them back to `W` — so the same transaction installs this one
-     * in its place (invariant 17).
-     *
-     * Postgres supplies it while it remains the store the stream resumes from. At
-     * the C5 flip the log's own head *is* the resume point, phantoms cannot
-     * exist, and both this field and the truncate-above path become dead code.
-     */
-    readonly cookies: CookieSet;
-};
-/**
- * What the log is reconciled against. Reconciliation runs once per stream
- * connection, since every reconnect can re-read a different resume point.
- */
-export type ChangeLogAnchor = ChangeLogResumePoint & {
-    readonly identity: ChangeLogIdentity;
-    /**
-     * The change-streamer's clock, at reconciliation time. Supplied rather than
-     * read inline so that tests control it. Used for `seededAtMs` and for the
-     * seed transaction's `writeTimeMs`, which is what the purger's time floor
-     * measures.
-     */
-    readonly nowMs: number;
-};
-/** The meta row, i.e. everything the log records about itself. */
-export type ChangeLogMeta = ChangeLogIdentity & {
-    readonly schemaVersion: number;
-    readonly seededAtMs: number;
-    readonly seedWatermark: string;
-};
-/**
- * Opens the change-log database beside `replicaFile`.
- *
- * A writable handle creates the file if it is absent; a `readonly` handle
- * throws, which is the normal state for a change-streamer whose writer is
- * disabled. Pragmas are the caller's responsibility, since only the writer sets
- * the persistent ones.
- */
-export declare function openChangeLogDB(lc: LogContext, replicaFile: string, opts: {
-    readonly: boolean;
-}): Database;
-/**
- * Configures the change-log database, which the change-streamer's writer owns
- * exclusively. These are the settings the `separate-files` mode of
- * `sqlite-change-log-ceiling.bench.ts` measured.
- *
- * `wal2` because the log is a continuous append that catchup reads
- * continuously, which is the case wal2 exists for: it avoids checkpoint
- * starvation without needing an autocheckpoint. `wal_autocheckpoint` therefore
- * keeps its default, unlike the backup replica's 0, which hands checkpointing
- * to litestream — nothing else owns this file.
- *
- * `synchronous = NORMAL` because the commit sits on the forward path, once per
- * upstream transaction, and NORMAL keeps that from costing an fsync. It is not
- * a durability compromise here: in WAL mode NORMAL still writes every commit
- * through to the OS, so it survives a process crash, an OOM kill, or a SIGKILL.
- * It is lost only to kernel panic or power loss, and those destroy the node —
- * the task restarts elsewhere, restores the replica from S3, and has no
- * change-log file at all. Whatever a power loss does take is detected by
- * {@link reconcileChangeLog} and reseeded.
- *
- * `auto_vacuum = INCREMENTAL` so that purge can return freed pages to the OS
- * rather than leaving the file at its high-water mark. **It must be the first
- * statement here.** SQLite honours a `none` -> `incremental` transition only
- * while the file is still empty, and `journal_mode = wal2` materializes page 1;
- * appending the pragma instead of prepending it silently leaves the file at
- * mode 0 forever, since neither `DROP TABLE` nor a reseed makes a file empty
- * again. {@link openChangeLogDBForWriting} verifies the result.
- */
-export declare function applyChangeLogPragmas(db: Database): void;
-/**
- * Opens the change-log database for the writer, applies its pragmas, and
- * reconciles it against `anchor`, returning the handle and what reconciliation
- * had to do.
- *
- * Corruption is answered with a rebuild rather than an escalation, which is a
- * deliberate divergence from how the replica's own corruption is handled. A
- * corrupt replica is a lost source of truth, so it ends in a restore or an
- * auto-reset; the change log holds nothing that is not either already in the
- * replica's litestream backup or re-derivable from the upstream slot, so the
- * entire response is to delete the file and seed a new one at the resume
- * watermark. The cost is one retention window of catchup — reconnecting
- * subscribers below the head get `too-old` — which is what every other
- * {@link ReseedReason} costs.
- *
- * Only corruption is rebuilt through. Anything else (a bad path, a permissions
- * error, a full disk) is a problem with the environment rather than with the
- * file's contents, and deleting a database in response would destroy state
- * without fixing it. Those propagate to the caller, which disables the writer
- * and keeps replicating.
- *
- * A file that predates `auto_vacuum = INCREMENTAL` takes the same rebuild, for
- * the same reason and at the same cost: the pragma only takes on an empty file,
- * so a reseed cannot enable it. Unlike corruption, a *second* failure there is
- * tolerated rather than thrown — see {@link ensureIncrementalAutoVacuum}.
- */
-/**
- * Returns an anchor after the database opens.
- *
- * The resolver can inspect the existing file before it selects the anchor. A
- * valid log can use its own head. A new or invalid log uses the replica seed.
- * The rebuild path calls the resolver again for the new file.
- */
-export type AnchorResolver = (db: Database) => ChangeLogAnchor;
-export declare function openChangeLogDBForWriting(lc: LogContext, replicaFile: string, anchor: AnchorResolver): {
-    db: Database;
-    result: ReconcileResult;
-    replacedFile: boolean;
-};
-/**
- * Replaces an already-closed change-log file after bounded reconciliation
- * declined its work. The caller closes cached readers before calling this so
- * none can continue serving the unlinked inode.
- */
-export declare function rebuildChangeLogDBForWriting(lc: LogContext, replicaFile: string, anchor: ChangeLogAnchor, required: ChangeLogRebuildRequired): {
-    db: Database;
-    result: ReconcileResult;
-    replacedFile: true;
-};
-export type ReseedReason = 'created' | 'schema-mismatch' | 'identity-mismatch' | 'gap' | 'oversized-truncate';
-/**
- * Reconciliation runs synchronously on the change-streamer's event loop. A
- * normal phantom is one transaction, so work above either limit is answered by
- * unlinking and reseeding this disposable cache rather than deleting an
- * arbitrarily large suffix in place.
- */
-export declare const MAX_RECONCILE_TRUNCATE_ROWS = 10000;
-export declare const MAX_RECONCILE_TRUNCATE_BYTES: number;
-export declare class ChangeLogRebuildRequired extends Error {
-    readonly name = "ChangeLogRebuildRequired";
-    readonly reason: ReseedReason;
-    readonly rows?: number | undefined;
-    readonly estimatedBytes?: number | undefined;
-    constructor(reason: ReseedReason, rows?: number | undefined, estimatedBytes?: number | undefined);
-}
-type ReconcileOptions = {
-    /** Throw before an unbounded delete/drop so the file owner can unlink it. */
-    readonly rebuildInsteadOfUnboundedWork?: boolean | undefined;
-    /** Preserve the reason that caused an old file to be unlinked. */
-    readonly reseedReason?: ReseedReason | undefined;
-};
-/**
- * `cookiesStale` records that the cookie set the log held did not survive
- * reconciliation. The cookies are unversioned point-in-time state, so any
- * reconciliation that moves the head invalidates them, and the same transaction
- * replaces them with the anchor's — the set that belongs to the resume
- * watermark (see `change-log-cookies.ts`). It is `action !== 'none'` today; it
- * is a field rather than a derivation because the replacement reads as intent
- * at the call site, and because it is what the `cookie_reseed` counter is keyed
- * on.
- */
-export type ReconcileResult = {
-    action: 'none';
-    head: string;
-    cookiesStale: false;
-} | {
-    action: 'truncated';
-    head: string;
-    rows: number;
-    cookiesStale: true;
-} | {
-    action: 'reseeded';
-    head: string;
-    reason: ReseedReason;
-    cookiesStale: true;
-};
-/**
- * Brings the change log into agreement with the watermark its stream connection
- * resumes from, in one transaction on the change-log database:
- *
- * ```
- * head === resumeWatermark  → keep appending
- * head  >  resumeWatermark  → truncate above resumeWatermark
- * otherwise                 → wipe, seed at resumeWatermark, record the reason
- * ```
- *
- * The log commits before anything that can advance the resume watermark, so a
- * *phantom* — a transaction the log holds whose watermark the resumed stream
- * re-delivers — is the normal state, and truncate-above is the whole of
- * reconciliation rather than a special case. A phantom's rows all carry the
- * transaction's commit watermark, which is strictly greater than the resume
- * watermark, so deleting on that predicate removes phantoms whole and retains
- * every transaction at or below the resume point.
- *
- * It must run per stream connection, not once per process: the stream loop
- * re-reads its resume watermark on every reconnect, and the writer inserts with
- * a plain `INSERT` against `PRIMARY KEY ("watermark","pos")`, so an
- * un-truncated overlap is a constraint violation on the first re-delivered
- * transaction.
- *
- * Anything truncation cannot resolve — the file was deleted, the writer was
- * disabled for a while, the replica was restored, power was lost with
- * `synchronous=NORMAL` — surfaces as a head that does not land on the resume
- * watermark, and is resolved by wiping and reseeding there.
- *
- * Whichever of the two moves the head also replaces the cookie set with the one
- * the anchor carries, in the same transaction: the head and the cookies are one
- * position, and nothing may observe them at two.
- */
-export declare function reconcileChangeLog(lc: LogContext, db: Database, anchor: ChangeLogAnchor, opts?: ReconcileOptions): ReconcileResult;
-/**
- * Returns the reason that the log must be recreated. Returns `undefined` when
- * the writer can continue to use the log.
- *
- * This function takes only the expected identity because callers use the result
- * to select the anchor.
- */
-export declare function changeLogWipeReason(db: Database, identity: ChangeLogIdentity): ReseedReason | undefined;
-/**
- * Seeds a valid synthetic transaction at the anchor's resume watermark, making
- * an otherwise empty log serviceable as a catchup boundary for a subscriber
- * that is exactly at that watermark.
- */
-export declare function seedChangeLogStream(db: Database, anchor: ChangeLogAnchor): void;
-/** Reads the whole meta row. Throws if the log has not been reconciled. */
-export declare function readChangeLogMeta(db: Database): ChangeLogMeta;
-/**
- * `max()` on the primary key's leading column, i.e. an index seek. Null when
- * the log is empty.
- */
-export declare function readChangeLogHead(db: Database): string | null;
-/**
- * The covered watermark range. Both scalar subqueries seek the watermark
- * index, so unlike a `count()` this does not scan the log. Both bounds are
- * null when it is empty.
- */
-export declare function readChangeLogBounds(db: Database): ChangeLogBounds;
-export type ChangeLogBounds = {
-    readonly minWatermark: string | null;
-    readonly headWatermark: string | null;
-};
-export {};
-//# sourceMappingURL=change-log-db.d.ts.map

package/out/zero-cache/src/services/replicator/change-log-db.d.ts.map

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

package/out/zero-cache/src/services/replicator/change-log-stream-writer.d.ts

@@ -1,56 +0,0 @@
-import type { StatementRunner } from '../../db/statements.ts';
-import { type DataOrSchemaChange } from '../change-source/protocol/current/data.ts';
-import { type CookieOpTag } from './change-log-cookies.ts';
-export type ChangeLogStreamTransactionStats = {
-    readonly rows: number;
-    readonly estimatedBytes: number;
-    /** Present only for transactions selected for shadow-write validation. */
-    readonly hash?: string | undefined;
-    /**
-     * The cookie mutations this transaction's schema changes folded in, in stream
-     * order. Empty for the overwhelming majority of transactions.
-     */
-    readonly cookieMutations: readonly CookieOpTag[];
-};
-export declare class ChangeLogStreamInvariantError extends Error {
-    readonly name = "ChangeLogStreamInvariantError";
-}
-/**
- * Appends the canonical downstream stream to the change-log database, which is
- * a separate file from the replica, and folds its schema changes into the log's
- * cookie jar (`change-log-cookies.ts`) as it goes.
- *
- * This class owns the change log's transaction, and its transaction alone. It is
- * driven from the change-streamer's stream loop, which commits it before
- * forwarding a transaction's `commit` message; see `SQLiteChangeLogWriter` in
- * `change-streamer/sqlite-change-log-writer.ts` for the ordering that makes a
- * hole unreachable, and for the fail-soft policy that wraps every call here.
- *
- * Because the cookies are written in that same transaction, they are atomic with
- * the head and {@link rollback} discards them with the rows they were folded
- * from. Neither needs any handling of its own.
- */
-export declare class ChangeLogStreamWriter {
-    #private;
-    constructor(db: StatementRunner);
-    begin(watermark: string, json: string, storedChange?: string, hash?: boolean): void;
-    /**
-     * Appends one data or schema change. The parsed message is taken rather than
-     * just its tag because a schema change also mutates the cookie jar, and the
-     * caller already holds it — so the fold costs no re-parse.
-     *
-     * The cookie statements run here, i.e. inside this transaction and in stream
-     * order relative to the rows they were folded from. The Postgres change log
-     * has to flush its buffered batch to get the same ordering
-     * (`Storer.#processQueue()`); SQLite gets it from statement order.
-     */
-    append(json: string, change: DataOrSchemaChange, storedChange?: string): void;
-    commit(watermark: string, json: string, writeTimeMs: number, storedChange?: string): ChangeLogStreamTransactionStats;
-    /**
-     * Discards the open transaction, if any. Safe to call when none is open — the
-     * caller rolls back on an interrupted change stream, which can arrive between
-     * transactions as well as inside one.
-     */
-    rollback(): void;
-}
-//# sourceMappingURL=change-log-stream-writer.d.ts.map

package/out/zero-cache/src/services/replicator/change-log-stream-writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-stream-writer.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/change-log-stream-writer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,2CAA2C,CAAC;AAGnD,OAAO,EAAwB,KAAK,WAAW,EAAC,MAAM,yBAAyB,CAAC;AAMhF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,WAAW,EAAE,CAAC;CAClD,CAAC;AAEF,qBAAa,6BAA8B,SAAQ,KAAK;IACtD,SAAkB,IAAI,mCAAmC;CAC1D;AAWD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAqB;;IAYhC,YAAY,EAAE,EAAE,eAAe,EAc9B;IAED,KAAK,CACH,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,YAAY,SAAwC,EACpD,IAAI,UAAO,GACV,IAAI,CAmCN;IAED;;;;;;;;;OASG;IACH,MAAM,CACJ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,kBAAkB,EAC1B,YAAY,SAA2C,GACtD,IAAI,CAwBN;IAED,MAAM,CACJ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,YAAY,SAAyC,GACpD,+BAA+B,CA2CjC;IAED;;;;OAIG;IACH,QAAQ,IAAI,IAAI,CAMf;CAmBF"}

package/out/zero-cache/src/services/replicator/change-processor.d.ts

@@ -1,37 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { DownloadStatus } from '../../../../zero-events/src/status.ts';
-import type { StatementRunner } from '../../db/statements.ts';
-import type { ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
-import type { ReplicatorMode } from './replicator.ts';
-export type ChangeProcessorMode = ReplicatorMode | 'initial-sync';
-export type CommitResult = {
-    watermark: string;
-    completedBackfill: DownloadStatus | undefined;
-    schemaUpdated: boolean;
-    changeLogUpdated: boolean;
-    /**
-     * Millisecond epoch at which the transaction committed upstream, if the
-     * ChangeSource reported one. Propagated to ViewSyncers as the origin
-     * timestamp of the end-to-end serving lag measurement.
-     */
-    upstreamCommitTimeMs?: number | undefined;
-};
-/**
- * The ChangeProcessor partitions the stream of messages into transactions
- * by creating a {@link TransactionProcessor} when a transaction begins, and dispatching
- * messages to it until the commit is received.
- *
- * From https://www.postgresql.org/docs/current/protocol-logical-replication.html#PROTOCOL-LOGICAL-MESSAGES-FLOW :
- *
- * "The logical replication protocol sends individual transactions one by one.
- *  This means that all messages between a pair of Begin and Commit messages
- *  belong to the same transaction."
- */
-export declare class ChangeProcessor {
-    #private;
-    constructor(db: StatementRunner, mode: ChangeProcessorMode, failService: (lc: LogContext, err: unknown) => void);
-    abort(lc: LogContext): void;
-    /** @return If a transaction was committed. */
-    processMessage(lc: LogContext, downstream: ChangeStreamData): CommitResult | null;
-}
-//# sourceMappingURL=change-processor.d.ts.map

package/out/zero-cache/src/services/replicator/change-processor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"change-processor.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/change-processor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAQjD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uCAAuC,CAAC;AAmB1E,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AAsC5D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAUpD,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,cAAc,CAAC;AASlE,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAAC;IAC9C,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,qBAAa,eAAe;;IAiB1B,YACE,EAAE,EAAE,eAAe,EACnB,IAAI,EAAE,mBAAmB,EACzB,WAAW,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,EAQpD;IA2BD,KAAK,CAAC,EAAE,EAAE,UAAU,QAEnB;IAED,8CAA8C;IAC9C,cAAc,CACZ,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,gBAAgB,GAC3B,YAAY,GAAG,IAAI,CAkBrB;CAyIF"}

package/out/zero-cache/src/services/replicator/drain-handler.d.ts

@@ -1,82 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type Sized, type Source } from '../../types/streams.ts';
-import type { ChangeStreamer, SubscriberContext } from '../change-streamer/change-streamer.ts';
-import type { SubscribeDownstream } from '../change-streamer/subscribe.ts';
-import type { RunningState } from '../running-state.ts';
-export type SwitchoverOptions = {
-    /**
-     * Called when a replication-manager with a newer replica version grants
-     * permission to restore its replica. This should initiate a graceful
-     * restart of the server (during which the current subscription continues
-     * to be served).
-     */
-    onRestoreGranted: () => void;
-    /**
-     * The replica file, from which the state of the last committed
-     * transaction is read for switchover subscriptions.
-     */
-    replicaFile: string;
-    /** For testing. */
-    timeoutMs?: number | undefined;
-    /** For testing. */
-    searchTimeoutMs?: number | undefined;
-};
-export type Downstream = Source<Sized<SubscribeDownstream>>;
-/**
- * Handles the switchover of a serving replica's subscription from a draining
- * replication-manager to another one, without interrupting the current
- * subscription.
- *
- * Upon {@link onChangeStreamerDrain}, the handler repeatedly (with backoff)
- * opens a new `switchover` subscription, at the watermark of the replica's
- * last committed transaction, to whichever replication-manager the
- * connection is routed to. The first message on the new subscription
- * determines the outcome:
- * * `status`: The subscription was accepted (i.e. the replica is compatible).
- *   The current subscription is cancelled (aborting any transaction in
- *   progress), and the new one is made available via
- *   {@link getNextConnection}. Note that the new subscription may start with
- *   transactions that were committed from the current subscription in the
- *   meantime, which the consumer must skip.
- * * `status` with `restore: queued`: The replication-manager has a newer
- *   replica version, and is holding the subscription until it grants
- *   permission to restore. The held subscription is monitored for the grant.
- * * `status` with `restore: granted`: Permission to restore is granted, and
- *   {@link SwitchoverOptions.onRestoreGranted} is called. The granted
- *   subscription is kept open until the process exits, so that the
- *   replication-manager can track the grant until the restore begins.
- * * Anything else (e.g. an error, or a `draining` replication-manager):
- *   The switchover is retried later.
- *
- * If no other replication-manager accepts or holds a switchover subscription
- * within {@link DEFAULT_SWITCHOVER_SEARCH_TIMEOUT_MS} (e.g. because the
- * draining one is the only one), the current subscription is closed so that
- * the draining replication-manager can shut down, and the consumer reconnects
- * on its own.
- *
- * The current subscription continues to be consumed throughout. A
- * switchover is scoped to the subscription from which it switches: If that
- * subscription ends first (e.g. the replication-manager shuts down), the
- * switchover is abandoned, including any held (but not granted)
- * subscription, as the consumer reconnects on its own.
- */
-export declare class DrainHandler {
-    #private;
-    /**
-     * @param committedContext Returns the subscriber context as of the
-     *        replica's last committed transaction.
-     */
-    constructor(lc: LogContext, changeStreamer: ChangeStreamer, state: RunningState, options: SwitchoverOptions, committedContext: () => SubscriberContext);
-    /**
-     * Called when the change-streamer of the `current` subscription is
-     * draining.
-     */
-    onChangeStreamerDrain(current: Downstream): void;
-    get hasNextConnection(): boolean;
-    /**
-     * Returns (and clears) the subscription that replaces the (now cancelled)
-     * current one, if a switchover succeeded.
-     */
-    getNextConnection(): Downstream | undefined;
-}
-//# sourceMappingURL=drain-handler.d.ts.map

package/out/zero-cache/src/services/replicator/drain-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drain-handler.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/drain-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAW,KAAK,KAAK,EAAE,KAAK,MAAM,EAAC,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EACV,cAAc,EAEd,iBAAiB,EAClB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAqBtD,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAE7B;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,mBAAmB;IACnB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/B,mBAAmB;IACnB,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;AAS5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,YAAY;;IAYvB;;;OAGG;IACH,YACE,EAAE,EAAE,UAAU,EACd,cAAc,EAAE,cAAc,EAC9B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,iBAAiB,EAC1B,gBAAgB,EAAE,MAAM,iBAAiB,EAO1C;IAED;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,UAAU,QAaxC;IAED,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED;;;OAGG;IACH,iBAAiB,IAAI,UAAU,GAAG,SAAS,CAI1C;CA+JF"}