@rocicorp/zero 1.10.0-canary.24 → 1.10.0-canary.26

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;gBAKtB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAwC,EAChD,GAAG,GAAE,cAAkD;IAYzD,gDAAgD;IAChD,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;;;OAMG;IACH,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI;IAUtC,0DAA0D;IAC1D,MAAM,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO;CAW5C"}

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

@@ -1,78 +0,0 @@
-import { assert } from "../../../../shared/src/asserts.js";
-//#region ../zero-cache/src/services/view-syncer/hydration-circuit-breaker.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.
-*/
-var DEFAULT_CIRCUIT_BREAKER_OPEN_MS = 5 * 6e4;
-/**
-* 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.
-*/
-var HydrationCircuitBreaker = class {
-	timeoutMs;
-	openMs;
-	#now;
-	#openedAt = /* @__PURE__ */ new Map();
-	constructor(timeoutMs, openMs = DEFAULT_CIRCUIT_BREAKER_OPEN_MS, now = performance.now.bind(performance)) {
-		assert(Number.isSafeInteger(timeoutMs) && timeoutMs >= 0, "Hydration timeout must be a nonnegative integer");
-		assert(openMs >= 0, "Circuit breaker open duration must be nonnegative");
-		this.timeoutMs = timeoutMs;
-		this.openMs = openMs;
-		this.#now = now;
-	}
-	/** Whether the breaker does anything at all. */
-	get enabled() {
-		return this.timeoutMs > 0;
-	}
-	/**
-	* Whether a hydration that has consumed `elapsedMs` of processing time must
-	* be aborted. Always false when the breaker is disabled.
-	*/
-	exceeded(elapsedMs) {
-		return this.enabled && elapsedMs >= this.timeoutMs;
-	}
-	/**
-	* 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) {
-		const now = this.#now();
-		for (const [hash, openedAt] of this.#openedAt) if (now - openedAt >= this.openMs) this.#openedAt.delete(hash);
-		this.#openedAt.set(transformationHash, now);
-	}
-	/** Whether `transformationHash` is currently rejected. */
-	isOpen(transformationHash) {
-		const openedAt = this.#openedAt.get(transformationHash);
-		if (openedAt === void 0) return false;
-		if (this.#now() - openedAt >= this.openMs) {
-			this.#openedAt.delete(transformationHash);
-			return false;
-		}
-		return true;
-	}
-};
-//#endregion
-export { HydrationCircuitBreaker };
-
-//# sourceMappingURL=hydration-circuit-breaker.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hydration-circuit-breaker.js","names":["#now","#openedAt"],"sources":["../../../../../../zero-cache/src/services/view-syncer/hydration-circuit-breaker.ts"],"sourcesContent":["import {assert} from '../../../../shared/src/asserts.ts';\nimport type {MonotonicClock} from './hydration-budget.ts';\n\n/**\n * How long a tripped query stays rejected before a retry is allowed.\n *\n * A query that blows the timeout is almost always slow because of the shape\n * of its data rather than because of transient load, so retrying it on every\n * reconnect would burn a full timeout each time. The cooldown keeps that cost\n * to at most one timeout per cooldown period per query.\n */\nexport const DEFAULT_CIRCUIT_BREAKER_OPEN_MS = 5 * 60_000;\n\n/**\n * A per-query circuit breaker for view-syncer hydration.\n *\n * Hydration of a single query is aborted once its processing time exceeds\n * {@link timeoutMs}. Callers check {@link exceeded} at the yield points of a\n * hydration, so a query is only ever aborted between time slices.\n *\n * Once a query has been aborted the breaker is \"open\" for its transformation\n * hash: {@link isOpen} reports true for {@link openMs}, and callers reject the\n * query up front instead of hydrating it again. After that the breaker is\n * implicitly half-open: the next hydration attempt runs, and either succeeds\n * or trips the breaker again.\n *\n * The breaker is keyed by transformation hash rather than query hash because\n * the transformation (permissions, auth context) determines the pipeline that\n * runs, and a different transformation of the same query may well be fast.\n */\nexport class HydrationCircuitBreaker {\n  readonly timeoutMs: number;\n  readonly openMs: number;\n  readonly #now: MonotonicClock;\n  readonly #openedAt = new Map<string, number>();\n\n  constructor(\n    timeoutMs: number,\n    openMs: number = DEFAULT_CIRCUIT_BREAKER_OPEN_MS,\n    now: MonotonicClock = performance.now.bind(performance),\n  ) {\n    assert(\n      Number.isSafeInteger(timeoutMs) && timeoutMs >= 0,\n      'Hydration timeout must be a nonnegative integer',\n    );\n    assert(openMs >= 0, 'Circuit breaker open duration must be nonnegative');\n    this.timeoutMs = timeoutMs;\n    this.openMs = openMs;\n    this.#now = now;\n  }\n\n  /** Whether the breaker does anything at all. */\n  get enabled(): boolean {\n    return this.timeoutMs > 0;\n  }\n\n  /**\n   * Whether a hydration that has consumed `elapsedMs` of processing time must\n   * be aborted. Always false when the breaker is disabled.\n   */\n  exceeded(elapsedMs: number): boolean {\n    return this.enabled && elapsedMs >= this.timeoutMs;\n  }\n\n  /**\n   * Records that hydrating `transformationHash` was aborted.\n   *\n   * Trips are rare, so this is also when expired entries are swept, which\n   * keeps the map bounded by the number of hashes tripped within one cooldown\n   * rather than by every hash ever tripped.\n   */\n  trip(transformationHash: string): void {\n    const now = this.#now();\n    for (const [hash, openedAt] of this.#openedAt) {\n      if (now - openedAt >= this.openMs) {\n        this.#openedAt.delete(hash);\n      }\n    }\n    this.#openedAt.set(transformationHash, now);\n  }\n\n  /** Whether `transformationHash` is currently rejected. */\n  isOpen(transformationHash: string): boolean {\n    const openedAt = this.#openedAt.get(transformationHash);\n    if (openedAt === undefined) {\n      return false;\n    }\n    if (this.#now() - openedAt >= this.openMs) {\n      this.#openedAt.delete(transformationHash);\n      return false;\n    }\n    return true;\n  }\n}\n"],"mappings":";;;;;;;;;;AAWA,IAAa,kCAAkC,IAAI;;;;;;;;;;;;;;;;;;AAmBnD,IAAa,0BAAb,MAAqC;CACnC;CACA;CACA;CACA,4BAAqB,IAAI,IAAoB;CAE7C,YACE,WACA,SAAiB,iCACjB,MAAsB,YAAY,IAAI,KAAK,WAAW,GACtD;EACA,OACE,OAAO,cAAc,SAAS,KAAK,aAAa,GAChD,iDACF;EACA,OAAO,UAAU,GAAG,mDAAmD;EACvE,KAAK,YAAY;EACjB,KAAK,SAAS;EACd,KAAKA,OAAO;CACd;;CAGA,IAAI,UAAmB;EACrB,OAAO,KAAK,YAAY;CAC1B;;;;;CAMA,SAAS,WAA4B;EACnC,OAAO,KAAK,WAAW,aAAa,KAAK;CAC3C;;;;;;;;CASA,KAAK,oBAAkC;EACrC,MAAM,MAAM,KAAKA,KAAK;EACtB,KAAK,MAAM,CAAC,MAAM,aAAa,KAAKC,WAClC,IAAI,MAAM,YAAY,KAAK,QACzB,KAAKA,UAAU,OAAO,IAAI;EAG9B,KAAKA,UAAU,IAAI,oBAAoB,GAAG;CAC5C;;CAGA,OAAO,oBAAqC;EAC1C,MAAM,WAAW,KAAKA,UAAU,IAAI,kBAAkB;EACtD,IAAI,aAAa,KAAA,GACf,OAAO;EAET,IAAI,KAAKD,KAAK,IAAI,YAAY,KAAK,QAAQ;GACzC,KAAKC,UAAU,OAAO,kBAAkB;GACxC,OAAO;EACT;EACA,OAAO;CACT;AACF"}

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

@@ -1,95 +0,0 @@
-/**
- * The default maximum number of entries retained by a {@link SnapshotRowCache}.
- *
- * Each entry is a raw SQLite row (or the list of rows conflicting with
- * a row on its unique keys) read while computing a snapshot diff. A
- * replicated transaction of N rows produces up to 2N entries (the new value
- * and the previous value(s) of each row), so the cache should be large enough
- * to hold the largest transactions that are commonly replicated in order for
- * all of the client groups on a worker to share the reads.
- */
-export declare const DEFAULT_MAX_SNAPSHOT_ROW_CACHE_ENTRIES = 50000;
-/**
- * How a statement's results are read: a single row (`Statement.get()`) or
- * all rows (`Statement.all()`).
- */
-export type ReadMode = 'get' | 'all';
-/**
- * The maximum number of distinct SQL statements interned by a
- * {@link SnapshotRowCache} before it is cleared. There is one per table and
- * lookup shape, so this is only reached after many schema changes.
- */
-export declare const MAX_INTERNED_STATEMENTS = 10000;
-/**
- * A worker-wide, bounded cache of the rows that a `Snapshotter` reads from
- * replica snapshots when computing the diff between two versions of the
- * replica.
- *
- * Every client group (i.e. view-syncer) on a sync worker computes its own
- * diff from the shared `_zero.changeLog2`, and each change in the diff costs
- * two SQLite reads: the new value of the row (from the `curr` snapshot) and
- * the previous value(s) that it replaces (from the `prev` snapshot). The
- * reads for a given change are identical for every client group that
- * traverses it, so a replicated transaction of N rows costs N × 2 × (client
- * groups) reads per worker, most of which are redundant. This cache lets the
- * client groups on a worker share those reads.
- *
- * ### Keys
- *
- * Entries are keyed by the exact SQL statement and arguments of the read
- * (which encodes the table, the selected columns and the lookup keys), plus
- * a `tag` supplied by the caller that pins the result to a version of the
- * replica:
- *
- * - The new value of a row is the row as of the `stateVersion` recorded in
- *   its change log entry (its `_0_version` is asserted to equal that
- *   version), and is tagged with that `stateVersion`. It is thus shareable
- *   by all client groups regardless of the snapshots they are advancing
- *   between.
- * - Previous values are read from the `prev` snapshot at its version, and
- *   are tagged with that version (and, when the result can depend on the
- *   changes applied to the snapshot before the read, the `curr` version
- *   as well). See `Diff` in `snapshotter.ts` for the details.
- *
- * Because every key includes the version(s) that the result depends on,
- * entries never go stale and are never invalidated; they are only evicted.
- *
- * ### Eviction
- *
- * The cache is bounded by entry count and evicts in insertion (FIFO) order
- * rather than by recency. Diffs are traversed in change log order by every
- * client group, so the entries that will not be needed again are those that
- * were inserted the earliest (all groups have moved past them), while the
- * most recently inserted entries are the ones that the trailing groups have
- * yet to reach. Refreshing an entry on a hit would evict exactly the wrong
- * entries when a trailing group catches up.
- *
- * ### Sharing
- *
- * Cached values are shared by reference across client groups and must
- * therefore never be mutated by callers.
- */
-export declare class SnapshotRowCache {
-    #private;
-    constructor(maxEntries?: number);
-    get size(): number;
-    get maxEntries(): number;
-    stats(): {
-        hits: number;
-        misses: number;
-        size: number;
-    };
-    /**
-     * Returns the cached result of the read identified by `tag`, `sql`, `mode`
-     * and `args`, or performs the read via `read()`, caching and returning its
-     * result. `undefined` results (i.e. a missing row) are not cached.
-     *
-     * `mode` is part of the key because the same statement can be read both
-     * ways: for a table whose only unique key is its primary key, `getRow()`
-     * and `getRows()` produce identical SQL, args and tags, but the former
-     * caches a row and the latter an array of rows.
-     */
-    getOrRead<T>(tag: string, sql: string, mode: ReadMode, args: unknown[], read: () => T): T;
-    clear(): void;
-}
-//# sourceMappingURL=snapshot-row-cache.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-row-cache.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/snapshot-row-cache.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,eAAO,MAAM,sCAAsC,QAAS,CAAC;AAwB7D;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;AAErC;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAK9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,gBAAgB;;gBAmBf,UAAU,SAAyC;IAI/D,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,KAAK,IAAI;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAIrD;;;;;;;;;OASG;IACH,SAAS,CAAC,CAAC,EACT,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,OAAO,EAAE,EACf,IAAI,EAAE,MAAM,CAAC,GACZ,CAAC;IAsBJ,KAAK,IAAI,IAAI;CA0Bd"}

package/out/zero-cache/src/services/view-syncer/snapshot-row-cache.js

@@ -1,155 +0,0 @@
-import { getOrInsert } from "../../../../shared/src/map.js";
-import { must } from "../../../../shared/src/must.js";
-import { stringify } from "../../../../shared/src/bigint-json.js";
-import { getOrCreateCounter } from "../../observability/metrics.js";
-import { RingBuffer } from "../../../../shared/src/ring-buffer.js";
-//#region ../zero-cache/src/services/view-syncer/snapshot-row-cache.ts
-/**
-* The default maximum number of entries retained by a {@link SnapshotRowCache}.
-*
-* Each entry is a raw SQLite row (or the list of rows conflicting with
-* a row on its unique keys) read while computing a snapshot diff. A
-* replicated transaction of N rows produces up to 2N entries (the new value
-* and the previous value(s) of each row), so the cache should be large enough
-* to hold the largest transactions that are commonly replicated in order for
-* all of the client groups on a worker to share the reads.
-*/
-var DEFAULT_MAX_SNAPSHOT_ROW_CACHE_ENTRIES = 5e4;
-/**
-* Serializes a lookup key value (i.e. a SQLite-bound parameter). Numbers and
-* bigints serialize identically, as row keys parsed from the change log are
-* JSON numbers whereas the values read from SQLite are bigints; both address
-* the same row. Strings are prefixed to distinguish them from numbers.
-*/
-function serialize(v) {
-	switch (typeof v) {
-		case "string": return "s" + v;
-		case "number":
-		case "bigint": return String(v);
-		case "boolean": return v ? "true" : "false";
-		case "object": return v === null ? "null" : "o" + stringify(v);
-		default: return "u" + String(v);
-	}
-}
-var HIT = { result: "hit" };
-var MISS = { result: "miss" };
-/**
-* A worker-wide, bounded cache of the rows that a `Snapshotter` reads from
-* replica snapshots when computing the diff between two versions of the
-* replica.
-*
-* Every client group (i.e. view-syncer) on a sync worker computes its own
-* diff from the shared `_zero.changeLog2`, and each change in the diff costs
-* two SQLite reads: the new value of the row (from the `curr` snapshot) and
-* the previous value(s) that it replaces (from the `prev` snapshot). The
-* reads for a given change are identical for every client group that
-* traverses it, so a replicated transaction of N rows costs N × 2 × (client
-* groups) reads per worker, most of which are redundant. This cache lets the
-* client groups on a worker share those reads.
-*
-* ### Keys
-*
-* Entries are keyed by the exact SQL statement and arguments of the read
-* (which encodes the table, the selected columns and the lookup keys), plus
-* a `tag` supplied by the caller that pins the result to a version of the
-* replica:
-*
-* - The new value of a row is the row as of the `stateVersion` recorded in
-*   its change log entry (its `_0_version` is asserted to equal that
-*   version), and is tagged with that `stateVersion`. It is thus shareable
-*   by all client groups regardless of the snapshots they are advancing
-*   between.
-* - Previous values are read from the `prev` snapshot at its version, and
-*   are tagged with that version (and, when the result can depend on the
-*   changes applied to the snapshot before the read, the `curr` version
-*   as well). See `Diff` in `snapshotter.ts` for the details.
-*
-* Because every key includes the version(s) that the result depends on,
-* entries never go stale and are never invalidated; they are only evicted.
-*
-* ### Eviction
-*
-* The cache is bounded by entry count and evicts in insertion (FIFO) order
-* rather than by recency. Diffs are traversed in change log order by every
-* client group, so the entries that will not be needed again are those that
-* were inserted the earliest (all groups have moved past them), while the
-* most recently inserted entries are the ones that the trailing groups have
-* yet to reach. Refreshing an entry on a hit would evict exactly the wrong
-* entries when a trailing group catches up.
-*
-* ### Sharing
-*
-* Cached values are shared by reference across client groups and must
-* therefore never be mutated by callers.
-*/
-var SnapshotRowCache = class {
-	#maxEntries;
-	#entries = /* @__PURE__ */ new Map();
-	#keys = new RingBuffer();
-	#sqlIDs = /* @__PURE__ */ new Map();
-	#reads = getOrCreateCounter("sync", "ivm.snapshot-row-reads", "Row reads performed while computing snapshot diffs for IVM, labeled by whether the read was served by the worker-wide snapshot row cache.");
-	#hits = 0;
-	#misses = 0;
-	constructor(maxEntries = DEFAULT_MAX_SNAPSHOT_ROW_CACHE_ENTRIES) {
-		this.#maxEntries = Math.max(0, maxEntries);
-	}
-	get size() {
-		return this.#entries.size;
-	}
-	get maxEntries() {
-		return this.#maxEntries;
-	}
-	stats() {
-		return {
-			hits: this.#hits,
-			misses: this.#misses,
-			size: this.#entries.size
-		};
-	}
-	/**
-	* Returns the cached result of the read identified by `tag`, `sql`, `mode`
-	* and `args`, or performs the read via `read()`, caching and returning its
-	* result. `undefined` results (i.e. a missing row) are not cached.
-	*
-	* `mode` is part of the key because the same statement can be read both
-	* ways: for a table whose only unique key is its primary key, `getRow()`
-	* and `getRows()` produce identical SQL, args and tags, but the former
-	* caches a row and the latter an array of rows.
-	*/
-	getOrRead(tag, sql, mode, args, read) {
-		const key = this.#key(tag, sql, mode, args);
-		const cached = this.#entries.get(key);
-		if (cached !== void 0) {
-			this.#hits++;
-			this.#reads.add(1, HIT);
-			return cached;
-		}
-		this.#misses++;
-		this.#reads.add(1, MISS);
-		const value = read();
-		if (value !== void 0 && this.#maxEntries > 0) {
-			this.#entries.set(key, value);
-			this.#keys.push(key);
-			if (this.#keys.size > this.#maxEntries) this.#entries.delete(must(this.#keys.shift()));
-		}
-		return value;
-	}
-	clear() {
-		this.#entries.clear();
-		this.#keys.clear();
-		this.#sqlIDs.clear();
-	}
-	#key(tag, sql, mode, args) {
-		if (this.#sqlIDs.size >= 1e4 && !this.#sqlIDs.has(sql)) this.clear();
-		let key = `${tag}\0${mode}${getOrInsert(this.#sqlIDs, sql, this.#sqlIDs.size)}`;
-		for (const arg of args) {
-			const serialized = serialize(arg);
-			key += `\0${serialized.length}:${serialized}`;
-		}
-		return key;
-	}
-};
-//#endregion
-export { SnapshotRowCache };
-
-//# sourceMappingURL=snapshot-row-cache.js.map

package/out/zero-cache/src/services/view-syncer/snapshot-row-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snapshot-row-cache.js","names":["#maxEntries","#entries","#keys","#sqlIDs","#reads","#hits","#misses","#key"],"sources":["../../../../../../zero-cache/src/services/view-syncer/snapshot-row-cache.ts"],"sourcesContent":["import {stringify} from '../../../../shared/src/bigint-json.ts';\nimport {getOrInsert} from '../../../../shared/src/map.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport {RingBuffer} from '../../../../shared/src/ring-buffer.ts';\nimport {getOrCreateCounter} from '../../observability/metrics.ts';\n\n/**\n * The default maximum number of entries retained by a {@link SnapshotRowCache}.\n *\n * Each entry is a raw SQLite row (or the list of rows conflicting with\n * a row on its unique keys) read while computing a snapshot diff. A\n * replicated transaction of N rows produces up to 2N entries (the new value\n * and the previous value(s) of each row), so the cache should be large enough\n * to hold the largest transactions that are commonly replicated in order for\n * all of the client groups on a worker to share the reads.\n */\nexport const DEFAULT_MAX_SNAPSHOT_ROW_CACHE_ENTRIES = 50_000;\n\n/**\n * Serializes a lookup key value (i.e. a SQLite-bound parameter). Numbers and\n * bigints serialize identically, as row keys parsed from the change log are\n * JSON numbers whereas the values read from SQLite are bigints; both address\n * the same row. Strings are prefixed to distinguish them from numbers.\n */\nfunction serialize(v: unknown): string {\n  switch (typeof v) {\n    case 'string':\n      return 's' + v;\n    case 'number':\n    case 'bigint':\n      return String(v);\n    case 'boolean':\n      return v ? 'true' : 'false';\n    case 'object':\n      return v === null ? 'null' : 'o' + stringify(v);\n    default:\n      return 'u' + String(v);\n  }\n}\n\n/**\n * How a statement's results are read: a single row (`Statement.get()`) or\n * all rows (`Statement.all()`).\n */\nexport type ReadMode = 'get' | 'all';\n\n/**\n * The maximum number of distinct SQL statements interned by a\n * {@link SnapshotRowCache} before it is cleared. There is one per table and\n * lookup shape, so this is only reached after many schema changes.\n */\nexport const MAX_INTERNED_STATEMENTS = 10_000;\n\nconst HIT = {result: 'hit'} as const;\nconst MISS = {result: 'miss'} as const;\n\n/**\n * A worker-wide, bounded cache of the rows that a `Snapshotter` reads from\n * replica snapshots when computing the diff between two versions of the\n * replica.\n *\n * Every client group (i.e. view-syncer) on a sync worker computes its own\n * diff from the shared `_zero.changeLog2`, and each change in the diff costs\n * two SQLite reads: the new value of the row (from the `curr` snapshot) and\n * the previous value(s) that it replaces (from the `prev` snapshot). The\n * reads for a given change are identical for every client group that\n * traverses it, so a replicated transaction of N rows costs N × 2 × (client\n * groups) reads per worker, most of which are redundant. This cache lets the\n * client groups on a worker share those reads.\n *\n * ### Keys\n *\n * Entries are keyed by the exact SQL statement and arguments of the read\n * (which encodes the table, the selected columns and the lookup keys), plus\n * a `tag` supplied by the caller that pins the result to a version of the\n * replica:\n *\n * - The new value of a row is the row as of the `stateVersion` recorded in\n *   its change log entry (its `_0_version` is asserted to equal that\n *   version), and is tagged with that `stateVersion`. It is thus shareable\n *   by all client groups regardless of the snapshots they are advancing\n *   between.\n * - Previous values are read from the `prev` snapshot at its version, and\n *   are tagged with that version (and, when the result can depend on the\n *   changes applied to the snapshot before the read, the `curr` version\n *   as well). See `Diff` in `snapshotter.ts` for the details.\n *\n * Because every key includes the version(s) that the result depends on,\n * entries never go stale and are never invalidated; they are only evicted.\n *\n * ### Eviction\n *\n * The cache is bounded by entry count and evicts in insertion (FIFO) order\n * rather than by recency. Diffs are traversed in change log order by every\n * client group, so the entries that will not be needed again are those that\n * were inserted the earliest (all groups have moved past them), while the\n * most recently inserted entries are the ones that the trailing groups have\n * yet to reach. Refreshing an entry on a hit would evict exactly the wrong\n * entries when a trailing group catches up.\n *\n * ### Sharing\n *\n * Cached values are shared by reference across client groups and must\n * therefore never be mutated by callers.\n */\nexport class SnapshotRowCache {\n  readonly #maxEntries: number;\n  readonly #entries = new Map<string, unknown>();\n  // The keys of #entries in insertion order, so that the oldest can be\n  // evicted in O(1). (Finding the oldest key with a fresh Map iterator\n  // instead costs O(evictions) per insert, as V8 leaves deleted entries in\n  // the table until it is compacted and every new iterator walks over them.)\n  readonly #keys = new RingBuffer<string>();\n  // Interns the SQL text of each distinct read so that entry keys\n  // do not repeat the (long) column list of every statement.\n  readonly #sqlIDs = new Map<string, number>();\n  readonly #reads = getOrCreateCounter(\n    'sync',\n    'ivm.snapshot-row-reads',\n    'Row reads performed while computing snapshot diffs for IVM, labeled by whether the read was served by the worker-wide snapshot row cache.',\n  );\n  #hits = 0;\n  #misses = 0;\n\n  constructor(maxEntries = DEFAULT_MAX_SNAPSHOT_ROW_CACHE_ENTRIES) {\n    this.#maxEntries = Math.max(0, maxEntries);\n  }\n\n  get size(): number {\n    return this.#entries.size;\n  }\n\n  get maxEntries(): number {\n    return this.#maxEntries;\n  }\n\n  stats(): {hits: number; misses: number; size: number} {\n    return {hits: this.#hits, misses: this.#misses, size: this.#entries.size};\n  }\n\n  /**\n   * Returns the cached result of the read identified by `tag`, `sql`, `mode`\n   * and `args`, or performs the read via `read()`, caching and returning its\n   * result. `undefined` results (i.e. a missing row) are not cached.\n   *\n   * `mode` is part of the key because the same statement can be read both\n   * ways: for a table whose only unique key is its primary key, `getRow()`\n   * and `getRows()` produce identical SQL, args and tags, but the former\n   * caches a row and the latter an array of rows.\n   */\n  getOrRead<T>(\n    tag: string,\n    sql: string,\n    mode: ReadMode,\n    args: unknown[],\n    read: () => T,\n  ): T {\n    const key = this.#key(tag, sql, mode, args);\n    const cached = this.#entries.get(key);\n    if (cached !== undefined) {\n      this.#hits++;\n      this.#reads.add(1, HIT);\n      return cached as T;\n    }\n    this.#misses++;\n    this.#reads.add(1, MISS);\n    const value = read();\n    if (value !== undefined && this.#maxEntries > 0) {\n      // `key` is not in #entries (this is a miss), so it is always added.\n      this.#entries.set(key, value);\n      this.#keys.push(key);\n      if (this.#keys.size > this.#maxEntries) {\n        this.#entries.delete(must(this.#keys.shift()));\n      }\n    }\n    return value;\n  }\n\n  clear(): void {\n    this.#entries.clear();\n    this.#keys.clear();\n    this.#sqlIDs.clear();\n  }\n\n  #key(tag: string, sql: string, mode: ReadMode, args: unknown[]): string {\n    if (\n      this.#sqlIDs.size >= MAX_INTERNED_STATEMENTS &&\n      !this.#sqlIDs.has(sql)\n    ) {\n      // Statements are only added (e.g. when schema changes produce new\n      // column lists), so bound them by starting over. The entries refer to\n      // statements by ID and are cleared with them.\n      this.clear();\n    }\n    const sqlID = getOrInsert(this.#sqlIDs, sql, this.#sqlIDs.size);\n    let key = `${tag}\\0${mode}${sqlID}`;\n    // Include each value's length so separators inside string values cannot\n    // make different argument arrays produce the same key.\n    for (const arg of args) {\n      const serialized = serialize(arg);\n      key += `\\0${serialized.length}:${serialized}`;\n    }\n    return key;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,IAAa,yCAAyC;;;;;;;AAQtD,SAAS,UAAU,GAAoB;CACrC,QAAQ,OAAO,GAAf;EACE,KAAK,UACH,OAAO,MAAM;EACf,KAAK;EACL,KAAK,UACH,OAAO,OAAO,CAAC;EACjB,KAAK,WACH,OAAO,IAAI,SAAS;EACtB,KAAK,UACH,OAAO,MAAM,OAAO,SAAS,MAAM,UAAU,CAAC;EAChD,SACE,OAAO,MAAM,OAAO,CAAC;CACzB;AACF;AAeA,IAAM,MAAM,EAAC,QAAQ,MAAK;AAC1B,IAAM,OAAO,EAAC,QAAQ,OAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmD5B,IAAa,mBAAb,MAA8B;CAC5B;CACA,2BAAoB,IAAI,IAAqB;CAK7C,QAAiB,IAAI,WAAmB;CAGxC,0BAAmB,IAAI,IAAoB;CAC3C,SAAkB,mBAChB,QACA,0BACA,2IACF;CACA,QAAQ;CACR,UAAU;CAEV,YAAY,aAAa,wCAAwC;EAC/D,KAAKA,cAAc,KAAK,IAAI,GAAG,UAAU;CAC3C;CAEA,IAAI,OAAe;EACjB,OAAO,KAAKC,SAAS;CACvB;CAEA,IAAI,aAAqB;EACvB,OAAO,KAAKD;CACd;CAEA,QAAsD;EACpD,OAAO;GAAC,MAAM,KAAKK;GAAO,QAAQ,KAAKC;GAAS,MAAM,KAAKL,SAAS;EAAI;CAC1E;;;;;;;;;;;CAYA,UACE,KACA,KACA,MACA,MACA,MACG;EACH,MAAM,MAAM,KAAKM,KAAK,KAAK,KAAK,MAAM,IAAI;EAC1C,MAAM,SAAS,KAAKN,SAAS,IAAI,GAAG;EACpC,IAAI,WAAW,KAAA,GAAW;GACxB,KAAKI;GACL,KAAKD,OAAO,IAAI,GAAG,GAAG;GACtB,OAAO;EACT;EACA,KAAKE;EACL,KAAKF,OAAO,IAAI,GAAG,IAAI;EACvB,MAAM,QAAQ,KAAK;EACnB,IAAI,UAAU,KAAA,KAAa,KAAKJ,cAAc,GAAG;GAE/C,KAAKC,SAAS,IAAI,KAAK,KAAK;GAC5B,KAAKC,MAAM,KAAK,GAAG;GACnB,IAAI,KAAKA,MAAM,OAAO,KAAKF,aACzB,KAAKC,SAAS,OAAO,KAAK,KAAKC,MAAM,MAAM,CAAC,CAAC;EAEjD;EACA,OAAO;CACT;CAEA,QAAc;EACZ,KAAKD,SAAS,MAAM;EACpB,KAAKC,MAAM,MAAM;EACjB,KAAKC,QAAQ,MAAM;CACrB;CAEA,KAAK,KAAa,KAAa,MAAgB,MAAyB;EACtE,IACE,KAAKA,QAAQ,QAAA,OACb,CAAC,KAAKA,QAAQ,IAAI,GAAG,GAKrB,KAAK,MAAM;EAGb,IAAI,MAAM,GAAG,IAAI,IAAI,OADP,YAAY,KAAKA,SAAS,KAAK,KAAKA,QAAQ,IAC9B;EAG5B,KAAK,MAAM,OAAO,MAAM;GACtB,MAAM,aAAa,UAAU,GAAG;GAChC,OAAO,KAAK,WAAW,OAAO,GAAG;EACnC;EACA,OAAO;CACT;AACF"}

package/out/zero-protocol/src/query-hash-visitor.d.ts

@@ -1,81 +0,0 @@
-import type { Format } from '../../zero-types/src/format.ts';
-/**
- * Hashes a normalized AST by visiting it, rather than by rendering it to JSON
- * and hashing the bytes. `hashOfAST` and `hashOfNameAndArgs` in
- * `query-hash.ts` are both built on this, so these digests are the query IDs
- * the client registers and the transformation hashes the server stores.
- *
- * The pipeline this replaced was
- * `h64(JSON.stringify(normalizeAST(ast))).toString(36)`, which materialized
- * the whole AST as a string, UTF-8 encoded it, and only then hashed it — three
- * passes over the data, two of which existed purely to produce bytes to hash.
- *
- * A visitor can fold values into the hash state as it walks, so nothing is
- * materialized at all. The primitives that make that pay off:
- *
- * - Two 32-bit accumulators held in module-level `let`s, so the "state" is
- *   plain numbers in registers rather than an object being threaded through
- *   the walk.
- * - xxHash32's own round and final mix, shared with `shared/src/hash.ts` via
- *   `shared/src/xxhash32.ts`. Only the ingestion differs: that one feeds them
- *   UTF-8 bytes, this one feeds them words straight out of the structure.
- * - Strings folded straight from `charCodeAt`, two UTF-16 units at a time, into
- *   one 32-bit word. No UTF-8 encoding, and half the loop iterations a
- *   byte-oriented hash would need over ASCII.
- *
- * These digests do not agree with xxHash32 over the old JSON encoding, and are
- * not meant to: nothing recomputes a hash produced elsewhere and compares it,
- * so the encoding is free to change as long as every writer moves together.
- * What it does have to give is distinct words for structurally distinct
- * queries — a 64-bit digest cannot promise that absolutely, but every field
- * and node kind must at least reach the mixer, and no two of them may be
- * written so as to be confusable. `query-hash-visitor.test.ts` holds that
- * line with a corpus and a per-field mutation test.
- *
- * The walk is deliberately specialized to the AST shape rather than written as
- * a generic JSON-value walk. That is not premature: a generic version was
- * measured alongside this one and came out ~2.4x slower, no better than the
- * `JSON.stringify` it was meant to replace, because `for...in` and the
- * megamorphic property loads cost about what the native stringify costs. Only
- * `visitValue` below stays generic, for the two places an AST holds arbitrary
- * JSON: a literal's value and a bound's row.
- */
-import type { AST, System } from './ast.ts';
-export declare function hashAST(ast: AST): string;
-/**
- * The identity of a custom query: its name and its arguments.
- *
- * Same walk, entered at a different node. `args` is arbitrary JSON, which is
- * what `visitValue` already exists to handle. The leading tag keeps this hash
- * space disjoint from `hashAST`'s -- both produce query IDs that live in the
- * same namespace, so an AST must not be able to fold to the same words as some
- * name and args.
- */
-export declare function hashNameAndArgs(name: string, args: readonly unknown[]): string;
-/**
- * The identity of a query as the client sees it: its AST, the shape it returns,
- * the system it was built for, and -- for a custom query -- the name and
- * arguments it was declared with.
- *
- * Everything past the AST is here because it is part of what makes two queries
- * different while leaving no trace, or an incomplete one, in the AST itself:
- *
- * - **name and args**: `nameAndArgs` reuses the AST it is given and only
- *   attaches a `CustomQueryID`, so without these two different named queries
- *   over the same table would be indistinguishable.
- * - **system**: a query stamps it onto every `related` entry and every `exists`
- *   correlation it builds, so it is already hashed via
- *   {@link visitCorrelatedSubquery} -- but a query with neither has nowhere to
- *   put it, and would otherwise hash the same whether it was built for the
- *   client or for permissions.
- * - **currentJunction**: builder state, set on the sub-query handed to a
- *   two-hop relationship's callback, which makes `limit` and `orderBy` throw.
- *   It leaves no trace in the AST at all, so two queries that differ only in
- *   whether those methods work would otherwise be indistinguishable.
- *
- * The name and args are taken apart rather than as a `CustomQueryID` because
- * that type lives in `zql`, which is above this package; `hashNameAndArgs`
- * splits them the same way.
- */
-export declare function hashOfQueryInternals(ast: AST, format: Format, system: System, currentJunction: string | undefined, customQueryName: string | undefined, customQueryArgs: readonly unknown[] | undefined): string;
-//# sourceMappingURL=query-hash-visitor.d.ts.map

package/out/zero-protocol/src/query-hash-visitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query-hash-visitor.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-hash-visitor.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,gCAAgC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EACV,GAAG,EAIH,MAAM,EAEP,MAAM,UAAU,CAAC;AA8UlB,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAcxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB,MAAM,CAaR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GAC9C,MAAM,CA2BR"}