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

package/out/zero-cache/src/services/replicator/incremental-sync.d.ts

@@ -1,25 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Source } from '../../types/streams.ts';
-import type { ReservationFollowup } from '../change-streamer/change-streamer-http.ts';
-import { type ChangeStreamer } from '../change-streamer/change-streamer.ts';
-import { type SwitchoverOptions } from './drain-handler.ts';
-import { type ReplicationStatusPublisher } from './replication-status.ts';
-import type { ReplicaState, ReplicatorMode } from './replicator.ts';
-import { type ReplicationLagReadinessOptions } from './reporter/recorder.ts';
-import type { WriteWorkerClient } from './write-worker-client.ts';
-/**
- * The {@link IncrementalSyncer} manages a logical replication stream from upstream,
- * handling application lifecycle events (start, stop) and retrying the
- * connection with exponential backoff. The actual handling of the logical
- * replication messages is done by the {@link ChangeProcessor}, which runs
- * in a worker thread via the {@link WriteWorkerClient}.
- */
-export declare class IncrementalSyncer {
-    #private;
-    constructor(lc: LogContext, taskID: string, id: string, changeStreamer: ChangeStreamer, worker: WriteWorkerClient, mode: ReplicatorMode, statusPublisher: ReplicationStatusPublisher | null, replicationLagReadinessOptions?: ReplicationLagReadinessOptions, initialConnection?: ReservationFollowup, switchover?: SwitchoverOptions);
-    ready(): Promise<void>;
-    run(): Promise<void>;
-    subscribe(): Source<ReplicaState>;
-    stop(lc: LogContext, err?: unknown): void;
-}
-//# sourceMappingURL=incremental-sync.d.ts.map

package/out/zero-cache/src/services/replicator/incremental-sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"incremental-sync.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/incremental-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAOjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAGnD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,uCAAuC,CAAC;AAM/C,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAC,YAAY,EAAE,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,wBAAwB,CAAC;AAIhC,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAchE;;;;;;GAMG;AACH,qBAAa,iBAAiB;;IA2B5B,YACE,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,cAAc,EACpB,eAAe,EAAE,0BAA0B,GAAG,IAAI,EAClD,8BAA8B,GAAE,8BAAmC,EACnE,iBAAiB,CAAC,EAAE,mBAAmB,EACvC,UAAU,CAAC,EAAE,iBAAiB,EAuB/B;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAEK,GAAG,kBAsSR;IA6BD,SAAS,IAAI,MAAM,CAAC,YAAY,CAAC,CAEhC;IAqCD,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,OAAO,QAIjC;CACF"}

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

@@ -1,9 +0,0 @@
-import { type Result, Subscription } from '../../types/subscription.ts';
-import type { ReplicaState, ReplicaStateNotifier } from './replicator.ts';
-export declare class Notifier implements ReplicaStateNotifier {
-    #private;
-    get latestState(): ReplicaState | undefined;
-    subscribe(): Subscription<ReplicaState>;
-    notifySubscribers(state?: ReplicaState): Promise<Result>[];
-}
-//# sourceMappingURL=notifier.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"notifier.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/notifier.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,MAAM,EACX,YAAY,EACb,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAC,YAAY,EAAE,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAqCxE,qBAAa,QAAS,YAAW,oBAAoB;;IAInD,IAAI,WAAW,IAAI,YAAY,GAAG,SAAS,CAE1C;IAyBD,SAAS,IAAI,YAAY,CAAC,YAAY,CAAC,CAStC;IAED,iBAAiB,CACf,KAAK,GAAE,YAAuC,GAC7C,OAAO,CAAC,MAAM,CAAC,EAAE,CAMnB;CACF"}

package/out/zero-cache/src/services/replicator/replication-status.d.ts

@@ -1,71 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { JSONObject } from '../../../../zero-events/src/json.ts';
-import type { IndexingStatus, ReplicationStage, ReplicationState, ReplicationStatusEvent, Status } from '../../../../zero-events/src/status.ts';
-import { Database } from '../../../../zqlite/src/db.ts';
-import type { LiteIndexSpec } from '../../db/specs.ts';
-import { publishCriticalEvent } from '../../observability/events.ts';
-export type GrowthOptions = {
-    /** How often to check the replica size. */
-    pollMs?: number;
-    /** Republish when the replica grew by at least this many bytes ... */
-    minDeltaBytes?: number;
-    /** ... and by at least this fraction of the last published size. */
-    minDeltaRatio?: number;
-};
-export declare class ReplicationStatusPublisher {
-    #private;
-    static forTesting(): ReplicationStatusPublisher;
-    static forRunningTransaction(tx: Database, publishFn?: typeof publishCriticalEvent): ReplicationStatusPublisher;
-    static forReplicaFile(file: string, publishFn?: typeof publishCriticalEvent): ReplicationStatusPublisher;
-    constructor(dbRunner: <T>(lc: LogContext, fn: (db: Database) => T) => T, publishFn?: typeof publishCriticalEvent);
-    publish(lc: LogContext, stage: ReplicationStage, description?: string, interval?: number, extraState?: () => Partial<ReplicationState>, now?: Date): this;
-    /**
-     * Like {@link publish}, but waits (for at most `maxWaitMs`) for the event
-     * to be sent. Use this before a long synchronous operation (e.g. creating
-     * an index) that blocks the event loop and would otherwise prevent the
-     * event from being sent until the operation completes.
-     */
-    publishAndFlush(lc: LogContext, stage: ReplicationStage, description?: string, interval?: number, extraState?: () => Partial<ReplicationState>, maxWaitMs?: number): Promise<void>;
-    /**
-     * Republishes the last published status whenever the replica has grown by
-     * the given delta since the last published `replicaSize`, until
-     * {@link stop}. Consumers (e.g. Cloud Zero, which sizes the disk requests of
-     * replicas from it) thereby see growth from any source, not only from
-     * backfills and initial syncs. The status interval of {@link publish} keeps
-     * running alongside.
-     */
-    watchGrowth(lc: LogContext, options?: GrowthOptions): this;
-    publishAndThrowError(lc: LogContext, stage: ReplicationStage, e: unknown): Promise<never>;
-    /** Stops the status interval and the growth watch. */
-    stop(): this;
-}
-/**
- * Tracks the progress of a sequence of index creations for reporting in
- * the `indexingStatus` field of {@link ReplicationState}.
- */
-export declare class IndexingProgress {
-    #private;
-    /**
-     * @param totalIndexes The total number of indexes to be created, if known.
-     */
-    constructor(totalIndexes?: number, now?: () => number);
-    /** Marks the start of creating the `index`. */
-    start(index: LiteIndexSpec): void;
-    /**
-     * Restarts the timer of the current index, e.g. to exclude time spent
-     * reporting its start from its creation time.
-     */
-    restartTimer(): void;
-    /**
-     * Marks the completion of the index passed to the last call to
-     * {@link start}, returning the milliseconds it took to create.
-     */
-    finish(): number;
-    /** The `extraState` for {@link ReplicationStatusPublisher.publish}. */
-    readonly state: () => Partial<ReplicationState>;
-    status(): IndexingStatus | undefined;
-}
-export declare function publishReplicationError(lc: LogContext, stage: ReplicationStage, description: string, errorDetails?: JSONObject, now?: Date): Promise<void>;
-export declare function replicationStatusError(lc: LogContext, stage: ReplicationStage, e: unknown, db?: Database, now?: Date): ReplicationStatusEvent;
-export declare function replicationStatusEvent(lc: LogContext, db: Database | undefined, stage: ReplicationStage, status: Status, description?: string, now?: Date): ReplicationStatusEvent;
-//# sourceMappingURL=replication-status.d.ts.map

package/out/zero-cache/src/services/replicator/replication-status.d.ts.map

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

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

@@ -1,86 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { ReadonlyJSONObject } from '../../../../shared/src/json.ts';
-import type { Source } from '../../types/streams.ts';
-import type { ReservationFollowup } from '../change-streamer/change-streamer-http.ts';
-import type { ChangeStreamer } from '../change-streamer/change-streamer.ts';
-import type { Service } from '../service.ts';
-import type { SwitchoverOptions } from './drain-handler.ts';
-import { type ReplicationStatusPublisher } from './replication-status.ts';
-import type { ReplicationLagReadinessOptions } from './reporter/recorder.ts';
-import type { WriteWorkerClient } from './write-worker-client.ts';
-/** See {@link ReplicaStateNotifier.subscribe()}. */
-export type ReplicaState = {
-    readonly state: 'version-ready';
-    /**
-     * The replica watermark that became ready. Omitted for the initial
-     * "current state is ready" notification, which should not count as newly
-     * unserved work for a freshly-started ViewSyncer.
-     */
-    readonly watermark?: string | undefined;
-    /**
-     * Millisecond epoch when `watermark` became ready to read from the replica.
-     */
-    readonly replicaReadyTimeMs?: number | undefined;
-    /**
-     * Millisecond epoch at which the transaction behind `watermark` committed
-     * *upstream*, as reported by the ChangeSource. Unlike `replicaReadyTimeMs`,
-     * which is stamped locally when the change lands in the replica, this is the
-     * origin of the whole pipeline, so `now - upstreamCommitTimeMs` at the point
-     * the change is poked to clients is the end-to-end serving lag.
-     *
-     * Note that this crosses a clock domain: it comes from the upstream
-     * database, whereas it is subtracted from the local clock in the ViewSyncer.
-     * The existing `zero.replication.total_lag` metric spans the same boundary.
-     *
-     * Undefined when the ChangeSource does not report a commit time, and for the
-     * initial "current state is ready" notification.
-     */
-    readonly upstreamCommitTimeMs?: number | undefined;
-    readonly testSeqNum?: number | undefined;
-};
-export interface ReplicaStateNotifier {
-    /**
-     * Creates a cancelable subscription of changes in the replica state.
-     *
-     * A `version-ready` message indicates that the replica is ready to be
-     * read, and henceforth that a _new_ version is ready, i.e. whenever a
-     * change is committed to the replica. The `version-ready` message itself
-     * otherwise contains no other information; the subscriber queries the
-     * replica for the current data.
-     *
-     * A `maintenance` state indicates that the replica should not be read from.
-     * If a subscriber is holding any transaction locks, it should release them
-     * until the next `version-ready` signal.
-     *
-     * Upon subscription, the current state of the replica is sent immediately
-     * if known. If multiple notifications occur before the subscriber
-     * can consume them, all but the last notification are discarded by the
-     * Subscription object (i.e. not buffered). Thus, a subscriber only
-     * ever consumes the current (i.e. known) state of the replica. This avoids
-     * a buildup of "work" if a subscriber is too busy to consume all
-     * notifications.
-     */
-    subscribe(): Source<ReplicaState>;
-}
-export interface Replicator extends ReplicaStateNotifier {
-    /**
-     * Returns an opaque message for human-readable consumption. This is
-     * purely for ensuring that the Replicator has started at least once to
-     * bootstrap a new replica.
-     */
-    status(): Promise<ReadonlyJSONObject>;
-}
-export type ReplicatorMode = 'backup' | 'serving';
-export declare class ReplicatorService implements Replicator, Service {
-    #private;
-    readonly id: string;
-    constructor(lc: LogContext, taskID: string, id: string, mode: ReplicatorMode, changeStreamer: ChangeStreamer, worker: WriteWorkerClient, statusPublisher: ReplicationStatusPublisher | null, replicationLagReadinessOptions?: ReplicationLagReadinessOptions, initialConnection?: ReservationFollowup, switchover?: SwitchoverOptions);
-    status(): Promise<{
-        status: string;
-    }>;
-    ready(): Promise<void>;
-    run(): Promise<void>;
-    subscribe(): Source<ReplicaState>;
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=replicator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"replicator.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/replicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AACvE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,4CAA4C,CAAC;AACpF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uCAAuC,CAAC;AAC1E,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAE1D,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAC,8BAA8B,EAAC,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAEhE,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC;;OAEG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEjD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAInD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,IAAI,MAAM,CAAC,YAAY,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACvC;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElD,qBAAa,iBAAkB,YAAW,UAAU,EAAE,OAAO;;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAOpB,YACE,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,cAAc,EACpB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,iBAAiB,EACzB,eAAe,EAAE,0BAA0B,GAAG,IAAI,EAClD,8BAA8B,GAAE,8BAAmC,EAKnE,iBAAiB,CAAC,EAAE,mBAAmB,EACvC,UAAU,CAAC,EAAE,iBAAiB,EAqB/B;IAED,MAAM;;OAEL;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAED,GAAG,kBAYF;IAED,SAAS,IAAI,MAAM,CAAC,YAAY,CAAC,CAEhC;IAEK,IAAI,kBAOT;CACF"}

package/out/zero-cache/src/services/replicator/reporter/recorder.d.ts

@@ -1,55 +0,0 @@
-import type { ObservableResult } from '@opentelemetry/api';
-import type { LogContext } from '@rocicorp/logger';
-import type { ReplicationReport } from './report-schema.ts';
-export type ReplicationLagReadinessOptions = {
-    readinessThresholdMs?: number | undefined;
-    maxReadinessDelayMs?: number | undefined;
-    setTimeoutFn?: typeof setTimeout | undefined;
-    clearTimeoutFn?: typeof clearTimeout | undefined;
-};
-export declare class ReplicationReportRecorder {
-    #private;
-    constructor(lc: LogContext, { readinessThresholdMs, maxReadinessDelayMs, setTimeoutFn, clearTimeoutFn, }?: ReplicationLagReadinessOptions);
-    ready(): Promise<void>;
-    record(report: ReplicationReport): void;
-    readonly reportUpstreamLag: (o: ObservableResult) => void;
-    readonly reportReplicaLag: (o: ObservableResult) => void;
-    readonly reportTotalLag: (o: ObservableResult) => void;
-    readonly reportLastTotalLag: (o: ObservableResult) => void;
-    readonly reportUpstreamClockSkew: (o: ObservableResult) => void;
-}
-/**
- * Estimates how far the upstream database's clock is from ours, in
- * milliseconds, positive meaning upstream is ahead.
- *
- * `sendTimeMs` and `receiveTimeMs` are both stamped in the
- * replication-manager, either side of `commitTimeMs`, which upstream stamps.
- * Assuming the upstream commit fell midway through that round trip, the
- * difference between where it actually landed and that midpoint is the clock
- * offset -- the same round-trip estimate NTP uses.
- *
- * The estimate is biased by any asymmetry between the two legs: the outbound
- * leg is a SQL round trip, while the return leg additionally waits on a WAL
- * flush and the walsender (which the pre-PG-17 path notes can add 50~100ms on
- * an idle database). So treat this as a detector of gross skew -- the kind
- * that invalidates sync.e2e_serving_lag -- and not as a sub-100ms correction.
- *
- * The rigorous bound, if a tighter reading is ever needed: the commit
- * genuinely happened between send and receive, so a `commitTimeMs` outside
- * that window proves skew of at least the amount by which it falls outside,
- * independent of any latency assumption.
- */
-export declare function estimateUpstreamClockSkewMs({ sendTimeMs, commitTimeMs, receiveTimeMs, }: {
-    sendTimeMs: number;
-    commitTimeMs: number;
-    receiveTimeMs: number;
-}): number;
-/**
- * Returns whether the `report` is the signal sent by the change-streamer,
- * once the subscriber is caught up, to indicate that lag reporting is
- * disabled upstream (and thus readiness cannot be gated on lag reports).
- *
- * This is a lag report with a `nextSendTimeMs` of 0 and no `lastTimings`.
- */
-export declare function isLagReportingDisabledSignal(report: ReplicationReport): boolean;
-//# sourceMappingURL=recorder.d.ts.map

package/out/zero-cache/src/services/replicator/reporter/recorder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/replicator/reporter/recorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAG3D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAM1D,MAAM,MAAM,8BAA8B,GAAG;IAC3C,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,YAAY,CAAC,EAAE,OAAO,UAAU,GAAG,SAAS,CAAC;IAC7C,cAAc,CAAC,EAAE,OAAO,YAAY,GAAG,SAAS,CAAC;CAClD,CAAC;AAEF,qBAAa,yBAAyB;;IASpC,YACE,EAAE,EAAE,UAAU,EACd,EACE,oBAA2B,EAC3B,mBAA6B,EAC7B,YAAyB,EACzB,cAA6B,GAC9B,GAAE,8BAAmC,EAgBvC;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAED,MAAM,CAAC,MAAM,EAAE,iBAAiB,QAsC/B;IA0DD,QAAQ,CAAC,iBAAiB,MAAO,gBAAgB,UAK/C;IAEF,QAAQ,CAAC,gBAAgB,MAAO,gBAAgB,UAK9C;IAEF,QAAQ,CAAC,cAAc,MAAO,gBAAgB,UAK5C;IAEF,QAAQ,CAAC,kBAAkB,MAAO,gBAAgB,UAKhD;IAEF,QAAQ,CAAC,uBAAuB,MAAO,gBAAgB,UAKrD;CACH;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,UAAU,EACV,YAAY,EACZ,aAAa,GACd,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAET"}

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

@@ -1,132 +0,0 @@
-/**
- * Observability for the SQLite change log.
- *
- * Everything here now runs in the **change-streamer** process, which is where
- * the writer lives. The module stays beside the rest of the change-log code
- * under `services/replicator/` for the same reason `change-log-db.ts` and
- * `change-log-stream-writer.ts` do: moving files would obscure the topology
- * diff, and the writer's home is a property of who calls it rather than of
- * where it sits. Metric names are unchanged from 7H — only their emitting
- * process, and therefore their resource attributes, moved.
- */
-import type { LogContext } from '@rocicorp/logger';
-import type { Database } from '../../../../zqlite/src/db.ts';
-import type { ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
-import { type CookieOpTag, type CookieRowCounts } from './change-log-cookies.ts';
-import { type ChangeLogMeta, type ReconcileResult } from './change-log-db.ts';
-import type { ChangeLogStreamTransactionStats } from './change-log-stream-writer.ts';
-/**
- * Reports the reconciliation of the change-log database against the watermark
- * the stream connection resumes from. This runs once per stream connection, so
- * a reconnect storm is visible here as well as a restart.
- *
- * A wipe is not an error — it is how every abnormal change-log state is
- * collapsed into a correct one — but each wipe costs the retention window, so
- * every reconnecting subscriber below the head gets `too-old`. The `gap` reason
- * in particular means the log neither held the resume watermark nor could be
- * truncated to it, so a nonzero rate in steady state is an alert, not a
- * statistic.
- */
-export declare function recordSQLiteChangeLogReconcile(lc: LogContext, result: ReconcileResult): void;
-/**
- * What the log says about itself. Nothing here reads the replica: after the
- * writer moved to the change-streamer, the replica's state version is a
- * consequence of this log rather than a fact about it.
- */
-export type SQLiteChangeLogStartupInfo = ChangeLogMeta & {
-    readonly minWatermark: string;
-    readonly headWatermark: string;
-};
-export type SQLiteChangeLogInfo = SQLiteChangeLogStartupInfo & {
-    readonly rows: number;
-    readonly estimatedBytes: number;
-    readonly cookieRows: CookieRowCounts;
-};
-/**
- * Reads the meta row and covered range. Unlike {@link getSQLiteChangeLogInfo}
- * this does not scan the log; see {@link readChangeLogBounds}.
- *
- * Call this after reconciliation, which is the only point at which the head is
- * known to be the resume watermark.
- */
-export declare function getSQLiteChangeLogStartupInfo(changeLog: Database): SQLiteChangeLogStartupInfo;
-/**
- * Extends {@link getSQLiteChangeLogStartupInfo} with the retained row and
- * estimated byte totals. Computing these scans the entire change-log table, so
- * only call it when the totals are consumed, i.e. when the writer (and thus the
- * observer) is enabled.
- */
-export declare function getSQLiteChangeLogInfo(changeLog: Database): SQLiteChangeLogInfo;
-export declare function logSQLiteChangeLogStartup(lc: LogContext, file: string, info: SQLiteChangeLogStartupInfo): void;
-/**
- * The on-disk footprint of a SQLite database: its main file plus its `-wal` and
- * `-wal2` sidecars, whichever exist. `-shm` is excluded — it is a
- * shared-memory index rather than retained bytes.
- *
- * A missing file counts as zero rather than warning. Which sidecars exist
- * depends on the journal mode, and the change-log database is absent entirely
- * until the writer creates it.
- */
-export declare function sqliteFileBytes(lc: LogContext, file: string): Promise<number>;
-/** What the writer reports back for a committed transaction. */
-export type ChangeLogCommit = {
-    readonly watermark: string;
-    readonly stats: ChangeLogStreamTransactionStats;
-    /**
-     * Appending the commit row and committing the log's transaction. This is the
-     * cost that sits on the forward path, once per upstream transaction.
-     */
-    readonly logCommitMs: number;
-};
-export type SQLiteChangeLogObservabilityState = {
-    readonly receivedHead: string;
-    readonly sqliteHead: string;
-    readonly headLag: number | undefined;
-    readonly rows: number;
-    readonly estimatedBytes: number;
-    readonly cookieRows: CookieRowCounts;
-    readonly cookieMutations: number;
-    readonly rollbacks: number;
-    readonly invariantFailures: number;
-    readonly hashMatches: number;
-    readonly hashMismatches: number;
-    readonly hashUnpaired: number;
-};
-/**
- * Records writer metrics in the change-streamer process. State changes only
- * after the corresponding write succeeds, except receivedHead, which advances
- * when a commit message arrives so that transient lag behind the log is
- * observable.
- */
-export declare class SQLiteChangeLogObserver {
-    #private;
-    constructor(lc: LogContext, info: SQLiteChangeLogInfo);
-    /**
-     * Called as each message arrives, before it is written. For a sampled
-     * transaction, hashes the *received* stream and compares it with the hash the
-     * writer computes over what it *stored*.
-     */
-    messageReceived(data: ChangeStreamData, json: string, validateHash?: boolean, storedChange?: string): void;
-    /** Called after the message has been written to the log. */
-    messageProcessed(data: ChangeStreamData, commit: ChangeLogCommit | null, durationMs: number | undefined): void;
-    messageFailed(data: ChangeStreamData, error: unknown, durationMs: number | undefined): void;
-    /**
-     * A committed transaction folded schema changes into the cookie jar. Reported
-     * separately from {@link messageProcessed} because it costs a read of the
-     * cookie tables, which is only worth taking when they actually moved.
-     */
-    cookiesMutated(ops: readonly CookieOpTag[], rows: CookieRowCounts): void;
-    /**
-     * A missed truncate-above surfaces as a constraint violation on the writer's
-     * plain `INSERT`, which the fail-soft policy would otherwise absorb quietly.
-     * Classifying it as an invariant failure is what keeps a reconciliation bug
-     * from looking like a lost cache.
-     */
-    invariantFailure(message: string, details?: Record<string, unknown>): void;
-    /** The source interrupted the stream mid-transaction. */
-    abort(): void;
-    /** Reconciliation moved the head, so the observer's totals are restated. */
-    reconciled(info: SQLiteChangeLogInfo): void;
-    state(): SQLiteChangeLogObservabilityState;
-}
-//# sourceMappingURL=sqlite-change-log-observability.d.ts.map

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

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

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

@@ -1,120 +0,0 @@
-/**
- * Deletes aged-out transactions from the change-log database, one bounded write
- * transaction at a time.
- *
- * The purger is a pure function of one database: it takes the floors its caller
- * has already gated on and narrows them, never widens them, and it reads no
- * replication state. That is what makes it testable without a scheduler and
- * what lets slice 9 run it from the change-streamer's stream loop, between the
- * writer's commits, on the writer's own connection.
- */
-import type { Database } from '../../../../zqlite/src/db.ts';
-/**
- * The eligible set, as three ANDed bounds. Only the `externalFloor` is a safety
- * property; the other two make the log serviceable and make purge conservative.
- *
- * `"watermark" < @externalFloor` is deliberately strict. A follower that lost
- * its replica restores it from S3 at watermark `W` and then asks this log for
- * everything after `W`, which requires the `commit` row *at* `W` to still be
- * here (`SQLITE_CHANGE_LOG_BOUNDARY_SQL`). Deleting it returns `too-old` to the
- * very subscriber the floor exists to protect.
- *
- * The head cap reads `max("watermark")` from the log's own database, which
- * keeps the purger a pure function of one file. The cap is inert in normal
- * operation: the floor is derived from a backup of a replica that consumes this
- * loop's output, and the log commits before that output is forwarded, so
- * `externalFloor <= head` holds by construction. It engages only on a *stale*
- * log — writer stopped, mode flipped to `off`, another task took over — where
- * deleting to a floor that has run past a frozen log would empty the file. Note
- * that head can be a phantom — committed here but not yet re-deliverable by a
- * resumed stream — for as long as it takes the watermark the stream would
- * resume from to advance past it. That is harmless precisely because head is
- * never a purge candidate, and it is why the purger asserts nothing about
- * anything outside its own file.
- *
- * Ordered by `("writeTimeMs", "watermark")` so it rides the partial index,
- * which carries one entry per transaction rather than one per change. The
- * `LIMIT` keeps a drain from re-scanning the remaining history on every batch,
- * which would be quadratic in the number of eligible transactions and would do
- * it inside the `BEGIN IMMEDIATE`, holding the write lock alongside the delete.
- *
- * Exported so the focused query-plan test covers the production query.
- */
-export declare const SQLITE_CHANGE_LOG_ELIGIBLE_COMMITS_SQL = "\n  SELECT \"watermark\"\n  FROM \"_zero.changeLogStream\"\n  WHERE \"writeTimeMs\" IS NOT NULL\n    AND \"writeTimeMs\" < @retentionCutoffMs\n    AND \"watermark\" < @externalFloor\n    AND \"watermark\" < (SELECT max(\"watermark\") FROM \"_zero.changeLogStream\")\n  ORDER BY \"writeTimeMs\", \"watermark\"\n  LIMIT @limit\n";
-/**
- * Counts the rows at `@watermark`, capped at `@limit`. The cap is what keeps
- * batch sizing O(budget): this runs per candidate inside the
- * `BEGIN IMMEDIATE`, and the transaction being sized can be arbitrarily
- * large — an uncapped count of a multi-million-row backfill would rescan
- * every remaining row on every tear batch, holding the write lock (and the
- * appending path behind it) for the duration, quadratically over the drain.
- * The caller only needs to know whether the transaction fits its remaining
- * budget, so it passes `remaining + 1` and reads a count above `remaining`
- * as "does not fit".
- *
- * Exported so the focused tests cover the production query.
- */
-export declare const SQLITE_CHANGE_LOG_COUNT_TRANSACTION_SQL = "\n  SELECT count(*) AS \"rows\" FROM (\n    SELECT 1\n    FROM \"_zero.changeLogStream\"\n    WHERE \"watermark\" = @watermark\n    LIMIT @limit\n  )\n";
-export type PurgeBatchResult = {
-    readonly deletedRows: number;
-    /**
-     * The watermark through which whole transactions were removed. `undefined`
-     * when the batch only tore rows off the minimum transaction without
-     * completing it — in that case `deletedRows > 0` and `moreEligible` is true.
-     */
-    readonly deletedThrough: string | undefined;
-    /** True while a tear is in progress, as well as while whole transactions remain eligible. */
-    readonly moreEligible: boolean;
-};
-export type PurgeBatchOptions = {
-    /**
-     * The floor the caller has already gated on subscriber ACKs and snapshot
-     * reservations — normally the confirmed S3 backup watermark. Transactions at
-     * or above it are NOT durable anywhere else: the change log is excluded from
-     * the litestream backup, so this is the boundary a follower restores to and
-     * then catches up from. Compared strictly (`<`), so the transaction *at* the
-     * floor survives as that follower's catchup boundary. The purger narrows this
-     * input and never widens it.
-     */
-    readonly externalFloor: string;
-    /**
-     * A *minimum* retention, ANDed on top of `externalFloor` rather than an
-     * alternative to it. Which of the two binds depends on the backup interval.
-     */
-    readonly retentionCutoffMs: number;
-    /** Starting chunk size. Not the bound — `maxDurationMs` is. */
-    readonly maxRows: number;
-    /**
-     * The statement duration target, enforced by feedback rather than by
-     * interruption: SQLite cannot yield mid-statement, so the purger measures
-     * each delete and shrinks the next batch's row budget when one overruns
-     * (see {@link SQLiteChangeLogPurger.budgetRows}) — which means the first
-     * delete after a restart, sized by `maxRows` alone, can still overrun it.
-     * The target is this consequential because purge shares the writer's
-     * connection: there is no lock to arbitrate and no `busy_timeout` to bound
-     * the wait — a long statement blocks the appending path, and the forward
-     * behind it, directly and for its full duration. That is why this is a
-     * precondition of purging from the stream loop rather than a tuning knob.
-     */
-    readonly maxDurationMs: number;
-};
-export declare class SQLiteChangeLogPurger {
-    #private;
-    /**
-     * @param db a writable connection to a change log the writer has already
-     *     created and reconciled — in slice 9, the writer's own connection.
-     *     Statements are prepared eagerly, so a caller that may run before the
-     *     log exists opens the connection lazily and treats construction failure
-     *     as a skipped cycle.
-     */
-    constructor(db: Database, now?: () => number);
-    /** The row budget the next batch would use. Exposed for tests and metrics. */
-    get budgetRows(): number | undefined;
-    /**
-     * Removes one bounded batch of aged-out history, in one `BEGIN IMMEDIATE`
-     * transaction. Callers loop while `moreEligible`, releasing whatever guards
-     * they hold between batches.
-     */
-    purgeBatch(opts: PurgeBatchOptions): PurgeBatchResult;
-}
-//# sourceMappingURL=sqlite-change-log-purger.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite-change-log-purger.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/replicator/sqlite-change-log-purger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAC,QAAQ,EAAY,MAAM,8BAA8B,CAAC;AAGtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,sCAAsC,2UASlD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uCAAuC,4JAOnD,CAAC;AAuCF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,6FAA6F;IAC7F,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAWF,qBAAa,qBAAqB;;IAahC;;;;;;OAMG;IACH,YACE,EAAE,EAAE,QAAQ,EACZ,GAAG,GAAE,MAAM,MAA0C,EAYtD;IAED,8EAA8E;IAC9E,IAAI,UAAU,IAAI,MAAM,GAAG,SAAS,CAEnC;IAED;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,CAsBpD;CAkLF"}