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

package/out/zero-cache/src/services/change-source/pg/replication-slots.d.ts

@@ -1,127 +0,0 @@
-import type { Readable } from 'node:stream';
-import type { LogContext } from '@rocicorp/logger';
-import postgres from 'postgres';
-import { type PostgresDB } from '../../../types/pg.ts';
-import { type ShardID } from '../../../types/shards.ts';
-import { type ReplicaStage } from './schema/replica-stage-enum.ts';
-import { type BackupOptions, type ReplicaState } from './schema/shard.ts';
-export type ReplicationSlot = {
-    slot_name: string;
-    consistent_point: string;
-    snapshot_name: string;
-    output_plugin: string;
-};
-export type ReplicationSlotResult<T> = {
-    slot: ReplicationSlot;
-    capturedSnapshot: T;
-    initialSession: Readable;
-    replica: ReplicaState;
-};
-export type ReservedSlot = {
-    slot: string;
-    reservation: Readable;
-    replica: ReplicaState;
-};
-export type CreateSlotSpec = {
-    slotName: string;
-    failover?: boolean;
-    temporary?: boolean;
-    lockTimeout?: number | undefined;
-    diagnosticsDB?: PostgresDB | undefined;
-};
-export declare const CREATE_REPLICATION_SLOT_TIMEOUT_MS = 60000;
-/** Thrown when the client-side timeout for creating a slot is reached. */
-export declare class SlotCreationTimeoutError extends Error {
-    readonly name = "SlotCreationTimeoutError";
-}
-export declare function createReplicationSlot(lc: LogContext, session: postgres.Sql, { slotName, failover, temporary, lockTimeout, diagnosticsDB, }: CreateSlotSpec): Promise<ReplicationSlot>;
-/**
- * Best-effort logging of what a timed out CREATE_REPLICATION_SLOT was waiting
- * on: the walsender's wait event and blocking pids, and the oldest
- * transactions holding an xid. Slot creation waits for every such transaction
- * on the instance (in all databases), each with its own lock_timeout, so a
- * chain of overlapping transactions can exceed the client-side timeout
- * without the lock_timeout ever firing.
- *
- * Query text is deliberately omitted since it can contain row values.
- *
- * Exported for testing.
- */
-export declare function logSlotCreationBlockers(lc: LogContext, sql: PostgresDB, walsenderPID: number, slotName: string): Promise<void>;
-export type CreateReplicaAndSlotOptions = {
-    lockTimeout?: number | undefined;
-    maxBlockedMs?: number | undefined;
-    retryDelayMs?: number | undefined;
-};
-/**
- * Replica and slot creation involves several sessions for proper
- * coordination with other replica management logic:
- *
- * * A dedicated session acquires a (session-level) advisory lock for
- *   replica slot management. This is the same lock that cleanup logic
- *   acquires before cleaning up replication slots. The lock is held
- *   outside of a transaction so that the session is not "idle in
- *   transaction" while slot creation waits on upstream transactions,
- *   which some upstreams terminate (e.g. idle_in_transaction_session_timeout).
- * * With the lock held, a new replication slot is created in a
- *   replication session. The API of CREATE_REPLICATION_SLOT is such
- *   that it cannot be done in a transaction, and cannot be followed by
- *   any writes, or else its snapshot (which is needed for initial sync)
- *   would be invalidated.
- * * Once the slot is created, the slot and replica information are recorded
- *   in the `replicas` table before releasing the lock.
- *
- * Slot creation waits for all transactions on the upstream instance that
- * hold an xid, so it can be blocked by long-running transactions. A blocked
- * attempt is abandoned (see {@link CREATE_REPLICATION_SLOT_TIMEOUT_MS}) and
- * retried in-process, as it leaves no durable state: the `replicas` row is
- * only inserted after the slot has been created. Retries continue until the
- * slot is created or until `maxBlockedMs` has elapsed, after which the error
- * is thrown.
- *
- * This locking ensures that:
- * 1. multiple replication managers attempting to create a replication slot
- *    will not use the same name for the replication slot (which is selected
- *    from a pool of reused names).
- * 2. Running replication managers (which use an earlier replica of a lower
- *    rank) will not delete the new slot during their cleanup logic, since
- *    the slot will belong to a replica of a higher rank.
- *
- * When the replication slot is created, `captureSnapshot` callback is first
- * run while the snapshot at the consistent point is available. The callback
- * must capture the snapshot in postgres (e.g. `SET TRANSACTION SNAPSHOT`)
- * in order to use it. Once the callback completes, a placeholder replication
- * session (i.e. that does not consume any messages) is started, in order to
- * reserve the slot by mark it "active", effectively distinguishing the
- * initializing session from a failed or abandoned session.
- *
- * Note that starting the replication session releases the initial snapshot,
- * which is why the callback must capture it synchronously, before the
- * replication session is started.
- *
- * The placeholder replication session is closed when the
- * PostgresChangeSource takes over the slot to process the stream in earnest.
- * It is also returned for cleanup in the case of failures (and for control
- * in unit tests).
- *
- * For replica's created in the `Restore` stage, the `generation` is
- * initialized to an empty string instead of the slot's consistent point,
- * since the slot is not being used for initial sync. It is the
- * responsibiliy of the caller to call {@link initRestoreReplica} when
- * the source replica has been selected for restoring, which will carry
- * over the `generation` and other relevant values from the source.
- */
-export declare function createReplicaAndSlot<T>(lc: LogContext, sql: PostgresDB, sessionName: string, shard: ShardID, epoch: number, replicaID: string, failover: boolean, backupOptions: BackupOptions, captureSnapshot: (snapshot: string) => Promise<T>, stage: ReplicaStage, { lockTimeout, maxBlockedMs, retryDelayMs, }?: CreateReplicaAndSlotOptions): Promise<ReplicationSlotResult<T>>;
-/**
- * Claims the inactive slot of the given replica for use by this task, opening
- * a replication session to mark it as active. The process should follow up by
- * taking over the slot via the PostgresChangeSource.
- *
- * The replica is identified by its ID (and not just its slot) because rows of
- * replicas whose slots were dropped outside of zero-cache's control may share
- * the slot name.
- */
-export declare function claimSlotForResumption(lc: LogContext, sql: PostgresDB, shard: ShardID, _sessionName: string, { id: replicaID, slot }: Pick<ReplicaState, 'id' | 'slot'>): Promise<ReservedSlot | null>;
-export declare function dropInactiveSlotsAndReplicas(lc: LogContext, sql: PostgresDB, shard: ShardID, slots: string[]): Promise<void>;
-export declare function slotPoolSuffix(n: number): string;
-//# sourceMappingURL=replication-slots.d.ts.map

package/out/zero-cache/src/services/change-source/pg/replication-slots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replication-slots.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/replication-slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAM1C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,QAA2C,MAAM,UAAU,CAAC;AAMnE,OAAO,EAAkB,KAAK,UAAU,EAAC,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAiB,KAAK,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAWtE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAG3B,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;IACrC,IAAI,EAAE,eAAe,CAAC;IACtB,gBAAgB,EAAE,CAAC,CAAC;IACpB,cAAc,EAAE,QAAQ,CAAC;IACzB,OAAO,EAAE,YAAY,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,QAAQ,CAAC;IACtB,OAAO,EAAE,YAAY,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IAGjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAInB,SAAS,CAAC,EAAE,OAAO,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAIjC,aAAa,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACxC,CAAC;AAUF,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAOzD,0EAA0E;AAC1E,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,8BAA8B;CAC5C;AAKD,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,QAAQ,CAAC,GAAG,EACrB,EACE,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,WAAoC,EACpC,aAAa,GACd,EAAE,cAAc,GAChB,OAAO,CAAC,eAAe,CAAC,CAwD1B;AAKD;;;;;;;;;;;GAWG;AACH,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,iBAmCjB;AA0BD,MAAM,MAAM,2BAA2B,GAAG;IAExC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC,CAAC;AAsBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,EACjB,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACjD,KAAK,EAAE,YAAY,EACnB,EACE,WAAW,EACX,YAAmD,EACnD,YAAmD,GACpD,GAAE,2BAAgC,GAClC,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAiLnC;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,MAAM,EACpB,EAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAC,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,MAAM,CAAC,GACvD,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA0D9B;AAED,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EAAE,iBA+BhB;AAmFD,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,UAUvC"}

package/out/zero-cache/src/services/change-source/pg/schema/init.d.ts

@@ -1,9 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { PostgresDB } from '../../../../types/pg.ts';
-import { type ShardConfig } from '../../../../types/shards.ts';
-/**
- * Ensures that a shard is set up for initial sync.
- */
-export declare function ensureShardSchema(lc: LogContext, db: PostgresDB, shard: ShardConfig, installPartialIndexTriggers?: boolean): Promise<void>;
-export declare const CURRENT_SCHEMA_VERSION: number;
-//# sourceMappingURL=init.d.ts.map

package/out/zero-cache/src/services/change-source/pg/schema/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAQjD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAiB,KAAK,WAAW,EAAC,MAAM,6BAA6B,CAAC;AAa7E;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,WAAW,EAClB,2BAA2B,UAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAiBf;AA8SD,eAAO,MAAM,sBAAsB,QASwB,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/backfill-progress.d.ts

@@ -1,68 +0,0 @@
-import type { BackfillProgressMark, BackfillRequest } from './current.ts';
-/**
- * The result of applying a backfill message to a column's tracked progress.
- * If `accept` is true, `progress` is the column's new progress.
- */
-export type AcceptResult = {
-    accept: true;
-    progress: BackfillProgressMark | undefined;
-} | {
-    accept: false;
-};
-/**
- * Applies the continuity policy of `backfill` (and `backfill-completed`)
- * messages to a column's `own` tracked progress, where `undefined` means that
- * the column has not received any backfill data (i.e. it needs a backfill
- * from scratch).
- *
- * * Messages without `progressMarks` are from pre-v8 replication-managers
- *   and are accepted unconditionally (i.e. the legacy behavior), with no
- *   change to the tracked progress.
- * * A message without a `previous` mark starts a backfill from scratch (or on
- *   a new timeline), and is always accepted.
- * * Otherwise, the message is only accepted if it is on the same timeline as
- *   `own`, and continues from a position at or before `own` (i.e. it does not
- *   create a gap).
- *
- * `current` is unset for `backfill-completed` messages, which do not advance
- * the progress.
- */
-export declare function acceptBackfill(own: BackfillProgressMark | undefined, marks: {
-    previous?: BackfillProgressMark | undefined;
-    current?: BackfillProgressMark;
-} | undefined): AcceptResult;
-/**
- * Returns whether a stream whose progress (for a column) is at `stream`
- * will deliver all of the data needed by a subscriber whose progress (for the
- * same column) is at `subscriber`. A `stream` progress of `undefined` indicates
- * a backfill that will start from scratch, which covers all subscribers.
- */
-export declare function covers(stream: BackfillProgressMark | undefined, subscriber: BackfillProgressMark | undefined): boolean;
-/**
- * Returns the position from which a backfill for the `req` must start
- * in order to satisfy the progress of all of its columns, i.e. the earliest
- * progress mark, or `undefined` (i.e. from scratch) if any column has no
- * progress or if the columns are on different timelines.
- */
-export declare function resumePoint(req: BackfillRequest): BackfillProgressMark | undefined;
-/**
- * Returns a copy of the `req` with the progress of every column set to
- * the request's {@link resumePoint}, i.e. the position from which the
- * backfill of the request will actually start.
- */
-export declare function withResumePoint(req: BackfillRequest): BackfillRequest;
-/**
- * Merges two BackfillRequests for the same table into one that satisfies
- * both. Both requests are expected to reflect the same (current) upstream
- * schema. For columns in both requests, the earlier progress mark is chosen,
- * or no progress mark (i.e. from scratch) if they are on different timelines.
- * If a column's backfill IDs differ (which is unexpected), the ID of `req1`
- * is chosen, and the column is backfilled from scratch.
- */
-export declare function getTableSuperset(req1: BackfillRequest, req2: BackfillRequest): BackfillRequest;
-/**
- * Merges the BackfillRequests of multiple parties (e.g. subscribers) into
- * one request per table, using {@link getTableSuperset}.
- */
-export declare function getSuperset(...requestSets: Iterable<BackfillRequest>[]): BackfillRequest[];
-//# sourceMappingURL=backfill-progress.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/backfill-progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-progress.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/protocol/backfill-progress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EAEhB,MAAM,cAAc,CAAC;AAyBtB;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB;IAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,oBAAoB,GAAG,SAAS,CAAA;CAAC,GAC1D;IAAC,MAAM,EAAE,KAAK,CAAA;CAAC,CAAC;AAEpB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,oBAAoB,GAAG,SAAS,EACrC,KAAK,EACD;IACE,QAAQ,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC5C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC,GACD,SAAS,GACZ,YAAY,CAyBd;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,UAAU,EAAE,oBAAoB,GAAG,SAAS,GAC3C,OAAO,CAOT;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,eAAe,GACnB,oBAAoB,GAAG,SAAS,CAelC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,eAAe,CAWrE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,eAAe,GACpB,eAAe,CA4BjB;AAMD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,WAAW,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,GAC1C,eAAe,EAAE,CAUnB"}

package/out/zero-cache/src/services/change-streamer/backfill-state-tracker.d.ts

@@ -1,72 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Subscription } from '../../types/subscription.ts';
-import type { ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
-import type { BackfillRequest } from '../change-source/protocol/current/upstream.ts';
-import type { PreSerializedBatch } from './broadcast.ts';
-import type { SubscriberContext } from './change-streamer.ts';
-import type { Subscriber, SubscriberOptions } from './subscriber.ts';
-export type SubscriberBackfillOptions = Pick<SubscriberOptions, 'backfills' | 'onAligned' | 'onBackfillIgnored'>;
-/**
- * Tracks the pending backfills (and their progress) of the change log, the
- * subscribers, and the current change stream, in order to determine:
- *
- * * the BackfillRequests with which to start a change stream, i.e. the
- *   superset of the pending backfills of the change log and all aligned
- *   subscribers, starting from the earliest progress, and
- * * whether (and why) the change stream must be restarted, i.e. when a
- *   newly aligned subscriber's pending backfills are not covered by the
- *   current stream.
- *
- * The change-streamer calls {@link startStream()} whenever it starts a change
- * stream, {@link track()} for every change that it forwards, and restarts
- * the stream at the next transaction boundary whenever a
- * {@link restartReason} is set.
- */
-export declare class BackfillStateTracker {
-    #private;
-    constructor(lc: LogContext);
-    /**
-     * The reason for which the change stream must be restarted, or `null` if
-     * it need not be. The restart should happen at the next transaction
-     * boundary, i.e. upon the next `commit`, or `status` message outside of a
-     * transaction.
-     */
-    get restartReason(): string | null;
-    /**
-     * Computes the BackfillRequests with which to start a new change stream:
-     * the superset of the pending backfills of the change log and of all
-     * aligned subscribers, all of which are consistent with the stream's
-     * starting watermark since streams are (re)started at transaction
-     * boundaries.
-     *
-     * @param logBackfillRequests The BackfillRequests from the change log's
-     *        cookie jar, consistent with the stream's starting watermark.
-     */
-    startStream(logBackfillRequests: BackfillRequest[]): BackfillRequest[];
-    /**
-     * Tracks a change that is forwarded to subscribers. This must be called
-     * (synchronously) before the change is forwarded, so that the stream's
-     * state is never ahead of that of aligned subscribers.
-     */
-    track(change: ChangeStreamData): void;
-    /**
-     * Requests a restart of the change stream (at the next transaction
-     * boundary), e.g. to start it with BackfillRequests that it was not
-     * started with.
-     */
-    requestRestart(reason: string): void;
-    /** Logs and records a (planned) restart for the {@link restartReason}. */
-    recordRestart(): void;
-    /**
-     * Returns the backfill-related {@link SubscriberOptions} for a new
-     * subscriber, which must subsequently be passed to {@link register()}.
-     */
-    subscriberOptions(lc: LogContext, ctx: SubscriberContext): SubscriberBackfillOptions;
-    /**
-     * Registers a subscriber (created with {@link subscriberOptions()}) until
-     * its `downstream` is closed. This is a no-op for subscribers that do not
-     * report their pending backfills.
-     */
-    register(subscriber: Subscriber, downstream: Subscription<string | PreSerializedBatch>): void;
-}
-//# sourceMappingURL=backfill-state-tracker.d.ts.map

package/out/zero-cache/src/services/change-streamer/backfill-state-tracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-state-tracker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backfill-state-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAK9D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+CAA+C,CAAC;AAEnF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAE,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,iBAAiB,EACjB,WAAW,GAAG,WAAW,GAAG,mBAAmB,CAChD,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,oBAAoB;;IA6C/B,YAAY,EAAE,EAAE,UAAU,EAEzB;IAED;;;;;OAKG;IACH,IAAI,aAAa,IAAI,MAAM,GAAG,IAAI,CAEjC;IAED;;;;;;;;;OASG;IACH,WAAW,CAAC,mBAAmB,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAyBrE;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,gBAAgB,QAG7B;IAED;;;;OAIG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,QAE5B;IAED,0EAA0E;IAC1E,aAAa,SAGZ;IAED;;;OAGG;IACH,iBAAiB,CACf,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,iBAAiB,GACrB,yBAAyB,CAqB3B;IAED;;;;OAIG;IACH,QAAQ,CACN,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,YAAY,CAAC,MAAM,GAAG,kBAAkB,CAAC,QAMtD;CAsBF"}

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

@@ -1,50 +0,0 @@
-import type { BackfillRequest, ChangeStreamData } from '../change-source/protocol/current.ts';
-import type { WatermarkedChange } from './change-streamer.ts';
-/**
- * Tracks the state of the pending backfills (and their progress) of a party
- * in the replication stream (e.g. a subscriber, or the change-log itself), by
- * applying the same policies that a subscriber applies to its replica:
- * schema changes are folded with the {@link cookieOps} shared by the
- * cookie jars, and `backfill` / `backfill-completed` messages are accepted
- * or ignored with the continuity policy of {@link acceptBackfill}.
- *
- * Changes are applied transactionally: the changes of a transaction are
- * discarded if it is rolled back, and {@link requests()} only reflects
- * committed transactions.
- */
-export declare class BackfillState {
-    #private;
-    constructor(requests?: readonly BackfillRequest[]);
-    /** The (committed) pending backfills. */
-    requests(): BackfillRequest[];
-    /**
-     * Returns the `requests` with the (committed) progress of this state
-     * applied to the columns that are pending in both, i.e. same table, column,
-     * and backfill ID. Other columns have no progress (i.e. from scratch).
-     */
-    withProgress(requests: readonly BackfillRequest[]): BackfillRequest[];
-    /** Whether there are no (committed) pending backfills. */
-    get empty(): boolean;
-    /**
-     * Returns the columns (as `schema.table.column` strings) with (committed)
-     * pending backfills that are not covered by the (committed) progress of the
-     * `stream`, i.e. columns for which the `stream` will not deliver all of the
-     * necessary data.
-     */
-    uncovered(stream: BackfillState): string[];
-    /**
-     * Applies a serialized change, parsing it only if it is relevant.
-     *
-     * @returns The columns (as `schema.table.column` strings) of a backfill
-     *          message that were ignored due to the continuity policy.
-     */
-    applySerialized([, tag, json]: WatermarkedChange): string[];
-    /**
-     * Applies a change.
-     *
-     * @returns The columns (as `schema.table.column` strings) of a backfill
-     *          message that were ignored due to the continuity policy.
-     */
-    apply(change: ChangeStreamData): string[];
-}
-//# sourceMappingURL=backfill-state.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-state.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backfill-state.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAIjB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,KAAK,EAAY,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AA8CvE;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;;IAIxB,YAAY,QAAQ,GAAE,SAAS,eAAe,EAAO,EASpD;IAMD,yCAAyC;IACzC,QAAQ,IAAI,eAAe,EAAE,CAE5B;IAED;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,eAAe,EAAE,CAmBpE;IAED,0DAA0D;IAC1D,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAazC;IAED;;;;;OAKG;IACH,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAgB1D;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CA4DxC;CA6HF"}

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

@@ -1,12 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { NormalizedZeroConfig } from '../../config/normalize.ts';
-import { BackupMonitor } from './backup-monitor.ts';
-import { type BackupStateVerifier } from './litestream3-prometheus-poller.ts';
-export type BackupCleanupMonitorFactoryOptions = {
-    lc: LogContext;
-    config: NormalizedZeroConfig;
-    replicaFile: string;
-    verifyBackupState?: BackupStateVerifier | undefined;
-};
-export declare function createBackupCleanupMonitor({ lc, config, replicaFile, verifyBackupState, }: BackupCleanupMonitorFactoryOptions): BackupMonitor;
-//# sourceMappingURL=backup-cleanup-monitor-factory.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backup-cleanup-monitor-factory.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAKpE,OAAO,EAAC,aAAa,EAAoB,MAAM,qBAAqB,CAAC;AAErE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,oCAAoC,CAAC;AAG5C,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE,oBAAoB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,EACzC,EAAE,EACF,MAAM,EACN,WAAW,EACX,iBAAiB,GAClB,EAAE,kCAAkC,GAAG,aAAa,CAyBpD"}

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

@@ -1,57 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Source } from '../../types/streams.ts';
-import type { SingletonService } from '../service.ts';
-export type BackedUpWatermark = {
-    watermark: string;
-    writeTimeMs?: number | undefined;
-    backupTimeMs: number;
-};
-/**
- * Determines which watermarks of the replica are backed up, by whatever means
- * the backup (or its absence) allows.
- */
-export interface BackupPoller {
-    /**
-     * Starts polling, returning the stream of backed-up watermarks. Must only
-     * be called once.
-     */
-    start(): Source<BackedUpWatermark>;
-    /**
-     * Requests that the replica be backed up through `watermark` promptly,
-     * rather than at the poller's regular cadence, once the replica has reached
-     * it. The resulting watermark is emitted on the stream as usual. Pollers
-     * that cannot initiate backups do not implement this.
-     */
-    requestSync?(watermark: string): void;
-}
-/**
- * The interface through which the change-streamer consumes backed-up
- * watermarks and requests prompt backups (see {@link BackupMonitor}).
- */
-export type BackupSource = Pick<BackupMonitor, 'backups' | 'requestSync'>;
-/**
- * Relays the watermarks backed up by a {@link BackupPoller} to the
- * change-streamer, which consumes them (see {@link backups}) and requests
- * prompt backups (see {@link requestSync}) as needed.
- */
-export declare class BackupMonitor implements SingletonService {
-    #private;
-    readonly id = "backup-monitor";
-    constructor(lc: LogContext, poller: BackupPoller, replicaFile: string);
-    firstBackupReceived(): Promise<void>;
-    /**
-     * The stream of backed-up watermarks, each later than the last, coalesced
-     * to the latest one that has not been consumed. It ends when the monitor
-     * stops.
-     */
-    backups(): Source<BackedUpWatermark>;
-    /**
-     * Requests that the replica be backed up through `watermark` promptly, if
-     * the poller supports it (see {@link BackupPoller.requestSync}). A no-op
-     * unless the monitor is running.
-     */
-    requestSync(watermark: string): void;
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=backup-monitor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"backup-monitor.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAEnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAEpD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,IAAI,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEnC;;;;;OAKG;IACH,WAAW,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,aAAa,CAAC,CAAC;AAE1E;;;;GAIG;AACH,qBAAa,aAAc,YAAW,gBAAgB;;IACpD,QAAQ,CAAC,EAAE,oBAAoB;IAwB/B,YAAY,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAIpE;IAED,mBAAmB,kBAElB;IAED;;;;OAIG;IACH,OAAO,IAAI,MAAM,CAAC,iBAAiB,CAAC,CAEnC;IAED;;;;OAIG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,QAY5B;IAEK,GAAG,kBAsCR;IAqDD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAKpB;CA+BF"}

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

@@ -1,98 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type PreSerialized } from '../../types/streams.ts';
-import type { WatermarkedChange } from './change-streamer.ts';
-import type { Subscriber } from './subscriber.ts';
-export type BroadcastReleaseMode = 'all-subscribers' | 'consensus-timeout';
-export type PreSerializedBatch = PreSerialized & {
-    readonly changes: readonly WatermarkedChange[];
-};
-export declare function isPreSerializedBatch(val: unknown): val is PreSerializedBatch;
-export declare function preSerializeBatch(changes: readonly WatermarkedChange[]): PreSerializedBatch;
-/**
- * Enables event-driven early release of a {@link Broadcast}. When provided and a
- * majority has acked, the broadcast schedules its own consensus-timeout release
- * proportional to how long the majority took to ack, instead of relying on the
- * Forwarder's periodic progress tick.
- */
-export type EarlyReleaseOptions = {
-    /** Time to wait, proportional to majority completion, before releasing. */
-    consensusTimeoutProportion: number;
-    /** Injectable timer, for deterministic testing. */
-    setTimeoutFn?: typeof setTimeout;
-    /** Injectable timer cancellation, for deterministic testing. */
-    clearTimeoutFn?: typeof clearTimeout;
-};
-/**
- * Initiates and tracks the progress of a change broadcasted to
- * a set of subscribers, implementing **consensus-based timeouts**
- * to effect short-term graceful degradation when a minority of
- * subscribers are behind.
- *
- * ### Background
- *
- * The purpose of flow control is to pull upstream replication changes
- * no faster than the rate they are processed by downstream subscribers
- * in the steady state. In the change-streamer, this is done by occasionally
- * waiting for ACKs from subscribers before continuing; without doing so,
- * I/O buffers fill up and cause the system to spend most of its time in GC.
- *
- * However, the naive algorithm of always waiting for all subscribers (e.g.
- * `Promise.all()`) can behave poorly in scenarios where subscribers
- * are imbalanced:
- * * New subscribers may have a backlog of changes to catch up with.
- *   Having all subscribers wait for the new subscriber to catch up results
- *   in delaying the entire application.
- * * Broken TCP connections similarly require all subscribers to wait until
- *   connection liveness checks kick in and disconnect the subscriber.
- *
- * A simplistic approach is to add a limit to the amount of time waiting for
- * subscribers, i.e. an ack timeout. However, deciding what this timeout
- * should be is non-trivial because of the heterogeneous nature of changes;
- * while most changes operate on single rows and are relatively predictable
- * in terms of running time, some changes are table-wide operations and can
- * legitimately take an arbitrary amount of time. In such scenarios, a
- * timeout that is too short can stop progress on replication altogether.
- *
- * ### Consensus-based Timeout Algorithm
- *
- * To address these shortcomings, a "consensus-based timeout" algorithm is
- * used:
- * * Wait for more than half of the subscribers to finish. (In
- *   case of a single node, or the case of one replication-manager
- *   and one view-syncer, this reduces to waiting for all subscribers.)
- * * Once more than half of the subscribers have finished, proceed after
- *   the configured timeout, proportional to the time it took for the
- *   majority of subscribers to ack, even if not all subscribers have
- *   finished.
- *
- * In other words, the subscribers themselves are used to determine the
- * timeout of each batch of changes; the majority determines this when
- * they complete, upon which a timeout is logically started.
- *
- * In the common case, the remaining subscribers finish soon afterward and
- * the timeout never elapses. However, in pathological cases where a minority
- * of subscribers have a disproportionate amount of load, some will still
- * be processing (or otherwise unresponsive). These subscribers are given
- * a bounded amount of time to catch up at each flushed batch, up to the
- * timeout interval. This guarantees eventual catchup because the
- * subscribers with a backlog of changes necessarily have a higher
- * processing rate than the subscribers that finished (and are made to wait).
- */
-export declare class Broadcast {
-    #private;
-    /**
-     * Sends the change to the subscribers without the tracking machinery.
-     * This is suitable for fire-and-forget (i.e. pipelined) sends.
-     */
-    static withoutTracking(subscribers: Iterable<Subscriber>, change: WatermarkedChange | readonly WatermarkedChange[]): void;
-    /**
-     * Broadcasts the `change` to the `subscribers` and tracks their
-     * completion.
-     */
-    constructor(lc: LogContext, subscribers: Iterable<Subscriber>, change: WatermarkedChange | readonly WatermarkedChange[], earlyRelease?: EarlyReleaseOptions);
-    get isDone(): boolean;
-    get done(): Promise<void>;
-    get releaseMode(): BroadcastReleaseMode;
-    logSlowRequests(now: number): void;
-}
-//# sourceMappingURL=broadcast.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAkB,KAAK,aAAa,EAAC,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAEhD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAE3E,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAChD,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAE5E;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,iBAAiB,EAAE,GACpC,kBAAkB,CAYpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAC;IACnC,mDAAmD;IACnD,YAAY,CAAC,EAAE,OAAO,UAAU,CAAC;IACjC,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,YAAY,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,qBAAa,SAAS;;IACpB;;;OAGG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,QAOzD;IA0BD;;;OAGG;IACH,YACE,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,EACxD,YAAY,CAAC,EAAE,mBAAmB,EA+BnC;IAwDD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAExB;IAED,IAAI,WAAW,IAAI,oBAAoB,CAEtC;IAED,eAAe,CAAC,GAAG,EAAE,MAAM,QAa1B;CAiBF"}

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

@@ -1,34 +0,0 @@
-import type { ChangeStreamData } from '../change-source/protocol/current/downstream.ts';
-import type { ChangeTag, WatermarkedChange } from './change-streamer.ts';
-export type ChangeLogEntry = {
-    watermark: string;
-    tag: string;
-    change: string;
-};
-export type SerializedChangeStreamData = {
-    /** The canonical downstream representation forwarded to subscribers. */
-    readonly json: string;
-    /** The already-serialized change tuple element stored in change logs. */
-    readonly change: string;
-};
-/**
- * Serializes a data-plane message and its stored change payload in one pass.
- *
- * Change logs retain only the second tuple element for backwards
- * compatibility. Serializing that element first avoids stringifying the full
- * message and then copying the payload back out of the resulting string on the
- * replication hot path.
- */
-export declare function serializeChangeStreamDataWithChange(data: ChangeStreamData): SerializedChangeStreamData;
-/** Serializes a data-plane message to the canonical downstream JSON form. */
-export declare function serializeChangeStreamData(data: ChangeStreamData): string;
-/**
- * Extracts the second tuple element for callers that only have the canonical
- * downstream JSON. The live write path uses
- * {@link serializeChangeStreamDataWithChange} and does not scan or copy the
- * completed message.
- */
-export declare function extractChangeSubstring(streamMessageJSON: string, tag: ChangeTag | undefined): string;
-/** Reconstructs the canonical downstream JSON around a stored change. */
-export declare function reconstructWatermarkedChange(watermark: string, entryTag: string, change: string): WatermarkedChange;
-//# sourceMappingURL=change-log-codec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-codec.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-codec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAC,SAAS,EAAE,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAEvE,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,gBAAgB,GACrB,0BAA0B,CAc5B;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,MAAM,EACzB,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,MAAM,CAkBR;AAED,yEAAyE;AACzE,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,iBAAiB,CAoBnB"}

package/out/zero-cache/src/services/change-streamer/change-log-compare-digest.d.ts

@@ -1,34 +0,0 @@
-/**
- * Pure building blocks for comparing catchup output between the Postgres and
- * SQLite change logs: how to reduce a catchup range to a single comparable
- * digest. Which transactions to sample is `isSampledForShard`, in
- * `shard-sampling.ts`.
- *
- * Nothing here touches either store. The comparator service supplies the
- * batches.
- */
-import type { WatermarkedChange } from './change-streamer.ts';
-export type CatchupRangeDigest = {
-    readonly digest: string;
-    readonly rows: number;
-    /** Change text hashed. This is the payload cost of the range. */
-    readonly bytes: number;
-    /** A row or byte limit was reached before the closing commit. */
-    readonly limitReached: boolean;
-};
-/**
- * Builds one ordered digest for a catchup range.
- *
- * The row position makes missing, extra, changed, and reordered rows change the digest.
- * The digest omits `precommit` because a commit already includes its watermark.
- *
- * The change text is hashed as stored. Both logs write the same
- * `extractChangeSubstring` output, and the Postgres column is `json`, which
- * keeps the input text exactly, so the two sides are byte-comparable without
- * reparsing. Comparing the stored text also catches an encoding difference
- * that a semantic comparison would hide.
- *
- * The read stops at `maxRows` or at `maxBytes`, whichever comes first.
- */
-export declare function digestCatchupRange(batches: AsyncIterable<readonly WatermarkedChange[]>, throughWatermark: string, maxRows: number, maxBytes: number): Promise<CatchupRangeDigest>;
-//# sourceMappingURL=change-log-compare-digest.d.ts.map

package/out/zero-cache/src/services/change-streamer/change-log-compare-digest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"change-log-compare-digest.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-compare-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,CAAC,SAAS,iBAAiB,EAAE,CAAC,EACpD,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,kBAAkB,CAAC,CAsC7B"}