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

package/out/zero-cache/src/services/change-source/common/backfill-manager.d.ts

@@ -1,57 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type JSONFormat } from '../../../types/lite.ts';
-import type { BackfillCompleted, BackfillRequest, ChangeStreamMessage, MessageBackfill } from '../protocol/current.ts';
-import type { Cancelable, ChangeStreamMultiplexer, Listener } from './change-stream-multiplexer.ts';
-/**
- * A {@link MessageBackfill} or {@link BackfillCompleted} paired with the
- * approximate number of upstream bytes it represents. The BackfillManager uses
- * `byteSize` to bound the size of each replica transaction, committing and
- * reopening once {@link COMMIT_THRESHOLD_BYTES} is reached.
- */
-export type BackfillMessage = {
-    message: MessageBackfill | BackfillCompleted;
-    byteSize: number;
-};
-type BackfillStreamer = (req: BackfillRequest) => AsyncGenerator<BackfillMessage>;
-/**
- * The BackfillManager initiates backfills for BackfillRequests from the
- * change-streamer (i.e. unfinished backfills from previous sessions)
- * or for new backfills signaled by `create-table` or `add-column` messages
- * from the change-source.
- *
- * The BackfillManager registers itself as a change stream listener in order
- * to track necessary backfills, and potentially invalidate the in-progress
- * backfill (e.g. due to a schema change) so that it can be retried at a
- * new snapshot.
- *
- * The manager also handles low priority streaming of the backfill messages
- * using the {@link ChangeStreamMultiplexer}, implementing a policy of always
- * releasing its reservation if another producer (i.e. the main change stream)
- * has messages to stream.
- */
-export declare class BackfillManager implements Cancelable, Listener {
-    #private;
-    constructor(lc: LogContext, changeStreamer: ChangeStreamMultiplexer, backfillStreamer: BackfillStreamer, jsonFormat?: JSONFormat, minBackoffMs?: number, maxBackoffMs?: number, commitThresholdBytes?: number);
-    run(lastWatermark: string, initialRequests: BackfillRequest[]): void;
-    /**
-     * Implements {@link Listener.onChange()}, invoked by the
-     * {@link ChangeStreamMultiplexer}.
-     */
-    onChange(message: ChangeStreamMessage): void;
-    cancel(): void;
-}
-declare abstract class BackfillStreamError extends Error {
-    constructor(bf: BackfillRequest, msg: string, cause?: unknown);
-}
-/**
- * Error type for backfill stream implementations to throw indicating that
- * the backfill request failed due to a schema incompatibility error. This
- * type of error does not need exponential backoff, as the retry happens
- * naturally once the invalidating schema change is processed and committed.
- */
-export declare class SchemaIncompatibilityError extends BackfillStreamError {
-    readonly name = "SchemaIncompatibilityError";
-    constructor(bf: BackfillRequest, msg: string, cause?: unknown);
-}
-export {};
-//# sourceMappingURL=backfill-manager.d.ts.map

package/out/zero-cache/src/services/change-source/common/backfill-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-manager.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/common/backfill-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAUjD,OAAO,EAAmB,KAAK,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAKzE,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EAEnB,eAAe,EAChB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,UAAU,EACV,uBAAuB,EACvB,QAAQ,EACT,MAAM,gCAAgC,CAAC;AAMxC;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,eAAe,GAAG,iBAAiB,CAAC;IAC7C,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,gBAAgB,GAAG,CACtB,GAAG,EAAE,eAAe,KACjB,cAAc,CAAC,eAAe,CAAC,CAAC;AAkFrC;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAgB,YAAW,UAAU,EAAE,QAAQ;;IA4C1D,YACE,EAAE,EAAE,UAAU,EACd,cAAc,EAAE,uBAAuB,EACvC,gBAAgB,EAAE,gBAAgB,EAClC,UAAU,GAAE,UAA6B,EACzC,YAAY,SAA0B,EACtC,YAAY,SAA0B,EACtC,oBAAoB,SAAyB,EAU9C;IAED,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,EAAE,QAU5D;IA4bD;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA6M3C;IAED,MAAM,IAAI,IAAI,CAab;CACF;AAED,uBAAe,mBAAoB,SAAQ,KAAK;IAC9C,YAAY,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAM5D;CACF;AA6BD;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;IACjE,QAAQ,CAAC,IAAI,gCAAgC;IAE7C,YAAY,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAE5D;CACF"}

package/out/zero-cache/src/services/change-source/common/change-stream-multiplexer.d.ts

@@ -1,55 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Source } from '../../../types/streams.ts';
-import type { ChangeStreamMessage, DownstreamStatusMessage } from '../protocol/current.ts';
-export type Cancelable = {
-    cancel(): void;
-};
-export type Listener = {
-    onChange(change: ChangeStreamMessage): void;
-};
-/**
- * Facilitates cooperative multiplexing of transactions from
- * multiple producers into a single change stream.
- */
-export declare class ChangeStreamMultiplexer {
-    #private;
-    constructor(lc: LogContext, lastWatermark: string);
-    addProducers(...p: Cancelable[]): this;
-    addListeners(...l: Listener[]): this;
-    /**
-     * Called by a producer to "reserve" the exclusive right to push data
-     * changes to the stream. If the stream is currently reserved,
-     * the resulting Promise must be awaited.
-     *
-     * The producer must then {@link release()} the reservation when it sees
-     * fit.
-     *
-     * @param producer The name of the producer, purely for debugging output
-     */
-    reserve(producer: string): string | Promise<string>;
-    /**
-     * If there are producers currently awaiting a reservation, returns
-     * the duration (in milliseconds) of the oldest reservation request.
-     * Returns a negative number if there are no waiters.
-     */
-    waiterDelay(): number;
-    /**
-     * Called by a producer to release its reservation after committing its
-     * last transaction.
-     */
-    release(newWatermark: string): void;
-    /**
-     * `pushStatus()` can be called without a reservation, as it
-     * does not constitute a data change and can appear anywhere
-     * in the stream.
-     */
-    pushStatus(message: DownstreamStatusMessage): void;
-    /**
-     * `push()` must only be called by a producer after it has
-     * {@link reserve}d the stream.
-     */
-    push(message: ChangeStreamMessage): Promise<unknown>;
-    fail(err: Error): void;
-    asSource(): Source<ChangeStreamMessage>;
-}
-//# sourceMappingURL=change-stream-multiplexer.d.ts.map

package/out/zero-cache/src/services/change-source/common/change-stream-multiplexer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"change-stream-multiplexer.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/common/change-stream-multiplexer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAIjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,2BAA2B,CAAC;AAEtD,OAAO,KAAK,EACV,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC7C,CAAC;AASF;;;GAGG;AACH,qBAAa,uBAAuB;;IAqBlC,YAAY,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,EAMhD;IAmBD,YAAY,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAGrC;IAED,YAAY,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,GAAG,IAAI,CAGnC;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA2BlD;IAED;;;;OAIG;IACH,WAAW,IAAI,MAAM,CAKpB;IAED;;;OAGG;IACH,OAAO,CAAC,YAAY,EAAE,MAAM,QAY3B;IAED;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,uBAAuB,QAG1C;IAED;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnD;IAED,IAAI,CAAC,GAAG,EAAE,KAAK,QAEd;IAED,QAAQ,IAAI,MAAM,CAAC,mBAAmB,CAAC,CAEtC;CACF"}

package/out/zero-cache/src/services/change-source/common/init-cleanup.d.ts

@@ -1,24 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-/**
- * Releases the resources acquired by an initialization attempt (e.g. a
- * claimed replication slot, or a purge lock on the change-log) if the attempt
- * fails, e.g. before it is retried after an AutoResetSignal, or when a restore
- * is abandoned in favor of an initial sync.
- *
- * On success, the resources are handed over (e.g. the replication slot is
- * taken over by the change source, and the purge lock by the change-streamer)
- * and the cleanup is simply dropped.
- */
-export declare class InitCleanup {
-    #private;
-    constructor(lc: LogContext);
-    /** Registers a resource to be released if the attempt fails. */
-    onFailure(name: string, release: () => unknown): void;
-    /**
-     * Releases the registered resources in the reverse order of their
-     * registration. Errors are logged rather than thrown so as not to mask the
-     * failure of the attempt.
-     */
-    release(): Promise<void>;
-}
-//# sourceMappingURL=init-cleanup.d.ts.map

package/out/zero-cache/src/services/change-source/common/init-cleanup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init-cleanup.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/common/init-cleanup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD;;;;;;;;;GASG;AACH,qBAAa,WAAW;;IAItB,YAAY,EAAE,EAAE,UAAU,EAEzB;IAED,gEAAgE;IAChE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,QAE7C;IAED;;;;OAIG;IACG,OAAO,kBAWZ;CACF"}

package/out/zero-cache/src/services/change-source/common/replica-restore.d.ts

@@ -1,115 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { LitestreamConfig } from '../../../config/normalize.ts';
-import { type ReplicaConstraints } from '../../litestream/commands.ts';
-import type { SubscriptionState } from '../../replicator/schema/replication-state.ts';
-import type { ChangeSource } from '../change-source.ts';
-import type { InitCleanup } from './init-cleanup.ts';
-export interface PurgeLock {
-    release(): Promise<void>;
-}
-/** A PurgeLock that also constrains the replica that can be restored. */
-export interface ConstrainingPurgeLock extends PurgeLock, ReplicaConstraints {
-    /**
-     * The head of the change log when the lock was acquired, from which (or
-     * from past which) the change log is resumed.
-     */
-    readonly headWatermark: string;
-}
-/**
- * Acquires a purge lock on the PG change-log (if it is not empty).
- *
- * When resuming the change-log from a replication slot, `slotWatermark` is the
- * slot's position (as a watermark). If the change-log's head is behind it, the
- * change-log may be missing transactions that the slot will not stream, in
- * which case nothing is locked and `'behind-slot'` is returned.
- */
-export type PgChangeLogPurgeLocker = (slotWatermark?: string) => Promise<ConstrainingPurgeLock | null | 'behind-slot'>;
-export type RestoreOptions = {
-    litestream?: LitestreamConfig;
-    /**
-     * With the PG change-log enabled, purge-locks the change-log before the
-     * replica is restored, which constrains the replica to one from which the
-     * change-log can be resumed. The lock is acquired as late as possible (i.e.
-     * after a replication slot is created, if applicable) because, if the
-     * change-db is the upstream db, a transaction holding the lock would block
-     * the creation of a replication slot.
-     */
-    acquirePurgeLock?: PgChangeLogPurgeLocker | undefined;
-    /**
-     * Resources acquired by the initialization (e.g. a claimed replication slot)
-     * are registered here to be released if the initialization attempt fails.
-     * Note that a purge lock acquired with `acquirePurgeLock` must be registered
-     * here by the locker, so that it is released on failure.
-     */
-    cleanup?: InitCleanup | undefined;
-};
-export type InitializeResult = {
-    subscriptionState: SubscriptionState;
-    changeSource: ChangeSource;
-    destinationBackupURL: string | undefined;
-    /**
-     * The replica this change stream belongs to, from the upstream `replicas`
-     * table. It is part of the identity the SQLite change log records, because a
-     * generation (i.e. `replicaVersion`) is shared by every sibling of a forked
-     * replica and so cannot distinguish two siblings' logs. `null` when the
-     * change source has no upstream table to identify itself from.
-     */
-    replicaID: string | null;
-    /**
-     * Whether server readiness should be gated on the first litestream backup,
-     * in order to ensure that a newly connecting subscriber can restore from
-     * this change-streamer's backup.
-     *
-     * This should be true when the backup destination differs from where the
-     * backup was restored from, which is the case for (1) initial-sync and
-     * (2) most initialization cases in RMv2, with the exception being when
-     * an abandoned replica is resumed.
-     */
-    waitForBackupBeforeServing: boolean;
-    /**
-     * Whether the PG change-log's head was behind the position of the
-     * replication slot from which replication resumes (see
-     * {@link PgChangeLogPurgeLocker}), in which case it is re-initialized from
-     * the restored replica if it does not contain the replica's changes.
-     */
-    pgChangeLogBehindSlot?: boolean | undefined;
-    /**
-     * Whether the litestream backup to `destinationBackupURL` starts a new
-     * (litestream v5) backup lineage, i.e. one that no local litestream state
-     * belongs to. Any such state (e.g. from a previous run of a restarted
-     * container, whose restore reused the existing replica) describes a
-     * different lineage and must be discarded before replicating, or litestream
-     * resolves its position from it and fails (and auto-recovers) on its first
-     * sync to the empty lineage.
-     *
-     * This is false when the backup continues a lineage from the local
-     * litestream state (see {@link ResumableBackup}).
-     */
-    newBackupLineage: boolean;
-};
-/**
- * Where the backup goes after a restore, when it can continue from the
- * restored replica's local litestream state instead of starting a new lineage
- * with a full snapshot:
- * - `fork`: a new, unique subfolder of `baseURL`, which the restore seeds with
- *   the restored backup files.
- */
-export type BackupDestination = {
-    type: 'fork';
-    baseURL: string;
-};
-/**
- * A backup lineage at `backupPath` that the litestream backup continues from
- * the local litestream state and the restored replica's WAL.
- */
-export type ResumableBackup = {
-    backupPath: string;
-};
-/**
- * Restores the replica from `config.backupURL`. With a `destination`, it
- * returns the backup that continues from the restored replica, if the
- * restore prepared one (e.g. it was not skipped because the replica already
- * exists).
- */
-export declare function restoreReplica(lc: LogContext, config: LitestreamConfig, replicaFile: string, replicaConstraints: ReplicaConstraints | undefined, destination?: BackupDestination | undefined): Promise<ResumableBackup | undefined>;
-//# sourceMappingURL=replica-restore.d.ts.map

package/out/zero-cache/src/services/change-source/common/replica-restore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replica-restore.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/common/replica-restore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAEL,KAAK,kBAAkB,EAExB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,8CAA8C,CAAC;AACpF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,SAAS;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,yEAAyE;AACzE,MAAM,WAAW,qBAAsB,SAAQ,SAAS,EAAE,kBAAkB;IAC1E;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,CACnC,aAAa,CAAC,EAAE,MAAM,KACnB,OAAO,CAAC,qBAAqB,GAAG,IAAI,GAAG,aAAa,CAAC,CAAC;AAE3D,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IACtD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;IAC3B,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB;;;;;;;;;OASG;IACH,0BAA0B,EAAE,OAAO,CAAC;IAEpC;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAE5C;;;;;;;;;;;OAWG;IACH,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC;AAEhE;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAOF;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAClD,WAAW,CAAC,EAAE,iBAAiB,GAAG,SAAS,GAC1C,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAkDtC"}

package/out/zero-cache/src/services/change-source/common/replica-schema.d.ts

@@ -1,14 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { Database } from '../../../../../zqlite/src/db.ts';
-import { type IncrementalMigrationMap } from '../../../db/migration-lite.ts';
-export declare function initReplica(log: LogContext, debugName: string, dbPath: string, initialSync: (lc: LogContext, tx: Database) => Promise<void>): Promise<void>;
-export declare function upgradeReplica(log: LogContext, debugName: string, dbPath: string): Promise<void>;
-export declare const CREATE_V6_COLUMN_METADATA_TABLE = "\n  CREATE TABLE \"_zero.column_metadata\" (\n    table_name TEXT NOT NULL,\n    column_name TEXT NOT NULL,\n    upstream_type TEXT NOT NULL,\n    is_not_null INTEGER NOT NULL,\n    is_enum INTEGER NOT NULL,\n    is_array INTEGER NOT NULL,\n    character_max_length INTEGER,\n    PRIMARY KEY (table_name, column_name)\n  );\n";
-export declare const CREATE_V7_CHANGE_LOG = "\n  CREATE TABLE \"_zero.changeLog2\" (\n    \"stateVersion\"              TEXT NOT NULL,\n    \"pos\"                       INT  NOT NULL,\n    \"table\"                     TEXT NOT NULL,\n    \"rowKey\"                    TEXT NOT NULL,\n    \"op\"                        TEXT NOT NULL,\n    PRIMARY KEY(\"stateVersion\", \"pos\"),\n    UNIQUE(\"table\", \"rowKey\")\n  );\n";
-export declare const CREATE_V9_TABLE_METADATA_TABLE = "\n  CREATE TABLE \"_zero.tableMetadata\" (\n    \"schema\"    TEXT NOT NULL,\n    \"table\"     TEXT NOT NULL,\n    \"metadata\"  TEXT NOT NULL,\n    PRIMARY KEY (\"schema\", \"table\")\n  );\n";
-export declare const CREATE_V17_BACKFILLING_TABLE = "\n  CREATE TABLE \"_zero.backfilling\" (\n    \"schema\"   TEXT NOT NULL,\n    \"table\"    TEXT NOT NULL,\n    \"column\"   TEXT NOT NULL,\n    \"backfill\" TEXT NOT NULL,\n    PRIMARY KEY (\"schema\", \"table\", \"column\")\n  );\n";
-export declare const V14_CHANGE_LOG_STREAM_TABLE = "_zero.changeLogStream";
-export declare const CREATE_V14_CHANGE_LOG_STREAM = "\n  CREATE TABLE \"_zero.changeLogStream\" (\n    \"watermark\"   TEXT NOT NULL,\n    \"pos\"         INTEGER NOT NULL,\n    \"change\"      TEXT NOT NULL,\n    \"precommit\"   TEXT,\n    \"writeTimeMs\" INTEGER,\n    PRIMARY KEY (\"watermark\", \"pos\")\n  );\n\n  CREATE INDEX \"_zero.changeLogStream_writeTimeMs\"\n    ON \"_zero.changeLogStream\" (\"writeTimeMs\", \"watermark\")\n    WHERE \"writeTimeMs\" IS NOT NULL;\n";
-export declare const schemaVersionMigrationMap: IncrementalMigrationMap;
-export declare const CURRENT_SCHEMA_VERSION: number;
-//# sourceMappingURL=replica-schema.d.ts.map

package/out/zero-cache/src/services/change-source/common/replica-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replica-schema.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/common/replica-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,iCAAiC,CAAC;AAG9D,OAAO,EAEL,KAAK,uBAAuB,EAE7B,MAAM,+BAA+B,CAAC;AAgBvC,wBAAsB,WAAW,CAC/B,GAAG,EAAE,UAAU,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,GAC3D,OAAO,CAAC,IAAI,CAAC,CA0Bf;AAED,wBAAsB,cAAc,CAClC,GAAG,EAAE,UAAU,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,iBAoBf;AAkBD,eAAO,MAAM,+BAA+B,0UAW3C,CAAC;AAEF,eAAO,MAAM,oBAAoB,8XAUhC,CAAC;AAEF,eAAO,MAAM,8BAA8B,sMAO1C,CAAC;AAEF,eAAO,MAAM,4BAA4B,8OAQxC,CAAC;AAKF,eAAO,MAAM,2BAA2B,0BAA0B,CAAC;AAMnE,eAAO,MAAM,4BAA4B,8aAaxC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,uBAkNvC,CAAC;AAGF,eAAO,MAAM,sBAAsB,QAEwB,CAAC"}

package/out/zero-cache/src/services/change-source/custom/change-source.d.ts

@@ -1,25 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type JSONObject } from '../../../../../shared/src/bigint-json.ts';
-import { Database } from '../../../../../zqlite/src/db.ts';
-import type { ShardConfig } from '../../../types/shards.ts';
-import { type InitializeResult, type RestoreOptions } from '../common/replica-restore.ts';
-/** Server context to store with the initial sync metadata for debugging. */
-export type ServerContext = JSONObject;
-/**
- * Initializes a Custom change source before streaming changes from the
- * corresponding logical replication stream.
- */
-export declare function initializeCustomChangeSource(lc: LogContext, upstreamURI: string, shard: ShardConfig, replicaDbFile: string, context: ServerContext, { litestream, acquirePurgeLock }?: RestoreOptions): Promise<InitializeResult>;
-/**
- * Initial sync for a custom change source makes a request to the
- * change source endpoint with no `replicaVersion` or `lastWatermark`.
- * The initial transaction returned by the endpoint is treated as
- * the initial sync, and the commit watermark of that transaction
- * becomes the `replicaVersion` of the initialized replica.
- *
- * Note that this is equivalent to how the LSN of the Postgres WAL
- * at initial sync time is the `replicaVersion` (and starting
- * version for all initially-synced rows).
- */
-export declare function initialSync(lc: LogContext, shard: ShardConfig, tx: Database, upstreamURI: string, context: ServerContext): Promise<void>;
-//# sourceMappingURL=change-source.d.ts.map

package/out/zero-cache/src/services/change-source/custom/change-source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"change-source.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/custom/change-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAEL,KAAK,UAAU,EAChB,MAAM,0CAA0C,CAAC;AAGlD,OAAO,EAAC,QAAQ,EAAC,MAAM,iCAAiC,CAAC;AAGzD,OAAO,KAAK,EAAC,WAAW,EAAU,MAAM,0BAA0B,CAAC;AAcnE,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,8BAA8B,CAAC;AAQtC,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;GAGG;AACH,wBAAsB,4BAA4B,CAChD,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,aAAa,EACtB,EAAC,UAAU,EAAE,gBAAgB,EAAC,GAAE,cAAmB,GAClD,OAAO,CAAC,gBAAgB,CAAC,CA8D3B;AA2ED;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAC/B,EAAE,EAAE,UAAU,EACd,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,aAAa,iBAqFvB"}

package/out/zero-cache/src/services/change-source/pg/backfill-metadata.d.ts

@@ -1,14 +0,0 @@
-import * as v from '../../../../../shared/src/valita.ts';
-export declare const columnMetadataSchema: v.ObjectType<{
-    attNum: v.Type<number>;
-}, undefined>;
-export type ColumnMetadata = v.Infer<typeof columnMetadataSchema>;
-export declare const tableMetadataSchema: v.ObjectType<{
-    schemaOID: v.Type<number>;
-    relationOID: v.Type<number>;
-    rowKey: v.Type<Record<string, {
-        attNum: number;
-    }>>;
-}, undefined>;
-export type TableMetadata = v.Infer<typeof tableMetadataSchema>;
-//# sourceMappingURL=backfill-metadata.d.ts.map

package/out/zero-cache/src/services/change-source/pg/backfill-metadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-metadata.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/backfill-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,qCAAqC,CAAC;AAKzD,eAAO,MAAM,oBAAoB;;aAE/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,mBAAmB;;;;;;aAI9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/out/zero-cache/src/services/change-source/pg/backfill-stream.d.ts

@@ -1,36 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type BackfillMessage } from '../common/backfill-manager.ts';
-import type { BackfillRequest } from '../protocol/current.ts';
-import type { Replica } from './schema/shard.ts';
-export declare function ctidToProgressMark(ctid: string): string;
-/** The inverse of {@link ctidToProgressMark}, as a `tid` literal. */
-export declare function progressMarkToCtid(mark: string): string;
-type StreamOptions = {
-    /**
-     * The number of bytes at which to flush a batch of rows in a
-     * backfill message. Defaults to Node's getDefaultHighWatermark().
-     */
-    flushThresholdBytes?: number | undefined;
-    /**
-     * Use text-format COPY instead of binary COPY.
-     * Binary is faster and handles all types (unknown types are cast to
-     * `::text` in the SELECT). This flag exists as an escape hatch to
-     * revert to the old code path if needed.
-     */
-    textCopy?: boolean | undefined;
-    /**
-     * @visibleForTesting
-     * Called after the snapshot transaction is opened, before the table is
-     * locked, e.g. to run a concurrent heap rewrite in between.
-     */
-    afterSnapshotForTesting?: (() => Promise<void>) | undefined;
-};
-/**
- * Streams a series of `backfill` messages (ending with `backfill-complete`)
- * at a set watermark (i.e. LSN). The data is retrieved via a COPY stream
- * made at a transaction snapshot corresponding to specific LSN, obtained by
- * creating a short-lived replication slot.
- */
-export declare function streamBackfill(lc: LogContext, upstreamURI: string, { slot, publications }: Pick<Replica, 'slot' | 'publications'>, bf: BackfillRequest, opts?: StreamOptions): AsyncGenerator<BackfillMessage>;
-export {};
-//# sourceMappingURL=backfill-stream.d.ts.map

package/out/zero-cache/src/services/change-source/pg/backfill-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill-stream.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/backfill-stream.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAsBjD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAGV,eAAe,EAGhB,MAAM,wBAAwB,CAAC;AAahC,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAC;AAoC/C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIvD;AAmCD,KAAK,aAAa,GAAG;IACnB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEzC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAE/B;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;CAC7D,CAAC;AAYF;;;;;GAKG;AACH,wBAAuB,cAAc,CACnC,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,MAAM,EACnB,EAAC,IAAI,EAAE,YAAY,EAAC,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAAC,EAC5D,EAAE,EAAE,eAAe,EACnB,IAAI,GAAE,aAAkB,GACvB,cAAc,CAAC,eAAe,CAAC,CAyJjC"}

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

@@ -1,65 +0,0 @@
-import type { Readable } from 'node:stream';
-import type { LogContext } from '@rocicorp/logger';
-import { type PostgresDB } from '../../../types/pg.ts';
-import { type ShardConfig, type ShardID } from '../../../types/shards.ts';
-import { type ConstrainingPurgeLock, type InitializeResult, type RestoreOptions } from '../common/replica-restore.ts';
-import { type InitialSyncOptions, type ReplicaOptions, type ServerContext } from './initial-sync.ts';
-import { type LSN } from './lsn.ts';
-import { type ReplicaState } from './schema/shard.ts';
-export type InitializeOptions = ReplicaOptions & {
-    slotPerReplica: boolean | undefined;
-    inactiveReplicaGracePeriodMs: number;
-    /**
-     * Whether this replication-manager maintains the PG change log, i.e. acks
-     * the replication slot only after transactions are stored in it. Recorded
-     * with the replica (see `pgChangeLog` in `ReplicaState`) when its slot is
-     * taken over.
-     */
-    pgChangeLog: boolean;
-};
-/**
- * Initializes a Postgres change source, including the initial sync of the
- * replica, before streaming changes from the corresponding logical replication
- * stream.
- */
-export declare function initializePostgresChangeSource(lc: LogContext, upstreamURI: string, shard: ShardConfig, replicaDbFile: string, syncOptions: InitialSyncOptions, context: ServerContext, lagReportIntervalMs?: number, restoreOptions?: RestoreOptions, { epoch, slotPerReplica, backupV5, inactiveReplicaGracePeriodMs, pgChangeLog, }?: InitializeOptions, streamInboundTimeoutMs?: number | undefined): Promise<InitializeResult>;
-/**
- * The watermark below which the replication stream cannot (correctly) be
- * started, i.e. from which it would skip transactions that the change log
- * does not contain. It reflects the order in which each mode stores a
- * transaction and then acks it to the slot, such that a correctly initialized
- * stream always starts at or past it:
- *
- * * After an initial sync, the replica's watermark, which is the position
- *   at which the new slot was created, and the change log is (re)initialized
- *   at it.
- * * With a slot per replica (RMv1.5 and RMv2), the minimum of the restored
- *   replica's watermark and the slot's position. Transactions are only acked
- *   once backed up (so a skipped interval ends at or before the replica), and
- *   if the change log is behind the slot it is re-initialized from the
- *   replica. Note that the slot can be past the replica (acked for keepalives,
- *   with nothing skipped), and the replica past the change log (forwarded
- *   before being stored, and streamed again from the slot), but the stream
- *   never starts below both. (With RMv1.5's purge lock, the change log's head
- *   is at or past the slot, so it does not lower the minimum.)
- * * With a shared slot (RMv1), or a resumed slot that was acked only once
- *   transactions were stored in the change log (RMv1.5), the change log's
- *   head when it was purge locked, as the stream resumes from the head, which
- *   only advances. The slot is not a reference: a shared slot is acked by its
- *   owner until it is taken over, and a resumed RMv1.5 slot can be past the
- *   head for acked keepalives. Without a purge lock (i.e. an empty change
- *   log), there is no floor.
- */
-export declare function minStartWatermark(replicaWatermark: string, initialSynced: boolean, slotWatermark: string | undefined, purgeLock: ConstrainingPurgeLock | null): string | undefined;
-export declare function getSourceAndDestinationReplicas(lc: LogContext, sql: PostgresDB, shard: ShardID, epoch: number, slotFailover: boolean, gracePeriodMs: number, pollIntervalMs?: number): Promise<{
-    restoreFrom: ReplicaState;
-    replicateTo: ReplicaState;
-    /** The position of the slot from which replication resumes. */
-    slotLSN: LSN;
-    /**
-     * The session holding the destination slot active until it is taken
-     * over by the PostgresChangeSource. Destroying it releases the slot.
-     */
-    slotSession: Readable;
-} | undefined>;
-//# sourceMappingURL=change-source-init.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"change-source-init.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/pg/change-source-init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAQjD,OAAO,EAAkB,KAAK,UAAU,EAAC,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAC,KAAK,WAAW,EAAE,KAAK,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAOxE,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAEpB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAiC,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AASlE,OAAO,EAOL,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG;IAG/C,cAAc,EAAE,OAAO,GAAG,SAAS,CAAC;IAEpC,4BAA4B,EAAE,MAAM,CAAC;IAErC;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,WAAW,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,aAAa,EACtB,mBAAmB,SAAI,EACvB,cAAc,GAAE,cAAmB,EACnC,EACE,KAAK,EACL,cAAc,EACd,QAAQ,EACR,4BAA4B,EAC5B,WAAW,GACZ,GAAE,iBAMF,EACD,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,GAC1C,OAAO,CAAC,gBAAgB,CAAC,CA4I3B;AA6KD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,SAAS,EAAE,qBAAqB,GAAG,IAAI,GACtC,MAAM,GAAG,SAAS,CAQpB;AAsBD,wBAAsB,+BAA+B,CACnD,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,OAAO,EACrB,aAAa,EAAE,MAAM,EACrB,cAAc,SAA2B,GACxC,OAAO,CACN;IACE,WAAW,EAAE,YAAY,CAAC;IAC1B,WAAW,EAAE,YAAY,CAAC;IAC1B,+DAA+D;IAC/D,OAAO,EAAE,GAAG,CAAC;IACb;;;OAGG;IACH,WAAW,EAAE,QAAQ,CAAC;CACvB,GACD,SAAS,CACZ,CA+LA"}

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

@@ -1,115 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import * as v from '../../../../../shared/src/valita.ts';
-import type { PublishedIndexSpec, PublishedTableSpec } from '../../../db/specs.ts';
-import { type LexiVersion } from '../../../types/lexi-version.ts';
-import { type PostgresDB } from '../../../types/pg.ts';
-import { type ShardID } from '../../../types/shards.ts';
-import type { Sink } from '../../../types/streams.ts';
-import type { ChangeSource, ChangeStream } from '../change-source.ts';
-import { type Listener } from '../common/change-stream-multiplexer.ts';
-import type { BackfillRequest, DownstreamStatusMessage } from '../protocol/current.ts';
-import type { ChangeStreamMessage } from '../protocol/current/downstream.ts';
-import { streamBackfill } from './backfill-stream.ts';
-import { type ServerContext } from './initial-sync.ts';
-import type { MessageMessage, MessageRelation as PostgresRelation } from './logical-replication/pgoutput.types.ts';
-import { subscribe } from './logical-replication/stream.ts';
-import { type PublishedTableWithReplicaIdentity } from './schema/published.ts';
-import { type BackupOptions, type InternalShardConfig, type Replica } from './schema/shard.ts';
-/**
- * Postgres implementation of a {@link ChangeSource} backed by a logical
- * replication stream.
- */
-export declare class PostgresChangeSource implements ChangeSource {
-    #private;
-    constructor(lc: LogContext, upstreamUri: string, shard: ShardID, replica: Replica, pgVersion: number, backupOptions: BackupOptions, context: ServerContext, lagReportIntervalMs: number, textCopy?: boolean | undefined, streamInboundTimeoutMs?: number | undefined, 
-    /**
-     * The watermark below which a stream cannot be started without skipping
-     * transactions, as Postgres would silently start from the slot's position
-     * instead (see `minStartWatermark()` in change-source-init.ts).
-     */
-    minStartWatermark?: string | undefined, deps?: {
-        subscribe?: typeof subscribe;
-        streamBackfill?: typeof streamBackfill;
-    });
-    stop(): Promise<void>;
-    startLagReporter(): Promise<{
-        firstCommitTimeMs: number;
-        nextSendTimeMs: number;
-    } | null>;
-    startStream(clientWatermark: string, backfillRequests?: BackfillRequest[]): Promise<ChangeStream>;
-    startStreamInternal(slot: string, clientWatermark: string, shardConfig: InternalShardConfig, backfillRequests: BackfillRequest[]): Promise<ChangeStream>;
-}
-export declare class Acker implements Listener {
-    #private;
-    /**
-     * @param resumeWatermark the watermark the stream resumes after. What came
-     *     before it was received on an earlier connection, and only the
-     *     change-streamer knows whether it has persisted it, so keepalives are
-     *     not acked until the change-streamer has acked it. A change-streamer
-     *     whose SQLite change log is ahead of its backup would otherwise have
-     *     the slot moved past transactions that only that log holds.
-     */
-    constructor(acks: Sink<bigint>, resumeWatermark: string | null);
-    onChange(change: ChangeStreamMessage): void;
-    ack(watermark: LexiVersion): void;
-}
-declare const lagReportSchema: v.ObjectType<{
-    id: v.Type<string>;
-    sendTimeMs: v.Type<number>;
-    commitTimeMs: v.Type<number>;
-}, undefined>;
-export type LagReport = v.Infer<typeof lagReportSchema>;
-export declare class LagReporter {
-    #private;
-    static readonly MESSAGE_SUFFIX = "/lag-report/v1";
-    readonly messagePrefix: string;
-    constructor(lc: LogContext, shard: ShardID, db: PostgresDB, pgVersion: number, reportIntervalMs: number, reportIntervalJitterMs?: number);
-    get pgVersion(): number;
-    initiateLagReport(log?: boolean): Promise<{
-        firstCommitTimeMs: number;
-        nextSendTimeMs: number;
-    }>;
-    /**
-     * In Postgres < 17, the pg_logical_emit_message lacks an immediate "flush"
-     * option, which can cause messages to be missed when the replication stream
-     * starts up:
-     *
-     * ```
-     * * emit message → WAL write (buffered, not flushed)
-     * * walsender reads up to current flush LSN
-     * * emitted message's LSN is beyond flush LSN → not yet visible
-     * * stream feedback/acknowledgment advances slot
-     * * WAL eventually flushes → but slot has already moved past it
-     * ```
-     *
-     * This has been seen to happen for the initial `wal_writer_delay` interval
-     * of a replication session.
-     *
-     * To account for this, the last emitted lag report is considered "received"
-     * if the stream has advanced beyond the WAL insert position read after the
-     * report was emitted (see initiateLagReport()).
-     *
-     * This is unnecessary in PG 17+, where reports are emitted with `flush`.
-     */
-    checkCurrentLSN(lsn: bigint): DownstreamStatusMessage | undefined;
-    stop(): void;
-    /**
-     * @param lsn The LSN of the message in the replication stream (i.e. from the
-     *     XLogData header), rather than the `messageLsn` of the message itself,
-     *     which is not guaranteed to be comparable to other stream LSNs (e.g. on
-     *     Aurora). See {@link initiateLagReport}.
-     */
-    processLagReportMessage(msg: MessageMessage, lsn: bigint): DownstreamStatusMessage;
-}
-export declare function relationDifferent(a: PublishedTableSpec, b: PostgresRelation): boolean;
-/**
- * Determines if an index was structurally changed (e.g. constraint dropped
- * and recreated with different columns) vs cosmetically changed (e.g. the
- * index spec changed because the table or a column was renamed).
- *
- * Compares boolean properties directly and resolves column names to their
- * stable attnums (pg_attribute `attnum`) for the column comparison.
- */
-export declare function isIndexStructurallyChanged(prev: PublishedIndexSpec, next: PublishedIndexSpec, prevTables: Map<number, PublishedTableWithReplicaIdentity>, nextTables: Map<number, PublishedTableWithReplicaIdentity>): boolean;
-export {};
-//# sourceMappingURL=change-source.d.ts.map

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

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