@rocicorp/zero 1.12.0-canary.1 → 1.12.0-canary.11

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

@@ -1,128 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { InspectQueryRow } from '../../../../zero-protocol/src/inspect-down.ts';
-import { ProtocolErrorWithLevel } from '../../types/error-with-level.ts';
-import type { PostgresDB, PostgresTransaction } from '../../types/pg.ts';
-import { type ShardID } from '../../types/shards.ts';
-import type { PatchToVersion } from './client-handler.ts';
-import type { CVR, CVRSnapshot } from './cvr.ts';
-import { type RowsRow } from './schema/cvr.ts';
-import { type ClientRecord, type CVRVersion, type NullableCVRVersion, type QueryPatch, type QueryRecord, type RowID, type RowRecord } from './schema/types.ts';
-import { type TTLClock } from './ttl-clock.ts';
-export type CVRFlushStats = {
-    instances: number;
-    queries: number;
-    desires: number;
-    clients: number;
-    rows: number;
-    rowsDeferred: number;
-    statements: number;
-};
-export declare class CVRStore {
-    #private;
-    constructor(lc: LogContext, cvrDb: PostgresDB, shard: ShardID, taskID: string, cvrID: string, failService: (e: unknown) => void, loadAttemptIntervalMs?: number, maxLoadAttempts?: number, deferredRowFlushThreshold?: number, // somewhat arbitrary
-    setTimeoutFn?: typeof setTimeout);
-    load(lc: LogContext, lastConnectTime: number): Promise<CVR>;
-    getRowRecords(): Promise<ReadonlyMap<RowID, RowRecord>>;
-    putRowRecord(row: RowRecord): void;
-    /**
-     * Note: Removing a row from the CVR should be represented by a
-     *       {@link putRowRecord()} with `refCounts: null` in order to properly
-     *       produce the appropriate delete patch when catching up old clients.
-     *
-     * This `delRowRecord()` method, on the other hand, is only used for
-     * "canceling" the put of a row that was not in the CVR in the first place.
-     */
-    delRowRecord(id: RowID): void;
-    /**
-     * Overrides the default logic that removes no-op writes and forces
-     * the updates for the given row `ids`. This has no effect if there
-     * are no corresponding puts or dels for the associated row records.
-     */
-    forceUpdates(...ids: RowID[]): void;
-    /**
-     * Updates the `ttlClock` of the CVR instance. The ttlClock starts at 0 when
-     * the CVR instance is first created and increments based on elapsed time
-     * since the base time established by the ViewSyncerService.
-     */
-    updateTTLClock(ttlClock: TTLClock, lastActive: number): Promise<void>;
-    /**
-     * @returns This returns the current `ttlClock` of the CVR instance. The ttlClock
-     *          represents elapsed time since the instance was created (starting from 0).
-     *          If the CVR has never been initialized for this client group, it returns
-     *          `undefined`.
-     */
-    getTTLClock(): Promise<TTLClock | undefined>;
-    putInstance({ version, replicaVersion, lastActive, clientSchema, profileID, ttlClock, }: Pick<CVRSnapshot, 'version' | 'replicaVersion' | 'lastActive' | 'clientSchema' | 'profileID' | 'ttlClock'>): void;
-    markQueryAsDeleted(version: CVRVersion, queryPatch: QueryPatch): void;
-    putQuery(query: QueryRecord): void;
-    updateQuery(query: QueryRecord): void;
-    /**
-     * The persisted row-set signature of the query, or `undefined` if it has
-     * none (e.g. a query from before signatures were introduced). Reflects the
-     * loaded/flushed CVR; changes made with {@link updateRowSetSignature} are
-     * only visible after they are flushed.
-     */
-    rowSetSignature(queryHash: string): bigint | undefined;
-    updateRowSetSignature(queryHash: string, signature: bigint): void;
-    insertClient(client: ClientRecord): void;
-    deleteClient(clientID: string): void;
-    putDesiredQuery(newVersion: CVRVersion, query: {
-        id: string;
-    }, client: {
-        id: string;
-    }, deleted: boolean, inactivatedAt: TTLClock | undefined, ttl: number): void;
-    catchupRowPatches(lc: LogContext, afterVersion: NullableCVRVersion, upToCVR: CVRSnapshot, current: CVRVersion, excludeQueryHashes?: string[]): AsyncGenerator<RowsRow[], void, undefined>;
-    catchupConfigPatches(lc: LogContext, afterVersion: NullableCVRVersion, upToCVR: CVRSnapshot, current: CVRVersion): Promise<PatchToVersion[]>;
-    get rowCount(): number;
-    /**
-     * Flushes pending writes, checking that `expectedCurrentVersion` is still
-     * the current version of the CVR and that this task still owns it.
-     *
-     * If there is nothing to write, the flush is a no-op and no check is done,
-     * unless `verifyNoop` is set.
-     */
-    flush(lc: LogContext, expectedCurrentVersion: CVRVersion, cvr: CVRSnapshot, lastConnectTime: number, verifyNoop?: boolean): Promise<CVRFlushStats | null>;
-    /**
-     * Discards the writes queued since the last {@link flush}, i.e. those of
-     * an updater that is abandoned without being flushed (such as an
-     * advancement that aborts with a pipeline reset). Otherwise they would be
-     * written by the next flush, even though the poke that carried them to the
-     * clients was cancelled.
-     *
-     * The row cache is not affected: it only learns of writes when they are
-     * flushed.
-     */
-    discardPending(): void;
-    hasPendingUpdates(): boolean;
-    /** Resolves when all pending updates are flushed. */
-    flushed(lc: LogContext): Promise<void>;
-    inspectQueries(lc: LogContext, ttlClock: TTLClock, clientID?: string): Promise<InspectQueryRow[]>;
-}
-/**
- * This is similar to {@link CVRStore.#checkVersionAndOwnership} except
- * that it only checks the version and is suitable for snapshot reads
- * (i.e. by doing a plain `SELECT` rather than a `SELECT ... FOR UPDATE`).
- */
-export declare function checkVersion(tx: PostgresTransaction, schema: string, clientGroupID: string, expectedCurrentVersion: CVRVersion): Promise<void>;
-export declare class ClientNotFoundError extends ProtocolErrorWithLevel {
-    constructor(message: string);
-}
-export declare class ConcurrentModificationException extends ProtocolErrorWithLevel {
-    readonly name = "ConcurrentModificationException";
-    constructor(expectedVersion: string, actualVersion: string);
-}
-export declare class OwnershipError extends ProtocolErrorWithLevel {
-    readonly name = "OwnershipError";
-    constructor(owner: string | null, grantedAt: number | null, lastConnectTime: number);
-}
-export declare class InvalidClientSchemaError extends ProtocolErrorWithLevel {
-    readonly name = "InvalidClientSchemaError";
-    constructor(cause: unknown);
-}
-export declare class RowsVersionBehindError extends Error {
-    readonly name = "RowsVersionBehindError";
-    readonly cvrVersion: string;
-    readonly rowsVersion: string | null;
-    constructor(cvrVersion: string, rowsVersion: string | null);
-}
-//# sourceMappingURL=cvr-store.d.ts.map

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

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

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

@@ -1,294 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import { type JSONObject } from '../../../../shared/src/bigint-json.ts';
-import { type ReadonlyJSONValue } from '../../../../shared/src/json.ts';
-import type { AST } from '../../../../zero-protocol/src/ast.ts';
-import type { ClientSchema } from '../../../../zero-protocol/src/client-schema.ts';
-import type { LexiVersion } from '../../types/lexi-version.ts';
-import { type ShardID } from '../../types/shards.ts';
-import type { PatchToVersion } from './client-handler.ts';
-import { type CVRFlushStats, type CVRStore } from './cvr-store.ts';
-import { type ClientRecord, type CVRVersion, type InternalQueryRecord, type QueryRecord, type RowID } from './schema/types.ts';
-import { type TTLClock } from './ttl-clock.ts';
-export type RowUpdate = {
-    version?: string;
-    contents?: JSONObject;
-    refCounts: {
-        [hash: string]: number;
-    };
-};
-/** Internally used mutable CVR type. */
-export type CVR = {
-    id: string;
-    version: CVRVersion;
-    lastActive: number;
-    ttlClock: TTLClock;
-    replicaVersion: string | null;
-    clients: Record<string, ClientRecord>;
-    queries: Record<string, QueryRecord>;
-    clientSchema: ClientSchema | null;
-    profileID: string | null;
-};
-/** Exported immutable CVR type. */
-export type CVRSnapshot = {
-    readonly id: string;
-    readonly version: CVRVersion;
-    readonly lastActive: number;
-    readonly ttlClock: TTLClock;
-    readonly replicaVersion: string | null;
-    readonly clients: Readonly<Record<string, ClientRecord>>;
-    readonly queries: Readonly<Record<string, QueryRecord>>;
-    readonly clientSchema: ClientSchema | null;
-    readonly profileID: string | null;
-};
-export declare function getMutationResultsQuery(upstreamSchema: string, clientGroupID: string): InternalQueryRecord;
-/**
- * The base CVRUpdater contains logic common to the {@link CVRConfigDrivenUpdater} and
- * {@link CVRQueryDrivenUpdater}. The CVRUpdater class itself is exported for updating
- * the `lastActive` time of the CVR in the absence of any changes to the CVR contents.
- * Although activity is automatically tracked when the CVR contents change, there may be
- * edge cases in which a client actively connects to a CVR that doesn't itself change.
- * Calling `new CVRUpdater(...).flush()` will explicitly update the active index and
- * prevent the CVR from being garbage collected.
- */
-export declare class CVRUpdater {
-    protected readonly _orig: CVRSnapshot;
-    protected readonly _cvr: CVR;
-    protected readonly _cvrStore: CVRStore;
-    /**
-     * @param cvrStore The CVRStore to use for storage
-     * @param cvr The current CVR
-     */
-    constructor(cvrStore: CVRStore, cvr: CVRSnapshot, replicaVersion: string | null);
-    protected _mutableClients(): Record<string, ClientRecord>;
-    protected _mutableClient(id: string): ClientRecord;
-    protected _mutableQueries(): Record<string, QueryRecord>;
-    protected _mutableQuery(id: string): QueryRecord;
-    protected _setVersion(version: CVRVersion): {
-        stateVersion: string;
-        configVersion?: number | undefined;
-    };
-    /**
-     * Ensures that the new CVR has a higher version than the original.
-     * This method is idempotent in that it will always return the same
-     * (possibly bumped) version.
-     */
-    protected _ensureNewVersion(): CVRVersion;
-    /**
-     * @param verifyNoop Check that the original CVR is still current even if
-     *     there is nothing to write. See {@link CVRStore.flush}.
-     */
-    flush(lc: LogContext, lastConnectTime: number, lastActive: number, ttlClock: TTLClock, verifyNoop?: boolean): Promise<{
-        cvr: CVRSnapshot;
-        flushed: CVRFlushStats | false;
-    }>;
-}
-/**
- * A {@link CVRConfigDrivenUpdater} is used for updating a CVR with config-driven
- * changes. Note that this may result in row deletion (e.g. if queries get dropped),
- * but the `stateVersion` of the CVR does not change.
- */
-export declare class CVRConfigDrivenUpdater extends CVRUpdater {
-    #private;
-    constructor(cvrStore: CVRStore, cvr: CVRSnapshot, shard: ShardID);
-    ensureClient(id: string): ClientRecord;
-    setClientSchema(lc: LogContext, clientSchema: ClientSchema): void;
-    setProfileID(lc: LogContext, profileID: string): void;
-    putDesiredQueries(clientID: string, queries: Readonly<{
-        hash: string;
-        ast?: AST | undefined;
-        name?: string | undefined;
-        args?: readonly ReadonlyJSONValue[] | undefined;
-        ttl?: number | undefined;
-    }>[]): PatchToVersion[];
-    markDesiredQueriesAsInactive(clientID: string, queryHashes: string[], ttlClock: TTLClock): PatchToVersion[];
-    deleteDesiredQueries(clientID: string, queryHashes: string[]): PatchToVersion[];
-    clearDesiredQueries(clientID: string): PatchToVersion[];
-    deleteClient(clientID: string, ttlClock: TTLClock): PatchToVersion[];
-}
-type Hash = string;
-export type Column = string;
-export type RefCounts = Record<Hash, number>;
-/**
- * The row-set signatures maintained by the pipeline driver, used by
- * {@link CVRQueryDrivenUpdater.flush} to persist the ones that changed.
- * Implemented by `PipelineDriver`.
- */
-export interface RowSetSignatureProvider {
-    /**
-     * IDs of the queries whose signature changed since the last
-     * {@link clearChangedRowSetSignatures}. Queries not in this set are not
-     * looked at, so that a flush does not have to visit every query.
-     */
-    changedRowSetSignatures(): Iterable<string>;
-    /**
-     * The current signature for the query. `undefined` means "no pipeline for
-     * this query right now" — the stored signature on disk is left alone.
-     */
-    rowSetSignature(queryID: string): bigint | undefined;
-    /** Called after the changed signatures have been flushed. */
-    clearChangedRowSetSignatures(): void;
-}
-/**
- * A {@link CVRQueryDrivenUpdater} is used for updating a CVR after making queries.
- * The caller should invoke:
- *
- * * {@link trackQueries} for queries that are being executed or removed.
- * * {@link received} for all rows received from the executed queries
- * * {@link removeTrackedQueries} for optional queries that did not execute
- * * {@link deleteUnreferencedRows} to remove any rows that have
- *       fallen out of the query result view.
- * * {@link flush}
- *
- * After flushing, the caller should perform any necessary catchup of
- * config and row patches for clients that are behind. See
- * {@link CVRStore.catchupConfigPatches} and {@link CVRStore.catchupRowPatches}.
- */
-export declare class CVRQueryDrivenUpdater extends CVRUpdater {
-    #private;
-    /**
-     * @param stateVersion The `stateVersion` at which the queries were executed.
-     * @param rowSetSignature Optional source of the current row-set
-     *        signatures, typically the `PipelineDriver`. When provided,
-     *        {@link flush} persists the signatures that changed.
-     */
-    constructor(cvrStore: CVRStore, cvr: CVRSnapshot, stateVersion: LexiVersion, replicaVersion: string, rowSetSignature?: RowSetSignatureProvider);
-    /**
-     * Initiates the tracking of the specified `executed` and `removed` queries.
-     * This kicks of a lookup of existing {@link RowRecord}s currently associated
-     * with those queries, which will be used to reconcile the rows to keep
-     * after all rows have been {@link received()}.
-     *
-     * "transformed" queries are queries that are currently
-     * gotten and running in the pipeline driver but
-     * received a new transformation hash due to an auth token
-     * update.
-     *
-     * @returns The new CVRVersion to be used when all changes are committed.
-     */
-    trackQueries(lc: LogContext, executed: {
-        id: string;
-        transformationHash: string;
-    }[], removed: {
-        id: string;
-    }[]): {
-        newVersion: CVRVersion;
-        queryPatches: PatchToVersion[];
-    };
-    /**
-     * Converts queries that were tracked as executed into normal query
-     * removals. This is used when a hydration budget expires after
-     * `trackQueries()` has established the final poke version but before an
-     * optional query starts hydration.
-     *
-     * The query ID remains in `#removedOrExecutedQueryIDs`, so its row
-     * references are dropped by {@link deleteUnreferencedRows} exactly as they
-     * would be for a query removed up front. Never un-track a query here: rows
-     * already flushed by {@link received} have had its refCounts stripped and
-     * cannot be restored.
-     */
-    removeTrackedQueries(queryIDs: Iterable<string>): PatchToVersion[];
-    /**
-     * Aborts queries that were tracked as executed but whose hydration was cut
-     * short (see the view-syncer's hydration circuit breaker).
-     *
-     * Rows received for an aborted query in this update have that query's
-     * references stripped: a row left with no references is deleted, and the
-     * 'del' patch cancels the 'put' the client has already received, while a
-     * row still referenced by other queries keeps its patch version. The query
-     * is then removed from the CVR. It stays tracked as executed, so
-     * {@link deleteUnreferencedRows} also drops the references held by rows that
-     * were synced for it before this update, exactly as for a removed query.
-     *
-     * Like {@link removeTrackedQueries}, this must be called after
-     * {@link trackQueries} has established the final version, and after all
-     * rows of the aborted queries have been {@link received}.
-     */
-    abortExecutedQueries(lc: LogContext, queryIDs: readonly string[]): Promise<PatchToVersion[]>;
-    /**
-     * Retracts what queries have contributed to this update, so that they can
-     * be executed again from scratch in the same update. This is for a query
-     * whose changes were being received incrementally (see
-     * `PipelineDriver.advance()`) until its pipeline was abandoned in favor of
-     * hydrating it again.
-     *
-     * Rows received so far in this update have the queries' references
-     * stripped, as in {@link abortExecutedQueries}, except that a row left
-     * with no references is only deleted by {@link deleteUnreferencedRows}, if
-     * it is still unreferenced by then. Until then the clients keep the row
-     * and the patches they received for it in this update, so a row that is
-     * received again unchanged needs no patch at all. The queries are then
-     * tracked as executed, without changing them in the CVR: the references
-     * they held before this update are replaced, rather than adjusted, by the
-     * rows subsequently {@link received} for them, and
-     * {@link deleteUnreferencedRows} drops the references of rows that are not
-     * received again.
-     *
-     * Unlike {@link trackQueries}, this can be called on an updater that has
-     * not tracked any queries, and after rows have been received. All rows
-     * that the queries' pipelines have output must have been {@link received}
-     * first, and {@link deleteUnreferencedRows} must be called once the
-     * queries' rows have been received again.
-     */
-    retractQueries(lc: LogContext, queryIDs: readonly string[]): Promise<PatchToVersion[]>;
-    updatedVersion(): CVRVersion;
-    /**
-     * Public alias for {@link _ensureNewVersion}. Forces a `configVersion` bump
-     * when the caller needs a new CVR version for reasons outside the built-in
-     * tracking (e.g. rowSetSignature drift re-execution).
-     */
-    ensureNewVersion(): CVRVersion;
-    flush(lc: LogContext, lastConnectTime: number, lastActive: number, ttlClock: TTLClock, verifyNoop?: boolean): Promise<{
-        cvr: CVRSnapshot;
-        flushed: CVRFlushStats | false;
-    }>;
-    /**
-     * Tracks rows received from executing queries. This will update row records
-     * and row patches if the received rows have a new version. The method also
-     * returns (put) patches to be returned to update their state, versioned by
-     * patchVersion so that only the patches new to the clients are sent.
-     */
-    received(lc: LogContext, rows: Map<RowID, RowUpdate>): Promise<PatchToVersion[]>;
-    /**
-     * Computes and updates the row records based on:
-     * * The {@link #executed} queries
-     * * The {@link #removed} queries
-     * * The {@link received} rows
-     *
-     * Returns the final delete and patch ops that must be sent to the client
-     * to delete rows that are no longer referenced by any query.
-     *
-     * This is Step [5] of the
-     * [CVR Sync Algorithm](https://www.notion.so/replicache/Sync-and-Client-View-Records-CVR-a18e02ec3ec543449ea22070855ff33d?pvs=4#7874f9b80a514be2b8cd5cf538b88d37).
-     */
-    deleteUnreferencedRows(lc?: LogContext): Promise<PatchToVersion[]>;
-}
-/**
- * The query must be inactive for all clients to be considered inactive.
- * This is because expiration is defined that way: a query is expired for a client group
- * only if it is expired for all clients in the group.
- *
- * If all clients have inactivated the query, we return
- * the one with the expiration furthest in the future.
- */
-export declare function getInactiveQueries(cvr: CVR): {
-    hash: string;
-    inactivatedAt: TTLClock;
-    ttl: number;
-}[];
-export type HydrationQueryGroups<T extends QueryRecord = QueryRecord> = {
-    required: T[];
-    /**
-     * Never contains an internal query: those are always required, so callers
-     * can rely on `patchVersion` being present on the type.
-     */
-    optional: Exclude<T, InternalQueryRecord>[];
-};
-/**
- * Splits hydration candidates into required and optional queries. Optional
- * queries are ordered from latest to earliest effective expiration; an
- * ownerless query has the lowest priority.
- */
-export declare function classifyQueriesForHydration<T extends QueryRecord>(queries: Iterable<T>): HydrationQueryGroups<T>;
-export declare function nextEvictionTime(cvr: CVR): TTLClock | undefined;
-export {};
-//# sourceMappingURL=cvr.d.ts.map

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

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

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

@@ -1,81 +0,0 @@
-/**
- * The bytes assumed for each row held in memory, which converts the memory
- * given to deferred writes into rows. The width of the rows an advancement
- * will hold is not known before it starts.
- */
-export declare const BYTES_PER_ROW = 1024;
-/**
- * Bounds the memory that deferred IVM writes (see `deferIvmWrites`) use
- * across the client groups of one syncer process.
- *
- * Each client group holds its own in-memory copy of the changes of the
- * advancement it is processing, so the copies add up across the groups that
- * advance at the same time. Before an advancement starts, its pipeline driver
- * reserves the number of change log entries it advances through (of every
- * table, since counting only the tables it reads would take a scan of the
- * entries). That number bounds the rows its sources can hold: the change log
- * has one entry per row key (a truncation, which does not, resets the
- * pipelines instead), and a row displaced through a unique key must itself
- * have changed in the same interval, so it has its own entry. (An entry that
- * sets a row of a table whose primary key in the client schema is not the key
- * the change log uses can change the row's primary key, which is two rows, so
- * the driver reserves a second row for it as it gets to it.) An advancement that does
- * not fit is written through to the replica snapshot instead, which SQLite
- * bounds with its page cache and spills to disk.
- *
- * The rows are reserved at an assumed {@link BYTES_PER_ROW}, but their width
- * is not known until they are held. So the advancements also add up the
- * bytes they are estimated to hold as they go, and the one that takes the
- * total past the budget writes what it holds through to the replica snapshot,
- * and the rest of its changes after them.
- *
- * The budget is a share of the heap, so it does not depend on how many
- * client groups are connected: when advancements do not overlap, each one
- * can use all of it, and when many do, each gets less and the rest write
- * through.
- */
-export declare class DeferredWritesBudget {
-    #private;
-    /**
-     * A budget of `proportion` of the heap limit, and the rows that fit in it
-     * at {@link BYTES_PER_ROW}.
-     */
-    static forHeapProportion(proportion: number): DeferredWritesBudget;
-    /** A budget of `bytes`, and the rows that fit in it at {@link BYTES_PER_ROW}. */
-    static forBytes(bytes: number): DeferredWritesBudget;
-    constructor(maxRows: number, maxBytes: number);
-    get maxRows(): number;
-    get maxBytes(): number;
-    get reservedRows(): number;
-    /** The estimated bytes held by the advancements that hold rows. */
-    get heldBytes(): number;
-    /**
-     * Reserves `rows` if they fit in what is left of the budget, and returns
-     * whether they did. A successful reservation must be {@link release}d.
-     */
-    tryReserve(rows: number): boolean;
-    /**
-     * Reserves `rows` more for an advancement that is already holding rows, if
-     * they fit. An advancement reserves a row this way for each change log entry
-     * that can change the primary key of the row it sets, as it gets to it, and
-     * writes through if it does not fit. The rows are {@link release}d with the rest.
-     */
-    tryReserveMore(rows: number): boolean;
-    /**
-     * Adds `bytes` (fewer if negative) to the estimated bytes held by an
-     * advancement that has reserved rows, and returns whether the total is
-     * still within the budget. If it is not, the advancement is expected to
-     * stop holding rows and {@link release} them.
-     */
-    holdBytes(bytes: number): boolean;
-    /**
-     * The advancements that have held more rows than they reserved, which the
-     * reservation is supposed to rule out. Each writes through the rest of its
-     * changes instead.
-     */
-    get rowOverruns(): number;
-    recordRowOverrun(): void;
-    /** Returns an advancement's reserved `rows` and the `bytes` it held. */
-    release(rows: number, bytes: number): void;
-}
-//# sourceMappingURL=deferred-writes-budget.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"deferred-writes-budget.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/deferred-writes-budget.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,oBAAoB;;IAO/B;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,CAIjE;IAED,iFAAiF;IACjF,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,CAEnD;IAED,YAAY,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAG5C;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,mEAAmE;IACnE,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpC;IAUD;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAIhC;IAED;;;;OAIG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,gBAAgB,IAAI,IAAI,CAEvB;IAED,wEAAwE;IACxE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYzC;CACF"}

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

@@ -1,45 +0,0 @@
-type DrainListener = () => void;
-/**
- * There are two types of drains:
- * 1. Elective drains happen when a view-syncer is about to process
- *    a replication event and drains instead because {@link shouldDrain()}
- *    returned true. In this case, it exits its processing loop and
- *    calls {@link drainNextIn()} immediately.
- * 2. Force drains are performed by the Syncer, which picks a random
- *    view-syncer and calls {@link stop()}.
- *
- * In the case of a forced drain, the view-syncer may be queued up
- * behind a large amount of CPU-consuming events, and thus it may take
- * a long time before it actually stops. Elective drains are preferred because
- * they are less subject to that variance. However, elective drains only happen
- * if there is a task to be processed, so forced drains are still necessary
- * for draining servers with no work / tasks.
- *
- * The Syncer kicks off the drain process by calling {@link drainNextIn drainNextIn(0)},
- * which sets off a short {@link forceDrainTimeout} but starts returning `true` for
- * {@link shouldDrain()} for elective drains. In the latter case, the drained
- * view-syncer immediately exiting its processing loop and calls
- * {@link drainNextIn drainNextIn(myHydrationTime)} to reset the timeout
- * for the next elective or forced drain.
- */
-export declare class DrainCoordinator {
-    #private;
-    /**
-     * Calls `listener` once draining has started (immediately if it already
-     * has) and returns a function that unsubscribes it.
-     *
-     * This is a subscription rather than a Promise so that a caller that stops
-     * caring (e.g. a view-syncer that finished initializing) can let go of it.
-     * A reaction attached to a Promise that may never settle would otherwise
-     * be retained by the coordinator for the lifetime of the server, once per
-     * view-syncer ever created.
-     */
-    onDraining(listener: DrainListener): () => void;
-    get drainListenerCount(): number;
-    shouldDrain(): 0 | boolean;
-    drainNextIn(interval: number): void;
-    get forceDrainTimeout(): Promise<void>;
-    get nextDrainTime(): number;
-}
-export {};
-//# sourceMappingURL=drain-coordinator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drain-coordinator.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/drain-coordinator.ts"],"names":[],"mappings":"AAGA,KAAK,aAAa,GAAG,MAAM,IAAI,CAAC;AAMhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,gBAAgB;;IAO3B;;;;;;;;;OASG;IACH,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,IAAI,CAS9C;IAGD,IAAI,kBAAkB,WAErB;IAED,WAAW,gBAEV;IAED,WAAW,CAAC,QAAQ,EAAE,MAAM,QA0B3B;IAED,IAAI,iBAAiB,kBAEpB;IAGD,IAAI,aAAa,WAEhB;CACF"}

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

@@ -1,53 +0,0 @@
-import type { ReplicaState } from '../replicator/replicator.ts';
-export type PendingUpstreamCommit = {
-    readonly watermark: string;
-    readonly commitTimeMs: number;
-};
-/**
- * Pairs the upstream commit timestamps carried by `version-ready`
- * notifications with the moment the corresponding change is poked to clients,
- * yielding the end-to-end serving lag.
- *
- * This measures completion, not backlog: an observation is produced only when
- * work actually reaches clients, so the resulting histogram is a latency
- * distribution rather than a periodic snapshot of how far behind things are.
- * A ViewSyncer that is stuck contributes nothing until it recovers, instead of
- * re-reporting its age on every sample tick.
- *
- * "Reaches clients" includes an advancement that had nothing to send this
- * client group. Such an advancement still establishes that the group is
- * current as of that commit, so it must clear the pending commit; a tracker
- * that waited for a *data* poke would instead accumulate the oldest commit
- * across every quiet interval and report the whole interval as lag the next
- * time the group happened to match a transaction. The caller is responsible
- * for passing the replica version it advanced to rather than the CVR version,
- * which only moves when there is something to write.
- */
-export declare class E2EServingLagTracker {
-    #private;
-    get pending(): PendingUpstreamCommit | null;
-    /**
-     * Records the upstream commit behind a `version-ready` notification.
-     *
-     * Notifications coalesce when the ViewSyncer is busy, so one state may stand
-     * in for several commits. The *oldest* commit time is kept, since it bounds
-     * the lag of everything the notification subsumed, while the watermark
-     * advances to the newest — that is the one that must be served for all of
-     * the subsumed commits to have been delivered.
-     */
-    onVersionReady({ watermark, upstreamCommitTimeMs }: ReplicaState): void;
-    /**
-     * Called once a version has been poked to clients.
-     *
-     * @return the observation to record, or `null` if the served version does
-     *     not yet cover an outstanding upstream commit.
-     */
-    onVersionServed(servedVersion: string, nowMs: number): Observation | null;
-}
-export type Observation = {
-    /** End-to-end lag in milliseconds, clamped to be non-negative. */
-    readonly lagMs: number;
-    /** Whether the clamp was applied, i.e. the raw measurement was negative. */
-    readonly clamped: boolean;
-};
-//# sourceMappingURL=e2e-serving-lag.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"e2e-serving-lag.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/e2e-serving-lag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAE9D,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,oBAAoB;;IAG/B,IAAI,OAAO,IAAI,qBAAqB,GAAG,IAAI,CAE1C;IAED;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAC,SAAS,EAAE,oBAAoB,EAAC,EAAE,YAAY,GAAG,IAAI,CAYpE;IAED;;;;;OAKG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAmBxE;CACF;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC"}