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

package/out/zero-cache/src/services/view-syncer/snapshotter.d.ts

@@ -1,420 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type JSONValue } from '../../../../shared/src/bigint-json.ts';
-import type { Row } from '../../../../zero-protocol/src/data.ts';
-import type { PrimaryKey } from '../../../../zero-types/src/schema.ts';
-import { type SQLiteRow } from '../../../../zqlite/src/table-source.ts';
-import type { LiteAndZqlSpec, LiteTableSpecWithKeysAndVersion } from '../../db/specs.ts';
-import { StatementRunner } from '../../db/statements.ts';
-import { type RowKey } from '../../types/row-key.ts';
-import type { AppID } from '../../types/shards.ts';
-import type { SnapshotRowCache } from './snapshot-row-cache.ts';
-/**
- * A `Snapshotter` manages the progression of database snapshots for a
- * ViewSyncer.
- *
- * The Replicator and ViewSyncers operate on the same SQLite file, with the
- * Replicator being the sole writer to the database. The IVM logic in
- * ViewSyncers, however, rely on incrementally applying changes to the DB to
- * update the state of its pipelines.
- *
- * To avoid coupling the progress of the Replicator and all IVM pipelines on
- * each other, ViewSyncers operate on ephemeral forks of the database by holding
- * [concurrent](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md)
- * snapshots of the database and simulating (but ultimately rolling back)
- * mutations on these snapshots.
- *
- * Example:
- * 1. ViewSyncer takes `snapshot_a` at version `t1` of the database and
- *    hydrates its pipeline(s).
- * 2. Replicator applies a new transaction to the database and notifies
- *    subscribers.
- * 3. ViewSyncer takes `snapshot_b` at `t2`, and queries the `ChangeLog` at
- *    that snapshot for changes since `t1`.
- * 4. ViewSyncer applies those changes to `snapshot_a` for IVM, but does not
- *    commit them. (Recall that the Replicator is the sole writer to the db, so
- *    the ViewSyncer never commits any writes.)
- * 5. Replicator applies the next transaction and advances the database to `t3`.
- * 6. ViewSyncer rolls back `snapshot_a` and opens `snapshot_c` at `t3`, using
- *    `snapshot_b` to simulate changes from `t2` to `t3`.
- *
- * ```
- * Replicator:  t1 --------------> t2 --------------> t3 --------------->
- * ViewSyncer:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]
- * ```
- *
- * Note that the Replicator (and ViewSyncers) do not wait on the progress of
- * other ViewSyncers. If a ViewSyncer is busy hydrating at `t1`, the Replicator
- * and other ViewSyncers can progress through `t2`, `t3`, etc. independently,
- * as the busy ViewSyncer simply takes its own snapshot when it is ready.
- *
- * ```
- * Replicator:   t1 --------------> t2 --------------> t3 --------------->
- * ViewSyncer1:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]
- * ViewSyncer2:       [.......... snapshot_a ..........] ----> [snapshot_b]
- * ```
- *
- * To minimize Database connections (and statement preparation, etc.), the
- * Snapshotter reuses the connection from the previous (rolled back)
- * snapshot when opening the new one.
- *
- * ```
- * Replicator:  t1 --------------> t2 --------------> t3 --------------->
- * ViewSyncer:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]
- *                     (conn_1)           (conn_2)           (conn_1)
- * ```
- *
- * In this manner, each ViewSyncer uses two connections that continually
- * "leapfrog" each other to replay the timeline of changes in isolation from
- * the Replicator and other ViewSyncers.
- */
-export declare class Snapshotter {
-    #private;
-    /**
-     * @param rowCache An optional worker-wide {@link SnapshotRowCache} through
-     *        which the row reads performed when iterating over a
-     *        {@link SnapshotDiff} are shared with the other Snapshotters
-     *        (i.e. client groups) on the worker.
-     */
-    constructor(lc: LogContext, dbFile: string, { appID }: AppID, pageCacheSizeKib?: number, rowCache?: SnapshotRowCache);
-    /**
-     * Initializes the snapshot to the current head of the database. This must be
-     * only be called once. The state of whether a Snapshotter has been initialized
-     * can be determined by calling {@link initialized()}.
-     */
-    init(): this;
-    initialized(): boolean;
-    /** Returns the current snapshot. Asserts if {@link initialized()} is false. */
-    current(): Snapshot;
-    /**
-     * Advances to the head of the Database, returning a diff between the
-     * previously current Snapshot and a new Snapshot at head. This is called
-     * in response to a notification from a Replicator subscription. Subsequent
-     * calls to {@link current()} return the new Snapshot. Note that the Snapshotter
-     * must be initialized before advancing.
-     *
-     * The returned {@link SnapshotDiff} contains snapshots at the endpoints
-     * of the database timeline. Iterating over the diff generates a sequence
-     * of {@link Change}s between the two snapshots.
-     *
-     * Note that this sequence is not chronological; rather, the sequence is
-     * ordered by `<table, row-key>`, such that a row can appear at most once
-     * in the common case, or twice if its table is `TRUNCATE`'d and a new value
-     * is subsequently `INSERT`'ed. This results in dropping most intermediate
-     * changes to a row and bounds the amount of work needed to catch up;
-     * however, as a consequence, a consistent database state is only guaranteed
-     * when the sequence has been fully consumed.
-     *
-     * Note that Change generation relies on the state of the underlying
-     * database connections, and because the connection for the previous snapshot
-     * is reused to produce the next snapshot, the diff object is only valid
-     * until the next call to `advance()`.
-     *
-     * It is okay for the caller to apply `Change`s to the `prev` snapshot
-     * during the iteration (e.g. this is necessary for IVM); the remainder
-     * of the iteration is not affected because a given row can appear at most
-     * once in the sequence (with the exception being TRUNCATE, after which the
-     * deleted rows can be re-inserted, but this will also behave correctly if
-     * the changes are applied).
-     *
-     * Once the changes have been applied, however, a _subsequent_ iteration
-     * will not produce the correct results. In order to perform multiple
-     * change-applying iterations, the caller must (1) create a save point
-     * on `prev` before each iteration, and (2) rollback to the save point after
-     * the iteration.
-     *
-     * @param prevWrites How the caller writes to `prev` during the iteration,
-     *        which determines which `prev` reads can be shared through the
-     *        {@link SnapshotRowCache}. See {@link PrevWrites}.
-     */
-    advance(syncableTables: Map<string, LiteAndZqlSpec>, allTableNames: Set<string>, observedTables?: TableFilter | undefined, prevWrites?: PrevWrites): SnapshotDiff;
-    /**
-     * The diff between the two snapshots of the last
-     * {@link advanceWithoutDiff()}, as {@link advance()} returns it.
-     *
-     * @param counts The counts of the change log entries between the two
-     *        snapshots, if the caller has counted them already (see
-     *        `Snapshot.countChangesSince()`). The diff then does not count
-     *        them again.
-     * @param readTables If set, only the change log entries of these tables
-     *        (and of the permissions table) are read, along with the
-     *        table-wide ops of every table, where `observedTables` reads the
-     *        entries of every table and skips those it does not have. For a
-     *        caller that does not need the changes of the other tables, this
-     *        saves reading and parsing their entries. This requires `counts`.
-     *        If they show that there is no entry of these tables and no
-     *        table-wide op, the change log is not read at all, and the
-     *        diff's `changes` is 0.
-     */
-    diff(syncableTables: Map<string, LiteAndZqlSpec>, allTableNames: Set<string>, observedTables?: TableFilter | undefined, prevWrites?: PrevWrites, counts?: ChangeLogCounts | undefined, readTables?: Iterable<string> | undefined): SnapshotDiff;
-    advanceWithoutDiff(): {
-        prev: Snapshot;
-        curr: Snapshot;
-    };
-    /**
-     * The reset of the pipelines that iterating over the changes from the
-     * previous snapshot to the current one ends in, if it does: the first of
-     * a schema change, a truncation, and a change of the permissions. It is
-     * found without iterating, so that a caller that would reset the pipelines
-     * anyway does not first process the changes that come before it.
-     *
-     * If there is none, iterating over a {@link diff()} of the two snapshots
-     * does not throw a {@link ResetPipelinesSignal}, and can be stopped at any
-     * point without missing one.
-     *
-     * @param counts The changes from the previous snapshot to the current
-     *        one, from which it is known whether there is anything to look
-     *        for.
-     */
-    pendingReset(syncableTables: Map<string, LiteAndZqlSpec>, counts: ChangeLogCounts): ResetPipelinesSignal | undefined;
-    /**
-     * Releases the previous snapshot, i.e. the `prev` of the last
-     * {@link advance()} or {@link advanceWithoutDiff()}. It is only read
-     * while the diff that it is the start of is iterated over, but its read
-     * transaction otherwise stays open until the next advance, which keeps
-     * the replica from checkpointing its write-ahead log past it. A diff that
-     * starts at it can no longer be iterated over.
-     */
-    releasePrevious(): void;
-    /**
-     * Call this to close the database connections when the Snapshotter is
-     * no longer needed.
-     */
-    destroy(): void;
-}
-export type Change = {
-    readonly table: string;
-    /**
-     * If this change represents a remove the row to remove,
-     * if nextValue is not null then all rows that have a unique constraint
-     * violation with nextValue.
-     * In both cases these rows should be removed.
-     */
-    readonly prevValues: Readonly<Row>[];
-    readonly nextValue: Readonly<Row> | null;
-    readonly rowKey: RowKey;
-};
-/** See `Snapshot.countChangesSince()`. */
-/** An entry of {@link Snapshot.changesSince}, in the order of its SELECT. */
-type RawChangeLogEntry = readonly [
-    stateVersion: string,
-    table: string,
-    rowKey: string,
-    op: string
-];
-/** Where an entry is in the order that the change log is read in. */
-type ChangeLogPosition = {
-    readonly stateVersion: string;
-    readonly pos: number;
-};
-export type ChangeLogCounts = {
-    /** The number of entries. */
-    readonly total: number;
-    /** The number of them that are table-wide ops (a RESET or TRUNCATE). */
-    readonly tableWideOps: number;
-    /**
-     * The number of entries of each table. If {@link sampled}, these are
-     * estimates, and a table with few entries may be missing.
-     */
-    readonly byTable: ReadonlyMap<string, number>;
-    /** Whether {@link byTable} was estimated from a sample of the entries. */
-    readonly sampled: boolean;
-};
-/**
- * The most change log entries that are read to count a batch's changes by
- * table. Reading an entry costs microseconds, and nothing else runs on the
- * sync worker in the meantime, so the cost of counting must not grow with
- * the number of changes that a client group has to catch up on.
- */
-export declare const CHANGE_LOG_SAMPLE_SIZE = 1000;
-export interface TableFilter {
-    has(table: string): boolean;
-}
-/**
- * How the caller of {@link Snapshotter.advance()} writes the changes of a
- * {@link SnapshotDiff} to its `prev` snapshot while iterating over it.
- *
- * A `prev` read for a table with a single unique key (its primary key)
- * cannot observe earlier changes of the iteration, since a row key appears
- * once in the diff. A read for a table with other unique keys can, because
- * the rows it returns may have been displaced or edited by earlier changes.
- *
- * * `uniform`: every caller applies every change, so such a read depends on
- *   the `<prev, curr>` versions of the diff, and is shared on that basis.
- * * `divergent`: callers apply different subsets of the changes (e.g. the
- *   pipeline driver skips changes that no pipeline can observe), so such a
- *   read depends on the caller and is not shared.
- * * `none`: the caller does not write to `prev` (e.g. IVM derivation is
- *   held in memory), so every read depends solely on `prev.version`.
- */
-export type PrevWrites = 'uniform' | 'divergent' | 'none';
-/**
- * Represents the difference between two database Snapshots.
- * Iterating over the object will produce a sequence of {@link Change}s
- * between the two snapshots.
- *
- * See {@link Snapshotter.advance()} for semantics and usage.
- */
-export type DiffTimingStats = {
-    changeLogReadMs: number;
-    rowReadMs: number;
-    parseMs: number;
-    totalDiffMs: number;
-};
-export interface SnapshotDiff extends Iterable<Change> {
-    readonly prev: {
-        readonly db: StatementRunner;
-        readonly version: string;
-    };
-    readonly curr: {
-        readonly db: StatementRunner;
-        readonly version: string;
-    };
-    /**
-     * The raw number of ChangeLog entries between the snapshots, before filtering
-     * out unobserved/non-syncable tables or no-op changes. Progress against this
-     * total must use {@link changesScanned}, rather than the number of yielded
-     * changes. Table-wide operations abort iteration and reset the pipelines.
-     */
-    readonly changes: number;
-    /** The number of raw ChangeLog entries read so far, including skipped entries. */
-    readonly changesScanned: number;
-    /**
-     * The raw ChangeLog entries read so far, by table. Like
-     * {@link changesScanned}, this includes the entries that are not yielded,
-     * so it counts the same entries as {@link ChangeLogCounts.byTable} does.
-     */
-    readonly changesScannedByTable: ReadonlyMap<string, number>;
-    /** The scanned entries omitted because their table is unobserved/non-syncable or the change is a no-op. */
-    readonly changesSkipped: number;
-    /**
-     * The scanned entries whose rows were looked up in the snapshots. Unlike
-     * the entries that are yielded, this includes the no-op changes, which are
-     * only known to be that from their rows.
-     */
-    readonly changesLookedUp: number;
-    /** Timing metrics recorded during diff iteration. */
-    readonly stats?: DiffTimingStats | undefined;
-    /**
-     * Overrides the `prevWrites` passed to {@link Snapshotter.advance()}, for a
-     * caller that decides how to write to `prev` once it knows the number of
-     * {@link changes}. Must be called before the diff is iterated, except to
-     * switch to `divergent`, which can be done between any two changes: it
-     * shares only the reads that no write to `prev` can affect.
-     */
-    setPrevWrites(prevWrites: PrevWrites): void;
-}
-/**
- * Thrown during an iteration of a {@link SnapshotDiff} when a schema
- * change or truncate is encountered, which result in aborting the
- * advancement and resetting / rehydrating the pipelines.
- */
-export type ResetPipelinesReason = 'advancement-timeout' | 'scalar-subquery' | 'schema-change' | 'truncation' | 'permissions-change';
-export declare class ResetPipelinesSignal extends Error {
-    readonly name = "ResetPipelinesSignal";
-    readonly reason: ResetPipelinesReason;
-    readonly breakdown?: string | undefined;
-    constructor(msg: string, reason: ResetPipelinesReason, breakdown?: string);
-}
-declare class Snapshot {
-    #private;
-    static create(lc: LogContext, dbFile: string, appID: string, pageCacheSizeKib: number | undefined): Snapshot;
-    readonly db: StatementRunner;
-    readonly version: string;
-    /**
-     * @param begun Whether `db` is already in a `BEGIN CONCURRENT` transaction
-     *        that has not read anything.
-     */
-    constructor(db: StatementRunner, appID: string, begun?: boolean);
-    numChangesSince(prevVersion: string): any;
-    /**
-     * Counts the change log entries after `prevVersion`. The change log keeps
-     * the latest entry of a row, so these are counts of the rows that changed,
-     * which is what a diff from `prevVersion` to this snapshot reads.
-     *
-     * The total, and the number of table-wide ops (a RESET or TRUNCATE), are
-     * exact, and are counted from the index alone. The counts by table are
-     * exact if there are at most `sampleSize` entries. Otherwise they are
-     * estimated from the newest `sampleSize` entries, so that at most that
-     * many entries are read however many there are.
-     */
-    countChangesSince(prevVersion: string, sampleSize?: number): ChangeLogCounts;
-    /**
-     * Whether an entry of `table` was logged after `prevVersion`. This reads
-     * the table's entries in the change log, however old, so it is for tables
-     * with few rows.
-     */
-    tableChangedSince(table: string, prevVersion: string): boolean;
-    /**
-     * Whether a table-wide RESET op (i.e. a schema change) was logged after
-     * `prevVersion`. Table specs computed at or before `prevVersion` are
-     * stale with respect to this snapshot if so.
-     */
-    schemaChangedSince(prevVersion: string): boolean;
-    /**
-     * Whether any table-wide op (i.e. a RESET or TRUNCATE) was logged after
-     * `prevVersion`. Iterating over a diff ending at this snapshot will
-     * abort with a {@link ResetPipelinesSignal} if so.
-     */
-    hasTableWideOpSince(prevVersion: string): boolean;
-    /**
-     * The first table-wide op (a schema change or a truncation) logged after
-     * `prevVersion`, in the order that {@link changesSince} reads the entries.
-     */
-    firstTableWideOpSince(prevVersion: string): ChangeLogPosition & {
-        table: string;
-        op: string;
-    };
-    /**
-     * The entries of `table` logged after `prevVersion`, in the order that
-     * {@link changesSince} reads them. For a table with few rows.
-     */
-    entriesSince(table: string, prevVersion: string): (ChangeLogPosition & {
-        rowKey: string | null;
-        op: string;
-    })[];
-    /**
-     * @param tables If set, only the entries of these tables, and the
-     *        table-wide ops of every table, are read.
-     */
-    changesSince(prevVersion: string, tables?: string | undefined): {
-        changes: IterableIterator<RawChangeLogEntry>;
-        cleanup: () => void;
-    };
-    /**
-     * Reads the row with the given `rowKey`, or `undefined` if it does not
-     * exist.
-     *
-     * @param cache An optional {@link SnapshotRowCache} through which to
-     *        perform the read, along with the `tag` that identifies the
-     *        version(s) of the replica that the result depends on.
-     */
-    getRow(table: LiteTableSpecWithKeysAndVersion, rowKey: JSONValue, cache?: SnapshotRowCache, tag?: string): Readonly<Record<string, import("../../../../zqlite/src/table-source.ts").SQLiteValue>>;
-    /**
-     * Reads the rows that conflict with `row` on any of the given unique
-     * `keys` (which includes the row with the same primary key, if any).
-     *
-     * @param cache An optional {@link SnapshotRowCache} through which to
-     *        perform the read, along with the `tag` that identifies the
-     *        version(s) of the replica that the result depends on.
-     */
-    getRows(table: LiteTableSpecWithKeysAndVersion, keys: PrimaryKey[], row: SQLiteRow, cache?: SnapshotRowCache, tag?: string): Readonly<Record<string, import("../../../../zqlite/src/table-source.ts").SQLiteValue>>[];
-    /**
-     * Whether the snapshot has been released, or its connection reset to a
-     * newer snapshot (i.e. via {@link release()} or {@link resetToHead()}),
-     * after which reads no longer reflect {@link version}.
-     */
-    get reset(): boolean;
-    /**
-     * Ends the snapshot's read transaction, after which reads no longer
-     * reflect {@link version}. An open read transaction keeps SQLite from
-     * checkpointing the write-ahead log past the snapshot, so a snapshot that
-     * is no longer read should not be left open.
-     */
-    release(): void;
-    resetToHead(): Snapshot;
-}
-export declare class InvalidDiffError extends Error {
-    constructor(msg: string);
-}
-export {};
-//# sourceMappingURL=snapshotter.d.ts.map

package/out/zero-cache/src/services/view-syncer/snapshotter.d.ts.map

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

package/out/zero-cache/src/services/view-syncer/tracer.d.ts

@@ -1,2 +0,0 @@
-export declare const tracer: import("@opentelemetry/api").Tracer;
-//# sourceMappingURL=tracer.d.ts.map

package/out/zero-cache/src/services/view-syncer/tracer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/tracer.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM,qCAA0C,CAAC"}

package/out/zero-cache/src/services/view-syncer/ttl-clock.d.ts

@@ -1,10 +0,0 @@
-import * as v from '../../../../shared/src/valita.ts';
-declare const ttlClockTag: unique symbol;
-export type TTLClock = {
-    [ttlClockTag]: true;
-};
-export declare const ttlClockSchema: v.Type<TTLClock>;
-export declare function ttlClockAsNumber(ttlClock: TTLClock): number;
-export declare function ttlClockFromNumber(ttlClock: number): TTLClock;
-export {};
-//# sourceMappingURL=ttl-clock.d.ts.map

package/out/zero-cache/src/services/view-syncer/ttl-clock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ttl-clock.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/ttl-clock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,kCAAkC,CAAC;AAEtD,OAAO,CAAC,MAAM,WAAW,EAAE,OAAO,MAAM,CAAC;AAEzC,MAAM,MAAM,QAAQ,GAAG;IAAC,CAAC,WAAW,CAAC,EAAE,IAAI,CAAA;CAAC,CAAC;AAE7C,eAAO,MAAM,cAAc,EAAoC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAEhF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAE7D"}

package/out/zero-cache/src/services/view-syncer/view-syncer.d.ts

@@ -1,133 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { ChangeDesiredQueriesMessage } from '../../../../zero-protocol/src/change-desired-queries.ts';
-import type { InitConnectionMessage } from '../../../../zero-protocol/src/connect.ts';
-import type { DeleteClientsMessage } from '../../../../zero-protocol/src/delete-clients.ts';
-import type { UnparsedInspectUpMessage } from '../../../../zero-protocol/src/inspect-up.ts';
-import type { UpdateAuthMessage } from '../../../../zero-protocol/src/update-auth.ts';
-import { type Auth } from '../../auth/auth.ts';
-import type { NormalizedZeroConfig } from '../../config/normalize.ts';
-import type { CustomQueryTransformer } from '../../custom-queries/transform-query.ts';
-import type { InspectorDelegate } from '../../server/inspector-delegate.ts';
-import type { ViewSyncerDownstream } from '../../types/downstream.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 { Source } from '../../types/streams.ts';
-import { Subscription } from '../../types/subscription.ts';
-import type { ReplicaState } from '../replicator/replicator.ts';
-import type { ActivityBasedService } from '../service.ts';
-import type { BatchPacer } from './batch-pacer.ts';
-import type { ConnectionContextManager, ConnectionSelector } from './connection-context-manager.ts';
-import type { DrainCoordinator } from './drain-coordinator.ts';
-import { type MonotonicClock } from './hydration-budget.ts';
-import type { PipelineDriver } from './pipeline-driver.ts';
-import { type ShouldCutOffPush } from './push-cutoff.ts';
-import { type ClientQueryRecord, type CustomQueryRecord, type InternalQueryRecord } from './schema/types.ts';
-import { type TTLClock } from './ttl-clock.ts';
-export interface ViewSyncer {
-    initConnection(selector: ConnectionSelector, initConnectionMessage: InitConnectionMessage): Source<ViewSyncerDownstream>;
-    changeDesiredQueries(selector: ConnectionSelector, msg: ChangeDesiredQueriesMessage): Promise<void>;
-    deleteClients(selector: ConnectionSelector, msg: DeleteClientsMessage): Promise<string[]>;
-    inspect(selector: ConnectionSelector, msg: UnparsedInspectUpMessage): Promise<void>;
-    updateAuth(selector: ConnectionSelector, msg: UpdateAuthMessage, authRevisionChanged: boolean): Promise<void>;
-    connContextManager: ConnectionContextManager;
-    readonly queryCount: number;
-    readonly rowCount: number;
-    readonly createdAtMs: number;
-    readonly servedVersion: string | null;
-    readonly servingLagEligible: boolean;
-    pipelineHashes(): readonly PipelineHashInfo[];
-    readonly clientSchemaKey: string | undefined;
-}
-export type PipelineHashInfo = {
-    readonly transformationHash: string;
-    readonly internal: boolean;
-    readonly queryName: string | undefined;
-};
-export type SyncContext = ConnectionSelector & {
-    readonly profileID: string | null;
-    readonly baseCookie: string | null;
-    readonly protocolVersion: number;
-    readonly httpCookie: string | undefined;
-    readonly origin: string | undefined;
-    readonly userID: string | undefined;
-    readonly auth: Auth | undefined;
-};
-type SetTimeout = (fn: (...args: unknown[]) => void, delay?: number) => ReturnType<typeof setTimeout>;
-/**
- * We update the ttlClock in flush that writes to the CVR but
- * some flushes do not write to the CVR and in those cases we
- * use a timer to update the ttlClock every minute.
- */
-export declare const TTL_CLOCK_INTERVAL = 60000;
-/**
- * This is some extra time we delay the TTL timer to allow for some
- * slack in the timing of the timer. This is to allow multiple evictions
- * to happen in a short period of time without having to wait for the
- * next tick of the timer.
- */
-export declare const TTL_TIMER_HYSTERESIS = 50;
-export declare class ViewSyncerService implements ViewSyncer, ActivityBasedService {
-    #private;
-    readonly id: string;
-    readonly createdAtMs: number;
-    readonly connContextManager: ConnectionContextManager;
-    constructor(config: NormalizedZeroConfig, lc: LogContext, shard: ShardID, taskID: string, clientGroupID: string, cvrDb: PostgresDB, pipelineDriver: PipelineDriver, versionChanges: Subscription<ReplicaState>, drainCoordinator: DrainCoordinator, slowHydrateThreshold: number, inspectorDelegate: InspectorDelegate, connContextManager: ConnectionContextManager, customQueryTransformer: CustomQueryTransformer | undefined, runPriorityOp: <T>(lc: LogContext, description: string, op: () => Promise<T>) => Promise<T>, keepaliveMs?: number, setTimeoutFn?: SetTimeout, now?: MonotonicClock, pushCutoff?: ShouldCutOffPush, pacer?: BatchPacer);
-    readyState(): Promise<'initialized' | 'draining'>;
-    run(): Promise<void>;
-    get queryCount(): number;
-    pipelineHashes(): readonly PipelineHashInfo[];
-    get clientSchemaKey(): string | undefined;
-    get rowCount(): number;
-    get servedVersion(): LexiVersion | null;
-    get servingLagEligible(): boolean;
-    /**
-     * Guarantees that the ViewSyncer will remain running for at least
-     * its configured `keepaliveMs`. This is called when establishing a
-     * new connection to ensure that its associated ViewSyncer isn't
-     * shutdown before it receives the connection.
-     *
-     * @return `true` if the ViewSyncer will stay alive, `false` if the
-     *         ViewSyncer is shutting down.
-     */
-    keepalive(): boolean;
-    initConnection(selector: ConnectionSelector, initConnectionMessage: InitConnectionMessage): Source<ViewSyncerDownstream>;
-    changeDesiredQueries(selector: ConnectionSelector, msg: ChangeDesiredQueriesMessage): Promise<void>;
-    updateAuth(selector: ConnectionSelector, msg: UpdateAuthMessage, authRevisionChanged: boolean): Promise<void>;
-    deleteClients(selector: ConnectionSelector, msg: DeleteClientsMessage): Promise<string[]>;
-    inspect(selector: ConnectionSelector, msg: UnparsedInspectUpMessage): Promise<void>;
-    stop(): Promise<void>;
-    /**
-     * Test helper: Manually mark initialization as complete.
-     * This should only be used in tests that don't call initConnection().
-     */
-    markInitialized(): void;
-}
-/**
- * Whether a query's TTL has elapsed. A query must be expired for all clients
- * in order to be considered expired.
- *
- * Exported for testing.
- */
-export declare function expired(ttlClock: TTLClock, q: InternalQueryRecord | ClientQueryRecord | CustomQueryRecord): boolean;
-export declare class TimeSliceTimer {
-    #private;
-    /**
-     * @param yieldSlice How the timer yields the process, if not by taking
-     *        turns with the rest of the worker's work (see `yieldProcess()`).
-     */
-    constructor(lc: LogContext, yieldSlice?: () => Promise<void>);
-    start(): Promise<this>;
-    startWithoutYielding(): this;
-    yieldProcess(_msgForTesting?: string): Promise<void>;
-    elapsedLap(): number;
-    /** @returns the total elapsed time */
-    stop(): number;
-    /**
-     * @returns the elapsed time. This can be called while the Timer is running
-     *          or after it has been stopped.
-     */
-    totalElapsed(): number;
-}
-export {};
-//# sourceMappingURL=view-syncer.d.ts.map

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

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

package/out/zero-cache/src/types/downstream.d.ts

@@ -1,11 +0,0 @@
-import type { Downstream } from '../../../zero-protocol/src/down.ts';
-/**
- * A logical view-syncer message and, when already available, its serialized
- * wire representation. Keeping them together lets the connection reuse the
- * view-syncer's serialization instead of stringifying large poke parts again.
- */
-export type ViewSyncerDownstream = {
-    readonly message: Downstream;
-    readonly serialized: string | undefined;
-};
-//# sourceMappingURL=downstream.d.ts.map

package/out/zero-cache/src/types/downstream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"downstream.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/downstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oCAAoC,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC"}

package/out/zero-cache/src/types/error-with-level.d.ts

@@ -1,9 +0,0 @@
-import type { LogLevel } from '@rocicorp/logger';
-import { ProtocolError, type ErrorBody } from '../../../zero-protocol/src/error.ts';
-export declare class ProtocolErrorWithLevel extends ProtocolError {
-    readonly logLevel: LogLevel;
-    constructor(errorBody: ErrorBody, logLevel: LogLevel, options?: ErrorOptions);
-}
-export declare function getLogLevel(error: unknown): LogLevel;
-export declare function wrapWithProtocolError(error: unknown): ProtocolError;
-//# sourceMappingURL=error-with-level.d.ts.map

package/out/zero-cache/src/types/error-with-level.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-with-level.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/error-with-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAI/C,OAAO,EAEL,aAAa,EACb,KAAK,SAAS,EACf,MAAM,qCAAqC,CAAC;AAE7C,qBAAa,sBAAuB,SAAQ,aAAa;IACvD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B,YACE,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,YAAY,EAIvB;CACF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAMpD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAanE"}

package/out/zero-cache/src/types/pg-patch.d.ts

@@ -1,21 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-/**
- * Whether the imported postgres.js has Zero's patch
- * (`packages/zero/patches/postgres@3.4.7.patch`), which marks itself with
- * `Postgres.zeroPatch`. pnpm applies the patch in this repo and in the Docker
- * image, but not when `@rocicorp/zero` is installed from npm.
- *
- * The patch includes the `CopyDone` fix for
- * https://github.com/porsager/postgres/issues/499
- * (https://github.com/porsager/postgres/pull/1016). Without it, a connection
- * can stop responding after a COPY, on any Node version: if the last
- * `CopyData` fills the stream's buffer, the socket is paused, and it is never
- * resumed once the stream has ended. Node version and OS only change how often
- * this happens. Initial sync and backfill only wait for their COPY connections
- * to close when this returns `true`.
- *
- * A later version of the patch can raise the number to mark new fixes.
- */
-export declare function hasPostgresPatch(): boolean;
-export declare function warnIfPostgresUnpatched(lc: LogContext): void;
-//# sourceMappingURL=pg-patch.d.ts.map