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

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"}

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

@@ -1,33 +0,0 @@
-export type MonotonicClock = () => number;
-/**
- * A soft wall-clock budget for one view-syncer hydration pass.
- *
- * Callers check the budget only at query boundaries. Consequently, a query
- * that starts before the limit is reached is always allowed to finish.
- *
- * The budget measures hydration work. Intervals that are not hydration --
- * notably the remote custom-query transform round trips -- are discounted via
- * {@link excluding}, so that endpoint latency cannot spend a budget that only
- * evicting queries could recover.
- */
-export declare class HydrationBudget {
-    #private;
-    readonly limitMs: number;
-    constructor(limitMs: number, now?: MonotonicClock);
-    /**
-     * Runs `fn`, discounting the time it takes as non-hydration work. The
-     * interval is measured with this budget's own clock, so an injected clock
-     * governs both the elapsed time and what is excluded from it.
-     */
-    excluding<T>(fn: () => Promise<T>): Promise<T>;
-    elapsedMs(): number;
-    /**
-     * Whether the budget is spent. A disabled budget (`limitMs === 0`) is never
-     * exhausted. The elapsed time at the first exhausted check is retained in
-     * {@link exhaustedAtMs} so that reporting does not re-read the clock.
-     */
-    exhausted(): boolean;
-    /** The elapsed time at which {@link exhausted} first returned true. */
-    get exhaustedAtMs(): number | undefined;
-}
-//# sourceMappingURL=hydration-budget.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hydration-budget.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/hydration-budget.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,MAAM,MAAM,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,qBAAa,eAAe;;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAMzB,YACE,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,cAAkD,EASxD;IAED;;;;OAIG;IACG,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAOnD;IAED,SAAS,IAAI,MAAM,CAElB;IAED;;;;OAIG;IACH,SAAS,IAAI,OAAO,CAUnB;IAED,uEAAuE;IACvE,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAEtC;CACF"}

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

@@ -1,51 +0,0 @@
-import type { MonotonicClock } from './hydration-budget.ts';
-/**
- * How long a tripped query stays rejected before a retry is allowed.
- *
- * A query that blows the timeout is almost always slow because of the shape
- * of its data rather than because of transient load, so retrying it on every
- * reconnect would burn a full timeout each time. The cooldown keeps that cost
- * to at most one timeout per cooldown period per query.
- */
-export declare const DEFAULT_CIRCUIT_BREAKER_OPEN_MS: number;
-/**
- * A per-query circuit breaker for view-syncer hydration.
- *
- * Hydration of a single query is aborted once its processing time exceeds
- * {@link timeoutMs}. Callers check {@link exceeded} at the yield points of a
- * hydration, so a query is only ever aborted between time slices.
- *
- * Once a query has been aborted the breaker is "open" for its transformation
- * hash: {@link isOpen} reports true for {@link openMs}, and callers reject the
- * query up front instead of hydrating it again. After that the breaker is
- * implicitly half-open: the next hydration attempt runs, and either succeeds
- * or trips the breaker again.
- *
- * The breaker is keyed by transformation hash rather than query hash because
- * the transformation (permissions, auth context) determines the pipeline that
- * runs, and a different transformation of the same query may well be fast.
- */
-export declare class HydrationCircuitBreaker {
-    #private;
-    readonly timeoutMs: number;
-    readonly openMs: number;
-    constructor(timeoutMs: number, openMs?: number, now?: MonotonicClock);
-    /** Whether the breaker does anything at all. */
-    get enabled(): boolean;
-    /**
-     * Whether a hydration that has consumed `elapsedMs` of processing time must
-     * be aborted. Always false when the breaker is disabled.
-     */
-    exceeded(elapsedMs: number): boolean;
-    /**
-     * Records that hydrating `transformationHash` was aborted.
-     *
-     * Trips are rare, so this is also when expired entries are swept, which
-     * keeps the map bounded by the number of hashes tripped within one cooldown
-     * rather than by every hash ever tripped.
-     */
-    trip(transformationHash: string): void;
-    /** Whether `transformationHash` is currently rejected. */
-    isOpen(transformationHash: string): boolean;
-}
-//# sourceMappingURL=hydration-circuit-breaker.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hydration-circuit-breaker.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/hydration-circuit-breaker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAE1D;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,QAAa,CAAC;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,uBAAuB;;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAIxB,YACE,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAwC,EAChD,GAAG,GAAE,cAAkD,EAUxD;IAED,gDAAgD;IAChD,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEnC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAQrC;IAED,0DAA0D;IAC1D,MAAM,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAU1C;CACF"}

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

@@ -1,34 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { AnalyzeQueryResult } from '../../../../zero-protocol/src/analyze-query-result.ts';
-import type { QueryServerMetrics } from '../../../../zero-protocol/src/inspect-down.ts';
-import { type UnparsedInspectUpMessage } from '../../../../zero-protocol/src/inspect-up.ts';
-import type { NormalizedZeroConfig } from '../../config/normalize.ts';
-import type { InspectorDelegate } from '../../server/inspector-delegate.ts';
-import type { ClientHandler } from './client-handler.ts';
-import type { ConnectionContext } from './connection-context-manager.ts';
-import type { CVRStore } from './cvr-store.ts';
-import type { CVRSnapshot } from './cvr.ts';
-export declare function handleInspect(lc: LogContext, body: UnparsedInspectUpMessage[1], cvr: CVRSnapshot, client: ClientHandler, inspectorDelegate: InspectorDelegate, clientGroupID: string, authOwner: object, cvrStore: CVRStore, config: NormalizedZeroConfig, ctx: ConnectionContext): Promise<void>;
-/**
- * Removes the planner's `filter` nodes from `joinPlans` for clients before
- * protocol 53, which added that node type. 1.9 and 1.10 clients fail to parse
- * a node type they don't know, and the failed parse puts the client in its
- * error state.
- *
- * @visibleForTesting
- */
-export declare function analyzeResultForProtocol(result: AnalyzeQueryResult, protocolVersion: number): AnalyzeQueryResult;
-/**
- * Converts per-query server metrics to the appropriate wire format based on the
- * client's protocol version.
- *
- * Protocol >= 51: new format — `query-hydration-server-ms` (plain number) +
- *   `query-update-server` (TDigest).
- * Protocol < 51: old format — `query-materialization-server` (TDigest) +
- *   `query-update-server` (TDigest). The scalar hydration time is wrapped into a
- *   one-point TDigest for backward compatibility.
- *
- * @visibleForTesting
- */
-export declare function metricsForProtocol(metrics: QueryServerMetrics | null, protocolVersion: number): QueryServerMetrics | null;
-//# sourceMappingURL=inspect-handler.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"inspect-handler.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/inspect-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,uDAAuD,CAAC;AAC9F,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,6CAA6C,CAAC;AAGrD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAMpE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oCAAoC,CAAC;AAE1E,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AAE1C,wBAAsB,aAAa,CACjC,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,wBAAwB,CAAC,CAAC,CAAC,EACjC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,aAAa,EACrB,iBAAiB,EAAE,iBAAiB,EACpC,aAAa,EAAE,MAAM,EAGrB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,oBAAoB,EAC5B,GAAG,EAAE,iBAAiB,GACrB,OAAO,CAAC,IAAI,CAAC,CA+Jf;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,eAAe,EAAE,MAAM,GACtB,kBAAkB,CAUpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,kBAAkB,GAAG,IAAI,EAClC,eAAe,EAAE,MAAM,GACtB,kBAAkB,GAAG,IAAI,CAmB3B"}

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

@@ -1,296 +0,0 @@
-import type { LogContext } from '@rocicorp/logger';
-import type { AST, LiteralValue } from '../../../../zero-protocol/src/ast.ts';
-import type { ClientSchema } from '../../../../zero-protocol/src/client-schema.ts';
-import type { Row } from '../../../../zero-protocol/src/data.ts';
-import { ChangeType } from '../../../../zql/src/ivm/change-type.ts';
-import { type Input } from '../../../../zql/src/ivm/operator.ts';
-import type { PlanWarning } from '../../../../zql/src/planner/planner-warnings.ts';
-import type { ClientGroupStorage } from '../../../../zqlite/src/database-storage.ts';
-import { type LoadedPermissions } from '../../auth/load-permissions.ts';
-import type { LogConfig, ZeroConfig } from '../../config/zero-config.ts';
-import type { LiteAndZqlSpec } from '../../db/specs.ts';
-import type { InspectorDelegate } from '../../server/inspector-delegate.ts';
-import { type RowKey } from '../../types/row-key.ts';
-import { type ShardID } from '../../types/shards.ts';
-import type { DeferredWritesBudget } from './deferred-writes-budget.ts';
-import { type QueryPushProgress, type ShouldCutOffPush } from './push-cutoff.ts';
-import { type QueryShape } from './query-shape.ts';
-import type { QueryStats } from './query-stats.ts';
-import type { Snapshotter } from './snapshotter.ts';
-type RowOp<Op extends Omit<ChangeType, ChangeType.CHILD>> = {
-    readonly type: Op;
-    readonly queryID: string;
-    readonly table: string;
-    readonly rowKey: Row;
-    readonly row: Row;
-};
-export type RowAdd = RowOp<ChangeType.ADD>;
-export type RowRemove = RowOp<ChangeType.REMOVE>;
-export type RowEdit = RowOp<ChangeType.EDIT>;
-export type RowChange = RowAdd | RowRemove | RowEdit;
-export type QueryInfo = {
-    readonly transformedAst: AST;
-    readonly originalAst?: AST | undefined;
-    readonly transformationHash: string;
-    readonly queryName?: string | undefined;
-};
-export type HydrationStats = {
-    /** The rows the hydration output. */
-    readonly rowCount: number;
-    /**
-     * The rows the hydration read from the replica, including rows that were
-     * then filtered out, e.g. by a filter that could not be pushed to SQLite or
-     * by an EXISTS that did not match. Much greater than {@link rowCount} means
-     * the query does a lot of work for the rows it returns.
-     */
-    readonly rowsRead: number;
-    /** What the planner warned about the plan it chose for the query. */
-    readonly planWarnings: readonly PlanWarning[];
-    /** The {@link queryShape} of the query, computed when it was hydrated. */
-    readonly shape: QueryShape;
-};
-export type PipelineHydrationReason = 'query-set-sync' | 'unchanged-query-rehydrate';
-type PipelineStopReason = 'replace-query' | 'remove-query' | 'abandon-advance' | 'reset' | 'destroy';
-export type AdvancementProgress = {
-    /** Raw ChangeLog entries read, including skipped entries and the current change. */
-    readonly changesScanned: number;
-    /** Yielded source changes whose push processing completed. */
-    readonly changesProcessed: number;
-    /** Raw entries omitted by the snapshot diff. */
-    readonly changesSkipped: number;
-};
-/**
- * A query whose pipeline was removed by a {@link CostBasedAdvance}, either
- * before the advancement's changes were pushed or partway through them
- * (`'cutoff'`). Before, it is because pushing them to the query was
- * estimated to cost more than hydrating it again (`'estimate'`), or because
- * reading them was, for the queries that were left to push them to
- * (`'read'`). The row changes it output before then have been returned by
- * the advancement. To bring the query to the advancement's
- * version, hydrate it again with {@link PipelineDriver.addQuery}, passing its
- * `originalAst`, once the advancement's changes have been iterated over in
- * their entirety.
- */
-export type AbandonedQuery = QueryPushProgress & {
-    readonly reason: 'estimate' | 'read' | 'cutoff';
-    /** What pushing the advancement's changes to it was estimated to cost. */
-    readonly estimatedPushMs?: number | undefined;
-    readonly transformationHash: string;
-    readonly transformedAst: AST;
-    /** The AST the query was added with. */
-    readonly originalAst: AST;
-    readonly queryName?: string | undefined;
-};
-/**
- * Bounds the cost of an advancement query by query, by hydrating a query
- * again when that is cheaper than pushing the advancement's changes through
- * its pipeline. This is an alternative to the client group's advancement
- * time limit, which does not apply to an advancement that is given this.
- * Such an advancement is never aborted for taking too long.
- */
-export type CostBasedAdvance = {
-    /**
-     * Between changes, the pipeline of each query that this says to stop
-     * pushing to is removed (see {@link PushCutoff}).
-     */
-    readonly shouldCutOff: ShouldCutOffPush;
-    /**
-     * Before any change is pushed, the pipelines of the queries that are
-     * estimated to be cheaper to hydrate again than to push the advancement's
-     * changes to are removed (see {@link shouldStartOnRebuild}). This is how
-     * many times cheaper.
-     */
-    readonly rebuildMargin: number;
-};
-/** How an estimate of a query's push time compared with the actual time. */
-export type PushEstimate = {
-    readonly queryID: string;
-    readonly estimatedPushMs: number;
-    readonly pushTimeMs: number;
-};
-export type Timer = {
-    elapsedLap: () => number;
-    totalElapsed: () => number;
-};
-/**
- * Manages the state of IVM pipelines for a given ViewSyncer (i.e. client group).
- */
-export declare class PipelineDriver {
-    #private;
-    constructor(lc: LogContext, logConfig: LogConfig, snapshotter: Snapshotter, shardID: ShardID, storage: ClientGroupStorage, clientGroupID: string, inspectorDelegate: InspectorDelegate, yieldThresholdMs: () => number, enablePlanner?: boolean, config?: ZeroConfig, deferredWrites?: DeferredWritesBudget, queryStats?: QueryStats | undefined);
-    /**
-     * Initializes the PipelineDriver to the current head of the database.
-     * Queries can then be added (i.e. hydrated) with {@link addQuery()}.
-     *
-     * Must only be called once.
-     */
-    init(clientSchema: ClientSchema): void;
-    /**
-     * @returns Whether the PipelineDriver has been initialized.
-     */
-    initialized(): boolean;
-    /**
-     * Clears the current pipelines and TableSources, returning the PipelineDriver
-     * to its initial state. This should be called in response to a schema change,
-     * as TableSources need to be recomputed.
-     */
-    reset(clientSchema: ClientSchema): void;
-    /** @returns The replica version. The PipelineDriver must have been initialized. */
-    get replicaVersion(): string;
-    /**
-     * Returns the current version of the database. This will reflect the
-     * latest version change when calling {@link advance()} once the
-     * iteration has begun.
-     */
-    currentVersion(): string;
-    /**
-     * Returns the current upstream {app}.permissions, or `null` if none are defined.
-     */
-    currentPermissions(): LoadedPermissions | null;
-    /**
-     * Advances the snapshot to the head of the database without diffing the
-     * change log, in preparation for hydrating queries at head.
-     *
-     * Throws a {@link ResetPipelinesSignal} if the change log records a
-     * schema change since the previous snapshot. The table specs (and any
-     * TableSources built from them) were computed at or before that snapshot
-     * and are stale with respect to the new head, so the caller must
-     * {@link reset()} before hydrating. ({@link advance()} detects this when
-     * the diff encounters the RESET op; this path skips the diff and so must
-     * check explicitly.)
-     *
-     * @param releasePreviousSnapshot Whether to release the snapshot that the
-     *        driver was at, which is otherwise left open until the next
-     *        advance (see `Snapshotter.releasePrevious()`).
-     */
-    advanceWithoutDiff(releasePreviousSnapshot?: boolean): string;
-    /**
-     * Clears storage used for the pipelines. Call this when the
-     * PipelineDriver will no longer be used.
-     */
-    destroy(): void;
-    /** @return Map from query ID to PipelineInfo for all added queries. */
-    queries(): ReadonlyMap<string, QueryInfo>;
-    /**
-     * The queries whose pipelines a {@link CostBasedAdvance} removed and that
-     * have not been hydrated again since, by query ID. They are not in
-     * {@link queries()}. A query whose hydration is started but does not
-     * finish is still one of them.
-     */
-    abandonedQueries(): ReadonlyMap<string, AbandonedQuery>;
-    /**
-     * Stats from the hydration of the pipeline for `queryID`, or `undefined` if
-     * the query has no pipeline.
-     */
-    hydrationStats(queryID: string): HydrationStats | undefined;
-    totalHydrationTimeMs(): number;
-    /**
-     * The rows the sources hold in memory for the advancement in progress.
-     * The advancement's reservation from the {@link DeferredWritesBudget}
-     * bounds this.
-     */
-    get pendingRows(): number;
-    /**
-     * The estimated bytes of {@link pendingRows}, which are added to the
-     * {@link DeferredWritesBudget}'s held bytes as the advancement goes.
-     */
-    get pendingBytes(): number;
-    /**
-     * Adds a pipeline for the query. The method will hydrate the query using the
-     * driver's current snapshot of the database and return a stream of results.
-     * Henceforth, updates to the query will be returned when the driver is
-     * {@link advance}d. The query and its pipeline can be removed with
-     * {@link removeQuery()}.
-     *
-     * If a query with the same queryID is already added, the existing pipeline
-     * will be removed and destroyed before adding the new pipeline.
-     *
-     * @param timer The caller-controlled {@link Timer} used to determine the
-     *        final hydration time. (The caller may pause and resume the timer
-     *        when yielding the thread for time-slicing).
-     * @return The rows from the initial hydration of the query.
-     */
-    addQuery(transformationHash: string, queryID: string, query: AST, timer: Timer, queryName?: string, hydrationReason?: PipelineHydrationReason): Iterable<RowChange | 'yield'>;
-    /**
-     * Removes the pipeline for the query. This is a no-op if the query
-     * was not added.
-     */
-    removeQuery(queryID: string, stopReason?: PipelineStopReason): void;
-    /**
-     * Current XOR signature of the row-set attached to `queryID`, or
-     * `undefined` if no pipeline for the query is currently active.
-     * Maintained incrementally by {@link addQuery} and {@link advance}.
-     */
-    rowSetSignature(queryID: string): bigint | undefined;
-    /**
-     * IDs of the queries whose {@link rowSetSignature} changed (by an ADD or
-     * REMOVE from {@link addQuery} or {@link advance}) since the last call to
-     * {@link clearChangedRowSetSignatures}.
-     */
-    changedRowSetSignatures(): ReadonlySet<string>;
-    /**
-     * Called once the {@link changedRowSetSignatures} have been persisted.
-     */
-    clearChangedRowSetSignatures(): void;
-    /**
-     * Returns the value of the row with the given primary key `pk`,
-     * or `undefined` if there is no such row. The pipeline must have been
-     * initialized.
-     */
-    getRow(table: string, pk: RowKey): Row | undefined;
-    /**
-     * Advances to the new head of the database.
-     *
-     * @param timer The caller-controlled {@link Timer} that will be used to
-     *        measure the progress of the advancement and abort with a
-     *        {@link ResetPipelinesSignal} if it is estimated to take longer
-     *        than a hydration.
-     * @param costBased If given, the advancement is bounded query by query
-     *        instead (see {@link CostBasedAdvance}).
-     * @return The resulting row changes for all added queries. Note that the
-     *         `changes` must be iterated over in their entirety in order to
-     *         advance the database snapshot.
-     * @throws A {@link ResetPipelinesSignal} if `costBased` is given and the
-     *         changes include a schema change, a truncation or a change of
-     *         the permissions. It is thrown before any change is pushed or
-     *         any pipeline is removed, as the caller resets the pipelines
-     *         either way. Without `costBased`, it is iterating over the
-     *         `changes` that throws it, on getting to that change.
-     */
-    advance(timer: Timer, costBased?: CostBasedAdvance): {
-        version: string;
-        numChanges: number;
-        changes: Iterable<RowChange | 'yield'>;
-        /** Available throughout iteration and after completion or an abort. */
-        progress: () => AdvancementProgress;
-        /**
-         * The queries whose pipelines the {@link CostBasedAdvance} has removed
-         * so far. They can be hydrated again once `changes` has been iterated
-         * over.
-         */
-        abandoned: () => readonly AbandonedQuery[];
-        /**
-         * How the estimates of the {@link CostBasedAdvance} compared with the
-         * actual push times, for the queries that had an estimate and were
-         * pushed all of the changes. Available once `changes` has been iterated
-         * over.
-         */
-        estimates: () => readonly PushEstimate[];
-    };
-}
-/**
- * Core hydration logic used by {@link PipelineDriver#addQuery}, extracted to a
- * function for reuse by the analyze-query RPC path so that analysis hydrates
- * queries the same way the view-syncer does in production. As there, the rows
- * of a table outside `clientSchema` are keyed by its key in the replica.
- */
-export declare function hydrate(input: Input, hash: string, clientSchema: ClientSchema, tableSpecs: Map<string, LiteAndZqlSpec>): Iterable<RowChange | 'yield'>;
-/**
- * Returns the value of `childField` in the row of `input`, the pipeline of a
- * scalar subquery: `null` if the field is `NULL`, or `undefined` if there is
- * no row. Used by {@link PipelineDriver#addQuery} and the analyze-query RPC
- * path to resolve scalar subqueries the same way.
- */
-export declare function fetchScalarValue(input: Input, childField: string): LiteralValue | null | undefined;
-export {};
-//# sourceMappingURL=pipeline-driver.d.ts.map

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

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

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

@@ -1,7 +0,0 @@
-import type { PlanWarning } from '../../../../zql/src/planner/planner-warnings.ts';
-/**
- * Explains a {@link PlanWarning} for a zero-cache operator, in terms of the
- * SQLite replica, whose indexes come from the upstream database.
- */
-export declare function planWarningMessage(warning: PlanWarning): string;
-//# sourceMappingURL=plan-warnings.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"plan-warnings.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/plan-warnings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,iDAAiD,CAAC;AAEjF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CA+B/D"}

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

@@ -1,132 +0,0 @@
-/**
- * Learns what it costs to push a change of each table through each query of
- * a client group, and estimates from it what pushing a batch of changes
- * would cost.
- *
- * The estimates only decide whether a query skips pushing and starts an
- * advancement on rebuild (see {@link shouldStartOnRebuild}). Nothing depends
- * on their accuracy: a query that starts on push when it should not have is
- * cut off (see `PushCutoff`), and one that starts on rebuild costs its
- * hydration time, as it would have at the cutoff.
- */
-export declare class PushCostEstimator {
-    #private;
-    /**
-     * Records what an advancement cost a query.
-     *
-     * @param tables The tables the query reads.
-     * @param timeMsByTable The time spent pushing the changes of each table
-     *        to the query. Absent for a table whose changes cost it nothing,
-     *        e.g. because the rows did not match its filters.
-     * @param changesByTable The entries of each table that the advancement
-     *        read from the change log, whether or not they reached the query,
-     *        or changed anything at all (a row that is inserted and deleted
-     *        between two snapshots is an entry that changes nothing). These
-     *        are the entries that {@link estimate} is given the count of.
-     */
-    record(queryID: string, tables: Iterable<string>, timeMsByTable: ReadonlyMap<string, number> | undefined, changesByTable: ReadonlyMap<string, number>): void;
-    /**
-     * The estimated time to push `changes` to the query, or `undefined` if it
-     * has never been pushed any change. A table that the query has never been
-     * pushed a change of is estimated to cost nothing.
-     *
-     * @param tables The tables the query reads.
-     * @param changes The number of changes to push, by table.
-     */
-    estimate(queryID: string, tables: Iterable<string>, changes: ReadonlyMap<string, number>): number | undefined;
-    /** Forgets what was learned about a query. */
-    forget(queryID: string): void;
-}
-/**
- * Learns what it costs a client group to read a batch of changes, apart from
- * pushing them through its queries, and estimates from it what reading the
- * next one would cost.
- *
- * Reading has three parts, which do not cost the same entries (see
- * {@link ReadParts}): walking the change log, parsing the entries that
- * the walk returns, and looking up the rows of the entries of the tables
- * that are read. What each costs is learned per entry that it was done for.
- * A cost learned per entry of some other count is only right for a batch
- * with the same mix of entries: charged to the entries that are pushed, for
- * instance, the parsing of a batch that is mostly of tables that no query
- * reads makes the next batch that is not look many times as expensive as it
- * is.
- *
- * No query can be cut off for what this costs, as it is not a cost of any
- * one query. It is what pushing costs all of them together, on top of what
- * it costs each (see {@link shouldRebuildInsteadOfReading}).
- */
-export declare class ReadCostEstimator {
-    #private;
-    /**
-     * Records what reading a batch cost. Only for a batch that was read to
-     * its end.
-     *
-     * @param timeMs The time spent on each part of reading the batch.
-     * @param entries The entries that each part was done for.
-     */
-    record(timeMs: ReadParts, entries: ReadParts): void;
-    /**
-     * The estimated time to read a batch, or `undefined` if none has been
-     * read yet.
-     *
-     * @param entries The entries that each part of reading the batch would be
-     *        done for.
-     */
-    estimate(entries: ReadParts): number | undefined;
-}
-/**
- * A number for each part of reading a batch of changes: the entries of the
- * change log that the part is done for, or the time that it takes.
- */
-export type ReadParts = {
-    /**
-     * Walking the change log, which is done for every entry since the
-     * previous snapshot, whether or not the entry is of a table that is read:
-     * the entries are in the order they were committed in, not grouped by
-     * table.
-     */
-    readonly walk: number;
-    /**
-     * Parsing, which is done for every entry that the walk returns. That is
-     * all of them, unless the walk is told which tables are read.
-     */
-    readonly parse: number;
-    /**
-     * Looking up the row in both snapshots, which is done for every entry of
-     * a table that is read. This includes the entries that then turn out to
-     * change nothing (e.g. a row inserted and deleted since the previous
-     * snapshot).
-     */
-    readonly lookup: number;
-};
-/**
- * Whether the queries that are left to push a batch to should all be
- * hydrated again instead, without the batch being read: when reading it and
- * pushing it to them is estimated to cost at least `margin` times what
- * hydrating them does.
- *
- * This is {@link shouldStartOnRebuild} for the queries together, with what
- * reading the batch costs added to what pushing it costs each of them. A
- * query that few of the batch's changes reach is cheap to push to, but the
- * whole batch still has to be walked to find those changes.
- *
- * @param estimatedReadMs `undefined` if there is no estimate, in which case
- *        the batch is read.
- * @param queries What pushing the batch is estimated to cost each query
- *        (nothing, if it has no estimate), and what hydrating it took.
- */
-export declare function shouldRebuildInsteadOfReading(estimatedReadMs: number | undefined, queries: Iterable<{
-    readonly estimatedPushMs: number | undefined;
-    readonly hydrationTimeMs: number;
-}>, margin: number): boolean;
-/**
- * Whether a query should start an advancement on rebuild, i.e. be hydrated
- * again without being pushed any of the advancement's changes: when pushing
- * them is estimated to cost at least `margin` times what hydrating it does.
- *
- * The margin is for the imprecision of the estimate. A query without one
- * starts on push.
- */
-export declare function shouldStartOnRebuild(estimatedPushMs: number | undefined, hydrationTimeMs: number, margin: number): boolean;
-//# sourceMappingURL=push-cost.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"push-cost.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/push-cost.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;GAUG;AACH,qBAAa,iBAAiB;;IAI5B;;;;;;;;;;;;OAYG;IACH,MAAM,CACJ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxB,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACtD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1C,IAAI,CAmBN;IAED;;;;;;;OAOG;IACH,QAAQ,CACN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,GAAG,SAAS,CAUpB;IAED,8CAA8C;IAC9C,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5B;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,iBAAiB;;IAK5B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI,CAgBlD;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAS/C;CACF;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAgBF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,OAAO,EAAE,QAAQ,CAAC;IAChB,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC,CAAC,EACF,MAAM,EAAE,MAAM,GACb,OAAO,CAWT;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GACb,OAAO,CAKT"}