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

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

@@ -1,205 +0,0 @@
-import type { Enum } from '../../../../shared/src/enum.ts';
-import type { Subscription } from '../../types/subscription.ts';
-import type { ReplicatorMode } from '../replicator/replicator.ts';
-import type { BackfillState } from './backfill-state.ts';
-import type { PreSerializedBatch } from './broadcast.ts';
-import type { ChangeTag, Status, WatermarkedChange } from './change-streamer.ts';
-import type * as ErrorType from './error-type-enum.ts';
-type ErrorType = Enum<typeof ErrorType>;
-export type SubscriberOptions = {
-    backlogHighWaterBytes?: number | undefined;
-    backlogLowWaterRatio?: number | undefined;
-    wsBatched?: boolean | undefined;
-    /**
-     * Called whenever the subscriber's acked watermark advances, i.e. when it
-     * has confirmed that a commit was durably applied to its replica. The ACK
-     * therefore lags the subscriber's replica rather than leading it.
-     */
-    onAck?: ((watermark: string) => void) | undefined;
-    /**
-     * The subscriber's pending backfills (protocol v8+), which are tracked
-     * over the changes sent to the subscriber.
-     */
-    backfills?: BackfillState | undefined;
-    /**
-     * Called once the subscriber has been sent all changes up to the head of
-     * the stream, i.e. its catchup and backlog have been flushed. From this
-     * point on, the subscriber's tracked {@link backfills} reflect the same
-     * position in the stream as that of the change-streamer.
-     */
-    onAligned?: ((subscriber: Subscriber) => void) | undefined;
-    /**
-     * Called when a `backfill` or `backfill-completed` message is ignored for
-     * some of the subscriber's pending backfill columns, after the subscriber
-     * is aligned.
-     */
-    onBackfillIgnored?: ((columns: string[]) => void) | undefined;
-    /**
-     * Resolves, once it is known whether lag reporting is enabled upstream, to
-     * the means of requesting a lag report, or to `undefined` if it is disabled.
-     *
-     * Subscribers use lag reports to determine that they are caught up (e.g. to
-     * advertise readiness to serve traffic). Once the subscriber is aligned, a
-     * report is therefore requested, so that it is received without waiting out
-     * the report interval. If lag reporting is disabled, a
-     * {@link LAG_REPORTING_DISABLED} status is sent as a stand-in instead.
-     */
-    lagReports?: Promise<LagReports | undefined> | undefined;
-    /**
-     * Whether the subscriber switches over to another replication-manager
-     * when this one drains (see `DrainTracker`).
-     */
-    drainable?: boolean | undefined;
-};
-export type BacklogFullWait = {
-    readonly promise: Promise<void>;
-    cancel(): void;
-};
-export type SubscriberStats = {
-    processRate: number;
-    pending: number;
-    backlog: number;
-    backlogBytes: number;
-    totalBufferedBytes: number;
-    missedLastTimeout: boolean;
-};
-/**
- * Encapsulates a subscriber to changes. All subscribers start in a
- * "catchup" phase in which changes are buffered in a backlog while the
- * storer is queried to send any changes that were committed since the
- * subscriber's watermark. Once the catchup is complete, calls to
- * {@link send()} result in immediately sending the change.
- */
-export declare class Subscriber {
-    #private;
-    readonly id: string;
-    readonly mode: ReplicatorMode;
-    readonly drainable: boolean;
-    constructor(protocolVersion: number, id: string, mode: ReplicatorMode, watermark: string, downstream: Subscription<string | PreSerializedBatch>, options?: SubscriberOptions);
-    /**
-     * The subscriber's tracked pending backfills, or `undefined` if the
-     * subscriber does not report them (i.e. protocol < v8).
-     */
-    get backfills(): BackfillState | undefined;
-    /**
-     * Whether the subscriber has been sent all changes up to the head of the
-     * stream (see {@link SubscriberOptions.onAligned}).
-     */
-    get aligned(): boolean;
-    /**
-     * Resolves once the subscriber has caught up, i.e. once it has acked
-     * (durably applied) all changes up to the head of the stream at the time
-     * it was {@link aligned}. Never resolves if the subscriber is closed first.
-     */
-    get caughtUp(): Promise<void>;
-    get watermark(): string;
-    get acked(): string;
-    /**
-     * Whether the backlog of live changes buffered during catchup has reached the
-     * point at which {@link send()} stops resolving. Past it the subscriber is no
-     * longer free: it holds up every subsequent flush, and with no other
-     * subscriber to form a majority it stalls replication outright.
-     */
-    get backlogFull(): boolean;
-    /**
-     * @returns whether the subscriber is currently sending backlogged messages,
-     *          vs caught up and sending the "head" of the replication stream.
-     */
-    isBacklogged(): boolean;
-    /**
-     * Resolves the first time {@link backlogFull} becomes true, so that a caller
-     * holding the subscriber in catchup can give up at the moment the subscriber
-     * starts costing replication rather than on a timer. Call cancel() when the
-     * wait is no longer needed so the subscriber does not retain it.
-     */
-    whenBacklogFull(): BacklogFullWait;
-    send(change: WatermarkedChange): Promise<void>;
-    sendBatch(changes: readonly WatermarkedChange[], preSerialized?: PreSerializedBatch | undefined): Promise<void>;
-    /**
-     * Sends a status message (e.g. a lag report) downstream. While the
-     * subscriber is catching up, the status is queued in the backlog behind
-     * the changes that preceded it in the replication stream, so that the
-     * subscriber processes it in stream order. This is necessary for lag
-     * reports to measure the lag of the subscriber, including its catchup.
-     *
-     * Status messages received before the subscriber is initialized are
-     * dropped.
-     */
-    sendStatus(status: Status): void;
-    /**
-     * Sends a control status (e.g. `draining` or `restore`) downstream
-     * immediately, regardless of whether the subscriber is initialized or
-     * catching up. Unlike {@link sendStatus}, such statuses are not tied to a
-     * position in the replication stream.
-     */
-    sendControlStatus(status: Status): void;
-    /** catchup() is called on ChangeEntries loaded from the store. */
-    catchup(change: WatermarkedChange): Promise<void>;
-    /**
-     * Marks the Subscribe as "caught up" and flushes any backlog of
-     * entries that were received during the catchup.
-     */
-    setCaughtUp(): Promise<void>;
-    /**
-     * The number of downstream messages that have yet to be acked.
-     */
-    get numPending(): number;
-    /**
-     * The total number of downstream messages that the subscriber has
-     * processed (i.e. acked).
-     */
-    get numProcessed(): number;
-    /**
-     * Records a new history entry for the number of messages processed,
-     * keeping the number of samples bounded to `maxSamples`.
-     */
-    sampleProcessRate(now: number, maxSamples?: number): this;
-    getStats(): SubscriberStats;
-    trackResponseResult(result: 'on-time' | 'timed-out'): void;
-    /**
-     * Reports the change rate of a slow subscriber (i.e. that missed the last
-     * timeout) compared to the change rate of the (slowest) subscriber that
-     * responded on time.
-     *
-     * * `lagging` indicates that this subscriber is slower
-     * * `catching-up` indicates that it is faster
-     *
-     * Returns the total duration in which subscriber has been continuously
-     * reported as `lagging`.
-     */
-    reportChangeRate(now: number, status: 'lagging' | 'catching-up'): number;
-    supportsMessage(tag: ChangeTag): boolean;
-    /**
-     * Ends the subscription without sending a downstream `['error', ...]`.
-     *
-     * This is deliberate, and not the same as reporting the failure to the
-     * subscriber: `IncrementalSyncer` treats any `['error', ...]` as terminal and
-     * shuts down to restore a fresh replica from litestream, whereas a clean end
-     * backs off and re-subscribes. The failures routed here -- storer catchup
-     * errors, backlog drain errors, backup-monitor errors -- are transient, so a
-     * reconnect is the proportionate response and a fleet-wide restore is not.
-     *
-     * Callers are responsible for logging `err`; it is not carried downstream.
-     */
-    fail(_err?: unknown): void;
-    close(error?: ErrorType, message?: string, details?: {
-        replicaVersion?: string | undefined;
-    }): void;
-}
-/** Requests lag reports from upstream (see {@link SubscriberOptions.lagReports}). */
-export type LagReports = {
-    /**
-     * Requests that a lag report be sent now rather than at the next report
-     * interval. Requests are coalesced upstream, e.g. with a report in flight.
-     */
-    request(): void;
-};
-/**
- * Sent to an aligned subscriber when lag reporting is disabled upstream,
- * signaling that the subscriber is caught up. This is a lag report with a
- * `nextSendTimeMs` of 0 and no `lastTimings`, so that no lag is measured
- * (see `isLagReportingDisabledSignal()` in the replicator's recorder).
- */
-export declare const LAG_REPORTING_DISABLED: Status;
-export {};
-//# sourceMappingURL=subscriber.d.ts.map

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

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

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

@@ -1,52 +0,0 @@
-import type { Sink } from '../../types/streams.ts';
-import type { ChangeSourceUpstream, ChangeStreamMessage } from '../change-source/protocol/current.ts';
-type Opts = {
-    trackPgChangeLog: boolean;
-    trackBackup: boolean;
-};
-/**
- * Tracks the progress (watermark) of multiple streams:
- * - downstream transactions and status messages (the latter
- *   indicating LSNs that are not relevant to the publication
- *   but nevertheless need to be ACKed)
- * - PG change-log commits
- * - backup watermarks
- *
- * and sends upstream ACKs accordingly. When both the PG change-log
- * and backup watermarks are being considered for upstream ACKs
- * (i.e. RMv1.5), only watermarks that have been reached by both
- * stores are acked.
- *
- * The UpstreamAcker also takes into account that an upstream
- * connection can be disconnected and {@link reset()}. In this case,
- * the progress of the persistent stores is retained and the acks
- * are resent on the new upstream connection as necessary.
- */
-export declare class UpstreamAcker {
-    #private;
-    constructor({ trackPgChangeLog, trackBackup }: Opts);
-    /**
-     * Starts tracking a new upstream connection, which resumes the change stream
-     * after `resumeWatermark`.
-     *
-     * Everything at or before `resumeWatermark` was committed on an earlier
-     * connection, so it counts as committed on this one: a status watermark past
-     * it waits for the tracked stores to reach it, as it would for a commit on
-     * this connection. Otherwise the first keepalive of a stream that resumes
-     * ahead of the stores -- a change log ahead of its backup, which is the
-     * normal state -- would move the replication slot past transactions that the
-     * backup has not persisted, and a task restored from the backup would then
-     * resume below the slot, which the upstream moves forward without a word.
-     *
-     * When the PG change log is tracked, the stream resumes from its head, so
-     * `resumeWatermark` has been persisted in it (by this or another
-     * change-streamer). Without this, status messages would not be acked on an
-     * idle upstream until a commit is stored.
-     */
-    reset(upstream: Sink<ChangeSourceUpstream>, resumeWatermark: string): void;
-    trackDownstream(downstream: ChangeStreamMessage): void;
-    trackPgChangeLog(committedWatermark: string): void;
-    trackBackup(backedUpWatermark: string): void;
-}
-export {};
-//# sourceMappingURL=upstream-acker.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"upstream-acker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/upstream-acker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AACjD,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAE9C,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;;IAYxB,YAAY,EAAC,gBAAgB,EAAE,WAAW,EAAC,EAAE,IAAI,EAOhD;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,oBAAoB,CAAC,EAAE,eAAe,EAAE,MAAM,QAalE;IAED,eAAe,CAAC,UAAU,EAAE,mBAAmB,QAe9C;IAED,gBAAgB,CAAC,kBAAkB,EAAE,MAAM,QAO1C;IAED,WAAW,CAAC,iBAAiB,EAAE,MAAM,QAIpC;CA2BF"}

package/out/zero-cache/src/services/limiter/sliding-window-limiter.d.ts

@@ -1,57 +0,0 @@
-type Window = {
-    start: number;
-    count: number;
-};
-/**
- * The limiter is a sliding window rate limiter that allows a maximum
- * number of mutations per window.
- *
- * The window is divided into two parts: the prev window and the next window.
- * The prev window is the part of the window that has already passed, and the
- * next window is the part of the window that is still in the future.
- *
- * The limiter keeps track of the number of mutations in each window. When the
- * current time moves completely past the next window, the limiter creates new
- * windows (this only happens if the limiter is not called for a long time).
- * When the current time moves completely into the next window, the
- * limiter rotates the windows.
- *
- * Case 1: need new windows
- * |----|----|
- *             |----| (sliding window)
- *
- * Case 2: rotate windows
- * |----|----|
- *      |----| (sliding window)
- *
- * or
- *
- * |----|----|
- *         |----| (sliding window)
- *
- * The leading edge of the sliding window is current time.
- *
- * The limiter increments the count for the prev window if the current time is
- * in the prior window. Otherwise, it increments the count for the next
- * window.
- *
- * The limiter computes the total mutations by: taking the number of mutation in the next window and
- * adding the number of mutation from the prev window, weighted by
- * the fraction of the window that has passed. The total mutations must be less
- * than the maximum number of mutations allowed per window.
- *
- * |----|----|
- *    |----| (sliding window)
- * ^-- the sliding window covers 25% of the prior window. Only 25% of that window's count counts.
- * The entirety of the next window's count counts.
- */
-export declare class SlidingWindowLimiter {
-    #private;
-    constructor(windowSizeMs: number, maxMutations: number);
-    canDo(): boolean;
-    totalCallsForTime(now: number): number;
-    get priorWindow(): Window;
-    get nextWindow(): Window;
-}
-export {};
-//# sourceMappingURL=sliding-window-limiter.d.ts.map

package/out/zero-cache/src/services/limiter/sliding-window-limiter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sliding-window-limiter.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/limiter/sliding-window-limiter.ts"],"names":[],"mappings":"AAEA,KAAK,MAAM,GAAG;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,qBAAa,oBAAoB;;IAO/B,YAAY,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAKrD;IAED,KAAK,IAAI,OAAO,CAoCf;IAED,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqBrC;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;CA4BF"}

package/out/zero-cache/src/services/litestream/commands.d.ts

@@ -1,77 +0,0 @@
-import type { ChildProcess } from 'node:child_process';
-import type { LogContext } from '@rocicorp/logger';
-import { type LitestreamConfig } from '../../config/normalize.ts';
-import { type LitestreamRole } from './metrics.ts';
-export type ReplicaConstraints = {
-    replicaVersion: string;
-    minWatermark: string;
-};
-export type RestoreResult = 'success' | 'no_backup' | 'invalid_replica' | 'error';
-export type RestoreAttempt = {
-    restored: boolean;
-    backupURL: string | undefined;
-    result: RestoreResult;
-    /**
-     * Set when the restore forked the backup (see {@link ForkBackup}), which
-     * then continues from the restored replica's WAL. The WAL is kept when the
-     * last connection closes (see `Database.persistWal()`).
-     */
-    forked?: boolean | undefined;
-};
-/**
- * Prepares the restored replica to continue from a forked backup
- * instead of starting a new lineage with a full snapshot.
- */
-export type ForkBackup = {
-    /** The restore also forks its backup into the (new, empty) one at this URL. */
-    url: string;
-};
-export declare class BackupNotFoundException extends Error {
-    static readonly name = "BackupNotFoundException";
-    constructor(backupURL: string | undefined);
-}
-/**
- * The effective backup URL: the `backupURLOverride` if present (i.e. a
- * lineage-specific location computed by the replication-manager), or
- * otherwise the configured `backupURL`.
- */
-export declare function backupDestinationURL(config: Pick<LitestreamConfig, 'backupURL' | 'backupURLOverride'>): string | undefined;
-export declare function tryRestore(lc: LogContext, config: LitestreamConfig, replicaFile: string, replicaConstraints: ReplicaConstraints | undefined, role: LitestreamRole, signal?: AbortSignal, forkBackup?: ForkBackup | undefined): Promise<RestoreAttempt>;
-/**
- * Deletes litestream's local state for `replicaFile` (its default meta
- * directory, `.<file>-litestream`).
- */
-export declare function deleteLitestreamMetaDir(replicaFile: string): void;
-/**
- * Returns the replica version and watermark of the local replica file, or
- * `undefined` if it does not exist or cannot be read.
- */
-export declare function readLocalReplica(lc: LogContext, replica: string): {
-    replicaVersion: string;
-    watermark: string;
-} | undefined;
-export declare function startReplicaBackupProcess(lc: LogContext, config: LitestreamConfig, replicaFile: string): ChildProcess;
-/**
- * Returns the time of the most recent object (snapshot or WAL segment)
- * actually uploaded to the backup replica destination, as listed by the
- * bundled litestream CLI (`litestream snapshots` / `litestream wal`).
- *
- * This queries the replica destination (e.g. S3) directly, and thus serves
- * as a source of truth for backup durability. This is in contrast to the
- * `litestream_replica_progress` metric, which is exported when litestream
- * *believes* an upload has succeeded, and has been observed to advance even
- * when nothing is actually written to the destination.
- *
- * Rejects if the backup state cannot be determined (spawn error, non-zero
- * exit, timeout, or empty/unparseable listing).
- */
-export declare function getLastBackupTime(lc: LogContext, config: LitestreamConfig, replicaFile: string): Promise<Date>;
-/**
- * Parses the `created` column (the last, RFC3339-formatted column) from the
- * tab-formatted output of `litestream snapshots` / `litestream wal`. The
- * header row and any unparseable lines are skipped.
- *
- * Exported for testing.
- */
-export declare function parseBackupCreatedTimes(lc: LogContext, command: 'snapshots' | 'wal', output: string): Date[];
-//# sourceMappingURL=commands.d.ts.map

package/out/zero-cache/src/services/litestream/commands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAIrD,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAK3D,OAAO,EAAC,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAUhE,OAAO,EAWL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,WAAW,GACX,iBAAiB,GACjB,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,aAAa,CAAC;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAKF,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA6B;IAEjD,YAAY,SAAS,EAAE,MAAM,GAAG,SAAS,EAExC;CACF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,mBAAmB,CAAC,GAChE,MAAM,GAAG,SAAS,CAEpB;AA6FD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAClD,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,GAClC,OAAO,CAAC,cAAc,CAAC,CA2BzB;AAsND;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,QAK1D;AAwDD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,MAAM,GACd;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,GAAG,SAAS,CAiBzD;AAqDD,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,YAAY,CAuCd;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf;AA8DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,WAAW,GAAG,KAAK,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CAoBR"}

package/out/zero-cache/src/services/litestream/litestream-controller.d.ts

@@ -1,78 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-/**
- * Path of the litestream control socket, derived from the replica file's
- * directory. The socket must live on a filesystem the (non-root) runtime user
- * can write — the replica directory is guaranteed writable since litestream
- * writes the replica there — so it must NOT default to a root-owned location
- * like /var/run. Kept in sync with config-v5.yml's `socket.path`, which is set
- * from `ZERO_LITESTREAM_SOCKET_PATH` (see getLitestream() in commands.ts).
- */
-export declare function litestreamSocketPath(replicaFile: string): string;
-/** Response body from litestream's `POST /sync` control endpoint. */
-export type SyncResponse = {
-    /**
-     * `synced` when `wait` was true and the upload completed, `synced_local`
-     * when the WAL was sealed locally without waiting on the remote replica, or
-     * `no_change` when there was nothing to sync.
-     */
-    status: 'synced' | 'synced_local' | 'no_change';
-    path: string;
-    txid: number;
-    replicated_txid: number;
-};
-export type SyncOptions = {
-    /**
-     * When true, block until the sealed WAL has been uploaded to the remote
-     * replica (litestream's SyncAndWait). When false (the default), litestream
-     * only seals the WAL into local LTX files and runs its checkpoint thresholds,
-     * returning without waiting on the backup store. Use false on the write path
-     * where the goal is to keep the WAL small, not to durably back it up.
-     */
-    wait?: boolean | undefined;
-    /** Overall request timeout in milliseconds. Defaults to 30s. */
-    timeoutMs?: number | undefined;
-    /**
-     * Server-side deadline in seconds, sent as litestream's `timeout`. When set,
-     * litestream ends the request itself (with an error response) once it
-     * elapses. Set it below {@link timeoutMs} so that litestream, rather than
-     * the client, ends a slow request. (litestream defaults to 30s when `wait`
-     * is set, and to no deadline otherwise.)
-     */
-    serverTimeoutSeconds?: number | undefined;
-};
-/**
- * IPC client for the litestream control server. litestream serves an HTTP API
- * over a Unix domain socket (enabled via the `socket:` block in config-v5.yml);
- * because zero-cache runs litestream as a subprocess in the same container, the
- * socket is reachable directly on the local filesystem.
- *
- * A single keep-alive connection is held open and reused across calls, so a
- * high-frequency caller (e.g. write-path backpressure) does not pay a
- * connect/handshake per request.
- */
-export declare class LitestreamController {
-    #private;
-    /**
-     * @param replicaFile Path of the replica database litestream is managing —
-     *   the same value passed to litestream as `ZERO_REPLICA_FILE`. This is the
-     *   `path` litestream matches control requests against.
-     * @param socketPath Path of the control socket; defaults to the path derived
-     *   from `replicaFile`, matching config-v5.yml's `socket.path`.
-     */
-    constructor(lc: LogContext, replicaFile: string, socketPath?: string);
-    /**
-     * Forces litestream to sync the WAL into LTX files immediately and run its
-     * checkpoint thresholds, instead of waiting for the next monitor-interval
-     * tick. The checkpoint itself is still litestream's usual (non-blocking)
-     * PASSIVE attempt, so it is skipped if the database is busy — call this once
-     * writes are quiesced.
-     *
-     * Best-effort: callers should tolerate rejection (e.g. ECONNREFUSED/ENOENT
-     * while litestream is restarting or before it has created the socket) rather
-     * than blocking application progress on it.
-     */
-    sync(opts?: SyncOptions, signal?: AbortSignal): Promise<SyncResponse>;
-    /** Releases the pooled keep-alive connection. */
-    close(): void;
-}
-//# sourceMappingURL=litestream-controller.d.ts.map

package/out/zero-cache/src/services/litestream/litestream-controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"litestream-controller.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/litestream-controller.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEhE;AAID,qEAAqE;AACrE,MAAM,MAAM,YAAY,GAAG;IACzB;;;;OAIG;IACH,MAAM,EAAE,QAAQ,GAAG,cAAc,GAAG,WAAW,CAAC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAE3B,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/B;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;;IAM/B;;;;;;OAMG;IACH,YACE,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,SAAoC,EAQ/C;IAED;;;;;;;;;;OAUG;IACG,IAAI,CACR,IAAI,GAAE,WAAgB,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,YAAY,CAAC,CAkBvB;IAED,iDAAiD;IACjD,KAAK,IAAI,IAAI,CAEZ;CA4DF"}

package/out/zero-cache/src/services/litestream/metrics.d.ts

@@ -1,31 +0,0 @@
-import type { LitestreamConfig } from '../../config/normalize.ts';
-export type LitestreamRole = 'replication_manager' | 'view_syncer';
-export type LitestreamVersion = 'legacy' | 'v5';
-export type LitestreamMetricAttrs = {
-    role: LitestreamRole;
-    backup_scheme: string;
-    litestream: LitestreamVersion;
-};
-type LitestreamMultipartMetricAttrs = {
-    multipart_concurrency: number;
-    multipart_size_mib: number;
-};
-export declare function litestreamRestoreMetricAttrs(config: LitestreamConfig, role: LitestreamRole, backupURL?: string | undefined): LitestreamMetricAttrs & LitestreamMultipartMetricAttrs;
-export declare function litestreamBackupMetricAttrs(config: LitestreamConfig): LitestreamMetricAttrs;
-export declare function litestreamBackupProcessMetricAttrs(config: LitestreamConfig): LitestreamMetricAttrs & LitestreamMultipartMetricAttrs;
-export declare function litestreamMonitorMetricAttrs(backupURL: string, litestream: LitestreamVersion, role: LitestreamRole): LitestreamMetricAttrs;
-export declare function litestreamRestoreRuns(): import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-export declare function litestreamRestoreAttempts(): import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-export declare function litestreamRestoredDbBytes(): import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-export declare function litestreamBackupProcessRuns(): import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-export declare function litestreamRestoreDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamRestoreWaitDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamRestoreProcessDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamRestoreValidationDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamBackupProcessDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamBackupListDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamBackupVerificationDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamSnapshotReservationDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export declare function litestreamSnapshotReservationConfirmDuration(): import("../../observability/metrics.ts").LatencyHistogram;
-export {};
-//# sourceMappingURL=metrics.d.ts.map

package/out/zero-cache/src/services/litestream/metrics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAOhE,MAAM,MAAM,cAAc,GAAG,qBAAqB,GAAG,aAAa,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,IAAI,CAAC;AAEhD,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,cAAc,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,iBAAiB,CAAC;CAC/B,CAAC;AAEF,KAAK,8BAA8B,GAAG;IACpC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,cAAc,EACpB,SAAS,qBAAmB,GAC3B,qBAAqB,GAAG,8BAA8B,CAaxD;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,gBAAgB,GACvB,qBAAqB,CAUvB;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,gBAAgB,GACvB,qBAAqB,GAAG,8BAA8B,CAKxD;AAED,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,cAAc,GACnB,qBAAqB,CAMvB;AAuBD,wBAAgB,qBAAqB,kFAMpC;AAED,wBAAgB,yBAAyB,kFAMxC;AAED,wBAAgB,yBAAyB,kFAMxC;AAED,wBAAgB,2BAA2B,kFAM1C;AAED,wBAAgB,yBAAyB,8DAKxC;AAED,wBAAgB,6BAA6B,8DAK5C;AAED,wBAAgB,gCAAgC,8DAK/C;AAED,wBAAgB,mCAAmC,8DAKlD;AAED,wBAAgB,+BAA+B,8DAK9C;AAED,wBAAgB,4BAA4B,8DAK3C;AAED,wBAAgB,oCAAoC,8DAKnD;AAED,wBAAgB,qCAAqC,8DAKpD;AAED,wBAAgB,4CAA4C,8DAM3D"}

package/out/zero-cache/src/services/litestream/restore-progress.d.ts

@@ -1,24 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { ViewSyncerStatusEvent } from '../../../../zero-events/src/status.ts';
-type PublishFn = (lc: LogContext, event: ViewSyncerStatusEvent) => void;
-/**
- * Publishes the progress of a view-syncer's litestream restore.
- *
- * `litestream restore` writes the database page by page into
- * `<replica>.tmp` and renames it to the replica when it is done, so the
- * size of the temporary file is the number of bytes restored so far.
- */
-export declare class RestoreProgressReporter {
-    #private;
-    constructor(lc: LogContext, replicaFile: string, publishFn?: PublishFn);
-    /**
-     * Publishes a `Restoring` event now and then every `intervalMs` while the
-     * number of restored bytes changes, until {@link stop} or {@link done}.
-     */
-    start(totalBytes: number | undefined, intervalMs?: number): void;
-    stop(): void;
-    /** Publishes a `Restored` event with the size of the restored replica. */
-    done(): void;
-}
-export {};
-//# sourceMappingURL=restore-progress.d.ts.map

package/out/zero-cache/src/services/litestream/restore-progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"restore-progress.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/restore-progress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAGV,qBAAqB,EACtB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,SAAS,GAAG,CAAC,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;AAExE;;;;;;GAMG;AACH,qBAAa,uBAAuB;;IAUlC,YACE,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,GAAE,SAAwB,EAKpC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,SAAsB,QAcrE;IAED,IAAI,SAGH;IAED,0EAA0E;IAC1E,IAAI,SAGH;CA2CF"}

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

@@ -1,40 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { JWTPayload } from 'jose';
-import postgres from 'postgres';
-import { ErrorKind } from '../../../../zero-protocol/src/error-kind.ts';
-import { type CRUDMutation, type InsertOp, type Mutation, type UpsertOp } from '../../../../zero-protocol/src/mutation.ts';
-import type { DatabaseStorage } from '../../../../zqlite/src/database-storage.ts';
-import { type WriteAuthorizer } from '../../auth/write-authorizer.ts';
-import { type ZeroConfig } from '../../config/zero-config.ts';
-import type { PostgresDB, PostgresTransaction } from '../../types/pg.ts';
-import { type ShardID } from '../../types/shards.ts';
-import type { RefCountedService, Service } from '../service.ts';
-export type MutationError = [
-    kind: ErrorKind.MutationFailed | ErrorKind.MutationRateLimited,
-    desc: string
-];
-export interface Mutagen extends RefCountedService {
-    /**
-     * Callers must hold a {@link ref} for the duration of a push (i.e. across
-     * all of its mutations). The service stops, closing its replica handle,
-     * when its ref count drops to zero.
-     */
-    processMutation(mutation: Mutation, authData: JWTPayload | undefined, customMutatorsEnabled: boolean): Promise<MutationError | undefined>;
-}
-export declare class MutagenService implements Mutagen, Service {
-    #private;
-    readonly id: string;
-    constructor(lc: LogContext, shard: ShardID, clientGroupID: string, upstream: PostgresDB, config: ZeroConfig, writeAuthzStorage: DatabaseStorage);
-    ref(): void;
-    unref(): void;
-    hasRefs(): boolean;
-    processMutation(mutation: Mutation, authData: JWTPayload | undefined, customMutatorsEnabled?: boolean): Promise<MutationError | undefined>;
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}
-export declare function processMutation(lc: LogContext, authData: JWTPayload | undefined, db: PostgresDB, shard: ShardID, clientGroupID: string, mutation: Mutation, writeAuthorizer: WriteAuthorizer, onTxStart?: () => void | Promise<void>, // for testing
-customMutatorsEnabled?: boolean): Promise<MutationError | undefined>;
-export declare function processMutationWithTx(lc: LogContext, tx: PostgresTransaction, authData: JWTPayload | undefined, shard: ShardID, clientGroupID: string, mutation: CRUDMutation, errorMode: boolean, authorizer: WriteAuthorizer): Promise<void>;
-export declare function getInsertSQL(tx: postgres.TransactionSql, create: InsertOp): postgres.PendingQuery<postgres.Row[]>;
-export declare function getUpsertSQL(tx: postgres.TransactionSql, set: UpsertOp): postgres.PendingQuery<postgres.Row[]>;
-//# sourceMappingURL=mutagen.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mutagen.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/mutagen/mutagen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,MAAM,CAAC;AACrC,OAAO,QAAQ,MAAM,UAAU,CAAC;AAGhC,OAAO,EAAC,SAAS,EAAC,MAAM,6CAA6C,CAAC;AAOtE,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,QAAQ,EACb,KAAK,QAAQ,EAEb,KAAK,QAAQ,EACd,MAAM,2CAA2C,CAAC;AAKnD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4CAA4C,CAAC;AAEhF,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,6BAA6B,CAAC;AAK5D,OAAO,KAAK,EAAC,UAAU,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAiB,KAAK,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,EAAC,iBAAiB,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAK9D,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,mBAAmB;IAC9D,IAAI,EAAE,MAAM;CACb,CAAC;AAEF,MAAM,WAAW,OAAQ,SAAQ,iBAAiB;IAChD;;;;OAIG;IACH,eAAe,CACb,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,UAAU,GAAG,SAAS,EAChC,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC;CACvC;AAED,qBAAa,cAAe,YAAW,OAAO,EAAE,OAAO;;IACrD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAiBpB,YACE,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,OAAO,EACd,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,UAAU,EAClB,iBAAiB,EAAE,eAAe,EAwBnC;IAED,GAAG,SAGF;IAED,KAAK,SAMJ;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,eAAe,CACb,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,UAAU,GAAG,SAAS,EAChC,qBAAqB,UAAQ,GAC5B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAqBpC;IAED,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnB;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBpB;CACF;AAID,wBAAsB,eAAe,CACnC,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,UAAU,GAAG,SAAS,EAChC,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,OAAO,EACd,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,QAAQ,EAClB,eAAe,EAAE,eAAe,EAChC,SAAS,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,cAAc;AACtD,qBAAqB,UAAQ,GAC5B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAwIpC;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,mBAAmB,EACvB,QAAQ,EAAE,UAAU,GAAG,SAAS,EAChC,KAAK,EAAE,OAAO,EACd,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,eAAe,iBAgE5B;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,QAAQ,CAAC,cAAc,EAC3B,MAAM,EAAE,QAAQ,GACf,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAKvC;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,QAAQ,CAAC,cAAc,EAC3B,GAAG,EAAE,QAAQ,GACZ,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAOvC"}