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

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-purge-scheduler.d.ts

@@ -1,121 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Database } from '../../../../zqlite/src/db.ts';
-import type { SQLiteChangeLogCleanupGuard } from './sqlite-change-log-catchup.ts';
-/** Why a pass stopped before draining the eligible set. */
-export type PurgeStopReason = 'stopped' | 'paused' | 'writer-unavailable' | 'subscriber-behind' | 'batch-limit' | 'error';
-/**
- * The invariant-14 probe's classification of `plan(floor)` after a pass.
- *
- * `too-old` at the floor is not by itself a violation: a log that never held
- * that history — routine at every fork, restore, and rolling restart — returns
- * `too-old` without having purged anything. Only the seed point distinguishes
- * the two, which is why `seedWatermark` is in the v2 meta row:
- *
- * ```
- * violation  ⇔  plan(floor) is `too-old`  AND  seedWatermark <= floor
- * ```
- */
-export type FloorProbeOutcome = 'retained' | 'ahead' | 'cold-log' | 'violation';
-/** When the cleanup coordinator should run another pass. */
-export type PurgeContinuation = 'immediate' | 'deferred';
-export type PurgePassResult = {
-    /** The external floor the pass used. */
-    readonly floor: string;
-    readonly batches: number;
-    readonly deletedRows: number;
-    /** Why the pass ended before draining, if it did. */
-    readonly stopped: PurgeStopReason | undefined;
-    /** The invariant-14 probe's outcome, when the log was available to probe. */
-    readonly probe: FloorProbeOutcome | undefined;
-    /** Whether, and how soon, the cleanup coordinator should run another pass. */
-    readonly continuation: PurgeContinuation | undefined;
-};
-export type SQLiteChangeLogPurgeSchedulerOptions = {
-    /**
-     * `sqliteChangeLogRetentionMs`: the minimum retention window, ANDed on top
-     * of the external floor. It can only make purge more conservative — the
-     * purger never accepts it as a standalone bound.
-     */
-    readonly retentionMs: number;
-    /**
-     * `sqliteChangeLogPurgeBatchRows`: the starting chunk size per batch. Not
-     * the bound — the statement duration target is.
-     */
-    readonly batchRows: number;
-    readonly statementTargetMs?: number | undefined;
-    readonly maxBatchesPerPass?: number | undefined;
-    readonly inTransactionPollMs?: number | undefined;
-    /** The clock the retention cutoff is measured against. Defaults to `Date.now`. */
-    readonly now?: (() => number) | undefined;
-    readonly setTimeoutFn?: typeof setTimeout | undefined;
-    readonly clearTimeoutFn?: typeof clearTimeout | undefined;
-    /**
-     * Awaited between batches so fan-out and catchup make progress. Defaults to
-     * a macrotask (`setImmediate`), so pending I/O runs before the next batch.
-     */
-    readonly yieldFn?: (() => Promise<void>) | undefined;
-};
-/**
- * Runs bounded SQLite change-log purge passes on the writer's own connection.
- *
- * The caller supplies the current durable cleanup floor independently of any
- * other change-log implementation and owns the timing of subsequent passes.
- * Within a pass this class drains bounded batches, re-checking live subscriber
- * ACKs before each one and releasing the cleanup guard between them, so a
- * catchup registration or snapshot reservation never waits longer than one
- * batch.
- *
- * Purge windows exist only between the writer's commits: purge shares the
- * writer's connection, so it cannot run inside the writer's open transaction,
- * and a batch that finds one waits for the commit notification instead.
- *
- * The result tells the cleanup coordinator whether the next pass should be
- * immediate or deferred. This class deliberately owns no cleanup timer: the
- * same level-triggered coordinator continues a large drain, advances the
- * retention clock on a quiet source, and retries changing external state.
- */
-export declare class SQLiteChangeLogPurgeScheduler {
-    #private;
-    /**
-     * The guard that brackets catchup registration: required-head capture and
-     * `Forwarder.add()` run under the same mutex as purge batches, so the
-     * registered ACK is visible to `Forwarder.getAcks()` before the next batch
-     * evaluates its gate.
-     */
-    readonly cleanupGuard: SQLiteChangeLogCleanupGuard;
-    /**
-     * @param connection the writer's own connection (§3.3). `undefined` until
-     *     the writer's first reconcile creates the file, and again after the
-     *     writer fails soft and deletes it — both of which defer the pass rather
-     *     than fail it, so a later coordinator pass picks up a late-appearing
-     *     file without a restart.
-     * @param subscriberAcks live subscriber ACKs, re-read before every batch so
-     *     the supplied floor remains safe throughout an asynchronous drain.
-     */
-    constructor(lc: LogContext, connection: () => Database | undefined, subscriberAcks: () => Iterable<string>, opts: SQLiteChangeLogPurgeSchedulerOptions);
-    /**
-     * Runs one purge pass for the current durable cleanup `floor`.
-     * Never rejects; a failed pass is logged and reported as `stopped: 'error'`.
-     */
-    purge(floor: string): Promise<PurgePassResult>;
-    /**
-     * Pauses purging while `taskID` holds a snapshot reservation. The returned
-     * promise resolves once no purge batch is in flight, i.e. once the bounds a
-     * backup monitor is about to advertise cannot be invalidated by a batch
-     * that had already been dispatched.
-     */
-    pause(taskID: string): Promise<void>;
-    /**
-     * Ends one of `taskID`'s pauses. A later coordinator pass can purge once
-     * every reservation has ended. Unknown `taskID`s are ignored.
-     */
-    resume(taskID: string): void;
-    /**
-     * Notes that the writer's open transaction has ended, waking any batch
-     * waiting for a purge window. A missed notification costs one poll
-     * interval, never correctness.
-     */
-    onWriterIdle(): void;
-    stop(): void;
-}
-//# sourceMappingURL=sqlite-change-log-purge-scheduler.d.ts.map

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-purge-scheduler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite-change-log-purge-scheduler.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-purge-scheduler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,QAAQ,EAAY,MAAM,8BAA8B,CAAC;AAWtE,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,gCAAgC,CAAC;AA2BhF,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAEvB,SAAS,GAET,QAAQ,GAGR,oBAAoB,GAIpB,mBAAmB,GAEnB,aAAa,GAEb,OAAO,CAAC;AAEZ;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GAGzB,UAAU,GAGV,OAAO,GAIP,UAAU,GAIV,WAAW,CAAC;AAEhB,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAEzB,WAAW,GAGX,UAAU,CAAC;AAEf,MAAM,MAAM,eAAe,GAAG;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC9C,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,kFAAkF;IAClF,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,UAAU,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,YAAY,GAAG,SAAS,CAAC;IAC1D;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;CACtD,CAAC;AA0CF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,6BAA6B;;IAkExC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,2BAA2B,CAEhD;IAEF;;;;;;;;OAQG;IACH,YACE,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,QAAQ,GAAG,SAAS,EACtC,cAAc,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,EACtC,IAAI,EAAE,oCAAoC,EAoB3C;IAED;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAWnD;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnC;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAU3B;IAED;;;;OAIG;IACH,YAAY,IAAI,IAAI,CAKnB;IAED,IAAI,IAAI,IAAI,CAGX;CA8QF"}

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-read-router.d.ts

@@ -1,73 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { ShardID } from '../../types/shards.ts';
-import { type ChangeLogIdentity } from '../replicator/change-log-db.ts';
-export type ChangeLogReadSource = 'pg' | 'sqlite';
-export type SQLiteChangeLogCoverage = {
-    readonly seededAtMs: number;
-    readonly seedWatermark: string;
-    readonly minWatermark: string;
-    readonly headWatermark: string;
-};
-export type ChangeLogReadRouteReason = 'selected' | 'selected-cold' | 'percentage' | 'cold-log' | 'log-unavailable' | 'breaker-open' | 'backup-uncovered';
-export type ChangeLogReadRoute = {
-    readonly source: ChangeLogReadSource;
-    readonly reason: ChangeLogReadRouteReason;
-    readonly pinned?: boolean | undefined;
-    readonly coverage?: SQLiteChangeLogCoverage | undefined;
-};
-export type SQLiteChangeLogReadRouterOptions = {
-    readonly shard: ShardID;
-    readonly readPercent: number;
-    /**
-     * Percentage of eligible tasks served from a log that has not yet aged
-     * through {@link retentionMs}. Defaults to zero, which keeps every such
-     * task on PG.
-     */
-    readonly coldReadPercent?: number | undefined;
-    readonly retentionMs: number;
-    readonly inspect: () => SQLiteChangeLogCoverage | undefined;
-    readonly failureCooldownMs?: number | undefined;
-    readonly now?: (() => number) | undefined;
-};
-/**
- * Selects and pins the catchup source shared by `/snapshot` and `/changes`.
- *
- * A post-registration SQLite failure opens a process-local breaker. Requests
- * use PG during the cooldown; the first request after it expires is the
- * bounded probe. A successful readiness inspection closes the breaker, while
- * another unavailable result rearms it. A writer failure opens it permanently
- * because the writer remains disabled and its file stays absent for the life
- * of the process.
- */
-export declare class SQLiteChangeLogReadRouter {
-    #private;
-    constructor(opts: SQLiteChangeLogReadRouterOptions);
-    /** Chooses and pins a source for a snapshot reservation. */
-    pin(taskID: string): ChangeLogReadRoute;
-    /** Returns the source pinned by an active snapshot reservation. */
-    peek(taskID: string): ChangeLogReadRoute | undefined;
-    /** Consumes a snapshot pin, or makes the stable choice for a direct retry. */
-    consume(taskID: string): ChangeLogReadRoute;
-    /** Releases a pin whose snapshot reservation ended before subscribing. */
-    release(taskID: string): void;
-    /**
-     * Replaces a pinned SQLite route with PG, for a reservation whose backup
-     * the log cannot cover -- most often a log seeded after that backup.
-     *
-     * The pin moves, not just the reservation's advertised bounds. Confirming
-     * with PG bounds while the task's `/changes` request still resolves to
-     * SQLite is exactly the mismatch the reservation path exists to prevent,
-     * so the two have to change together.
-     *
-     * A task with no pin is left alone: `consume` makes it a fresh choice.
-     */
-    demote(taskID: string): ChangeLogReadRoute;
-    /** Opens the post-registration failure breaker. */
-    trip(permanent?: boolean): void;
-}
-/**
- * Reads the coverage and validates the v2 schema and RMv2 identity in one
- * short-lived readonly connection. It never creates the log.
- */
-export declare function inspectSQLiteChangeLog(lc: LogContext, changeLogFile: string, identity: ChangeLogIdentity): SQLiteChangeLogCoverage | undefined;
-//# sourceMappingURL=sqlite-change-log-read-router.d.ts.map

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-read-router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite-change-log-read-router.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-read-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,gCAAgC,CAAC;AAGxC,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,QAAQ,CAAC;AAElD,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAChC,UAAU,GAIV,eAAe,GACf,YAAY,GACZ,UAAU,GACV,iBAAiB,GACjB,cAAc,GAId,kBAAkB,CAAC;AAEvB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,uBAAuB,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C,CAAC;AAIF;;;;;;;;;GASG;AACH,qBAAa,yBAAyB;;IAapC,YAAY,IAAI,EAAE,gCAAgC,EASjD;IAED,4DAA4D;IAC5D,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAItC;IAED,mEAAmE;IACnE,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAGnD;IAED,8EAA8E;IAC9E,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAO1C;IAED,0EAA0E;IAC1E,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE5B;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CASzC;IAED,mDAAmD;IACnD,IAAI,CAAC,SAAS,UAAQ,GAAG,IAAI,CAS5B;CA6DF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,UAAU,EACd,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,iBAAiB,GAC1B,uBAAuB,GAAG,SAAS,CAgCrC"}

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

@@ -1,62 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { WatermarkedChange } from './change-streamer.ts';
-export type CatchupPlan = {
-    readonly kind: 'range';
-    readonly minWatermark: string;
-    readonly headWatermark: string;
-} | {
-    readonly kind: 'ahead';
-    readonly headWatermark: string;
-} | {
-    readonly kind: 'too-old';
-    readonly minWatermark: string;
-    readonly headWatermark: string;
-} | {
-    readonly kind: 'not-ready';
-};
-/**
- * Seeks to the final position so validating a boundary does not scan every row
- * of a large transaction. Exported so the focused query-plan test covers the
- * production subquery.
- */
-export declare const SQLITE_CHANGE_LOG_BOUNDARY_SQL = "\n  SELECT\n    \"precommit\" = @fromWatermark AND\n      \"tag\" = 'commit' AS \"boundaryExists\"\n  FROM \"_zero.changeLogStream\"\n  WHERE \"watermark\" = @fromWatermark\n  ORDER BY \"pos\" DESC\n  LIMIT 1\n";
-/**
- * The log describes its own bounds; nothing here reads the replica.
- * `max("watermark")` is the head because a transaction's rows commit atomically,
- * so the log never ends mid-transaction.
- *
- * `min` and `max` are deliberately kept as *separate* scalar subqueries: SQLite
- * applies its single-aggregate index optimization only when the aggregate is
- * alone in its query, so `SELECT min(x), max(x) FROM t` degrades to a full scan
- * while two scalar subqueries are two index seeks. The query-plan test pins
- * this.
- *
- * Exported so that test can cover the production query.
- */
-export declare const SQLITE_CHANGE_LOG_PLAN_SQL = "\n  SELECT\n    (SELECT max(\"watermark\") FROM \"_zero.changeLogStream\")\n      AS \"headWatermark\",\n    (SELECT min(\"watermark\") FROM \"_zero.changeLogStream\")\n      AS \"minWatermark\",\n    coalesce((\n  SELECT\n    \"precommit\" = @fromWatermark AND\n      \"tag\" = 'commit' AS \"boundaryExists\"\n  FROM \"_zero.changeLogStream\"\n  WHERE \"watermark\" = @fromWatermark\n  ORDER BY \"pos\" DESC\n  LIMIT 1\n), 0) AS \"boundaryExists\"\n";
-/** Exported so the focused query-plan test covers the production query. */
-export declare const SQLITE_CHANGE_LOG_READ_BATCH_SQL = "\n  SELECT\n    \"watermark\",\n    \"pos\",\n    \"tag\",\n    \"change\"\n  FROM \"_zero.changeLogStream\"\n  WHERE (\"watermark\", \"pos\") > (?, ?)\n    AND \"watermark\" <= ?\n  ORDER BY \"watermark\", \"pos\"\n  LIMIT ?\n";
-/**
- * Reads the change log without retaining a SQLite snapshot while a consumer
- * processes a batch.
- *
- * The log lives in its own database beside the replica
- * (`changeLogFileName(replicaFile)`), which this reader opens read-only; it
- * never opens the replica. The connection therefore keeps the journal mode
- * configured by the change-log writer. Callers pin a head with {@link plan}
- * before passing it to {@link read}.
- *
- * A change-streamer can start before the replicator has created the log, so the
- * stream table may not exist yet. Statements are prepared on first use rather
- * than in the constructor, and {@link plan} reports `not-ready` until they can
- * be; a reader constructed too early becomes usable once the writer catches up.
- */
-export declare class SQLiteChangeLogReader implements Disposable {
-    #private;
-    constructor(lc: LogContext, changeLogFile: string);
-    plan(fromWatermark: string): CatchupPlan;
-    read(fromWatermark: string, throughWatermark: string, batchSize: number, signal?: AbortSignal | undefined, maxRows?: number | undefined): AsyncIterable<readonly WatermarkedChange[]>;
-    close(): void;
-    [Symbol.dispose](): void;
-}
-//# sourceMappingURL=sqlite-change-log-reader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite-change-log-reader.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAMjD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAE5D,MAAM,MAAM,WAAW,GACnB;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,GACD;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;CAAC,GACxD;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,GAKD;IAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAC,CAAC;AAqBjC;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,uNAQ1C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B,ucAOtC,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,gCAAgC,wOAW5C,CAAC;AAMF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAsB,YAAW,UAAU;;IAKtD,YAAY,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,EAMhD;IAED,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,WAAW,CAmBvC;IAEM,IAAI,CACT,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,EAChC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAC3B,aAAa,CAAC,SAAS,iBAAiB,EAAE,CAAC,CA2E7C;IAED,KAAK,IAAI,IAAI,CAMZ;IAED,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAEvB;CAqCF"}

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

@@ -1,114 +0,0 @@
-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 ChangeLogIdentity, type ChangeLogResumePoint } from '../replicator/change-log-db.ts';
-import { type SQLiteChangeLogObservabilityState } from '../replicator/sqlite-change-log-observability.ts';
-export type SQLiteChangeLogWriterOptions = {
-    /** The replica file the log is named after, i.e. `${replicaFile}-change-log`. */
-    replicaFile: string;
-    /** The replica whose contents this log belongs to. */
-    identity: ChangeLogIdentity;
-    /**
-     * Called after each transaction's log commit, with the log's new head. This
-     * is what releases the catchup barrier: after the writer moved in-process,
-     * the head advances here rather than at a subscriber's ACK.
-     */
-    onCommit?: ((watermark: string) => void) | undefined;
-    /**
-     * Called when the writer disables itself and deletes the file. The reader is
-     * cached on the service, so a delete that leaves it open would leave an
-     * in-process reader serving an unlinked inode while every new open sees
-     * nothing.
-     */
-    onDisabled?: (() => void) | undefined;
-    /** Called when reconciliation replaces the file, to close cached readers. */
-    onRebuilt?: (() => void) | undefined;
-    /** Overridable for tests. */
-    now?: (() => number) | undefined;
-    /**
-     * Percentage of transactions that retain the rollout-only per-message
-     * timing and source-vs-stored hash validation. Defaults to 1.
-     */
-    shadowValidationPercent?: number | undefined;
-};
-/**
- * Appends the canonical change stream to the SQLite change log, from the
- * change-streamer's own stream loop.
- *
- * ### Ordering
- *
- * The log's commit for a transaction precedes the forward of that transaction's
- * `commit` message, and nothing `await`s in between. Everything that can
- * advance the watermark the stream would resume from — the storer's Postgres
- * commit, `lastWatermark`, the upstream ACK — runs strictly after it, so the
- * log's head is always at or above the resume point. A *hole* is therefore
- * unreachable at any crash timing, and a *phantom* is the normal state, which is
- * what makes truncate-above the whole of reconciliation.
- *
- * ### Fail-soft
- *
- * The log is a catchup cache: nothing in it is not either already durable in the
- * replica's litestream backup or re-derivable from the replication slot. A write
- * failure must therefore not stop replication for the shard. Corruption is
- * rebuilt once at open; any other write error — a full disk, an I/O error, a
- * permissions problem — logs, disables the writer, deletes the file, closes the
- * reader, and lets the stream continue. The cost is catchup reach, and reach is
- * recoverable: `too-old` sends a subscriber to a restore.
- *
- * One carve-out keeps that from hiding the bug class this topology introduces. A
- * missed truncate-above surfaces as `SQLITE_CONSTRAINT` on the writer's plain
- * `INSERT`, which is "any write error other than corruption" and would be
- * absorbed quietly. It is counted as an invariant failure and alerted on before
- * failing soft.
- */
-export declare class SQLiteChangeLogWriter {
-    #private;
-    constructor(lc: LogContext, opts: SQLiteChangeLogWriterOptions);
-    /** False once the writer has failed soft, or after {@link close}. */
-    get enabled(): boolean;
-    /**
-     * The writer's own connection, which is the one purge runs on (§3.3): one
-     * process appends *and* deletes, on one handle, with no second writable
-     * connection and no cross-process barrier. `undefined` until the stream
-     * loop's first reconcile creates the log, and again once the writer has
-     * failed soft and deleted the file — both of which a purge cycle treats as
-     * "skip", not as an error.
-     */
-    get connection(): Database | undefined;
-    /** Exposed for tests and for the integration assertions on the metrics. */
-    state(): SQLiteChangeLogObservabilityState | undefined;
-    /**
-     * Opens the log if necessary and reconciles it with the Postgres resume
-     * point. Returns the resume point stored in the log.
-     *
-     * Returns `undefined` when the writer is disabled. The caller must then use
-     * another source.
-     *
-     * This runs for every connection because Postgres supplies a new resume point
-     * after each reconnect. The log can contain transactions above that point.
-     * Reconciliation removes them before Postgres sends them again.
-     *
-     * `resumeFrom` includes cookies because the cookies must match the resume
-     * watermark.
-     */
-    reconcile(resumeFrom: ChangeLogResumePoint): ChangeLogResumePoint | undefined;
-    /**
-     * Reconciles the log without a Postgres resume point.
-     *
-     * A valid log uses its own head and cookies. A new or invalid log uses the
-     * replica values returned by `seed`.
-     */
-    reconcileFromLog(seed: () => ChangeLogResumePoint): ChangeLogResumePoint | undefined;
-    /**
-     * Writes one stream message, committing at transaction boundaries. Never
-     * throws: a write failure disables the writer instead of failing the stream.
-     */
-    write(change: ChangeStreamData, json: string, storedChange?: string): void;
-    /**
-     * Discards the open transaction, if any. Called when the change stream is
-     * interrupted mid-transaction.
-     */
-    abort(): void;
-    close(): void;
-}
-//# sourceMappingURL=sqlite-change-log-writer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite-change-log-writer.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,8BAA8B,CAAC;AAM3D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AAKtF,OAAO,EAUL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAE1B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAML,KAAK,iCAAiC,EACvC,MAAM,kDAAkD,CAAC;AAG1D,MAAM,MAAM,4BAA4B,GAAG;IACzC,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,QAAQ,EAAE,iBAAiB,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACrD;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IACtC,6EAA6E;IAC7E,SAAS,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IACrC,6BAA6B;IAC7B,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IACjC;;;OAGG;IACH,uBAAuB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9C,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,qBAAqB;;IAYhC,YAAY,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,4BAA4B,EAY7D;IAED,qEAAqE;IACrE,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,QAAQ,GAAG,SAAS,CAErC;IAED,2EAA2E;IAC3E,KAAK,IAAI,iCAAiC,GAAG,SAAS,CAErD;IAED;;;;;;;;;;;;;OAaG;IACH,SAAS,CACP,UAAU,EAAE,oBAAoB,GAC/B,oBAAoB,GAAG,SAAS,CAElC;IAED;;;;;OAKG;IACH,gBAAgB,CACd,IAAI,EAAE,MAAM,oBAAoB,GAC/B,oBAAoB,GAAG,SAAS,CAElC;IA2GD;;;OAGG;IACH,KAAK,CACH,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,MAAM,EACZ,YAAY,SAA8C,GACzD,IAAI,CA4FN;IAeD;;;OAGG;IACH,KAAK,IAAI,IAAI,CAYZ;IAED,KAAK,IAAI,IAAI,CAYZ;CA6BF"}