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

package/out/zero-client/src/client/ivm-branch.d.ts

@@ -1,9 +1,14 @@
-import type { NoIndexDiff } from '../../../replicache/src/btree/node.ts';
+import type { InternalDiffOperation, NoIndexDiff } from '../../../replicache/src/btree/node.ts';
 import type { LazyStore } from '../../../replicache/src/dag/lazy-store.ts';
 import { type Store } from '../../../replicache/src/dag/store.ts';
 import type { Hash } from '../../../replicache/src/hash.ts';
 import type { ZeroReadOptions } from '../../../replicache/src/replicache-options.ts';
+import type { AggregateFunction, CompoundKey } from '../../../zero-protocol/src/ast.ts';
+import type { Row } from '../../../zero-protocol/src/data.ts';
+import type { PrimaryKey } from '../../../zero-protocol/src/primary-key.ts';
 import type { TableSchema } from '../../../zero-schema/src/table-schema.ts';
+import { type SchemaValue } from '../../../zero-types/src/schema-value.ts';
+import { type AggregateOptimisticDelta } from '../../../zql/src/builder/builder.ts';
 import { MemorySource } from '../../../zql/src/ivm/memory-source.ts';
 /**
  * Replicache needs to rebase mutations onto different
@@ -21,11 +26,61 @@ import { MemorySource } from '../../../zql/src/ivm/memory-source.ts';
  * ever be a few outstanding diffs to apply given Zero is meant
  * to be run in a connected state.
  */
+/**
+ * Metadata for optimistically updating a synced aggregate when a child row is
+ * locally mutated. Registered when a relationship-aggregate query materializes.
+ */
+export type OptimisticAggregate = {
+    /** The synthetic aggregate table, e.g. `aggregate:<queryID>:<alias>`. */
+    readonly aggTableName: string;
+    /** The correlation columns of a child row, as the client names them. */
+    readonly childField: readonly string[];
+    /**
+     * The same columns as the synced aggregate rows name them (server names), in
+     * the same order. An aggregate row's key is built from these.
+     */
+    readonly keyField: readonly string[];
+    /** The aggregate function (`count`/`sum`/`avg` are optimistically deltaed). */
+    readonly fn: AggregateFunction;
+    /** The aggregated field, for `sum`/`avg` (`undefined` for `count`). */
+    readonly field: string | undefined;
+    /** A JSON path into `field` (see `Aggregate.path`). */
+    readonly path: readonly (string | number)[] | undefined;
+    /**
+     * The aggregate's `where`, compiled to a per-row predicate. A child row
+     * contributes only when it returns true; `undefined` means no filter (every
+     * child contributes). Only set when the whole `where` is per-row evaluable —
+     * a correlated subquery in the `where` makes the aggregate
+     * server-authoritative (it is never registered for optimism at all).
+     */
+    readonly predicate: ((row: Row) => boolean) | undefined;
+    /** The rows are a grouped query's groups (see `AggregateOptimisticDelta`). */
+    readonly grouped: boolean;
+};
 export declare class IVMSourceBranch {
     #private;
     hash: Hash | undefined;
-    constructor(tables: Record<string, TableSchema>, hash?: Hash, sources?: Map<string, MemorySource | undefined>);
+    constructor(tables: Record<string, TableSchema>, hash?: Hash, sources?: Map<string, MemorySource | undefined>, aggregateOptimism?: Map<string, Map<string, OptimisticAggregate>>, isFork?: boolean);
     getSource(name: string): MemorySource | undefined;
+    /**
+     * Get-or-create the synthetic source for a *relationship* aggregate
+     * (`aggregate:<queryID>:<alias>`), whose shape (the correlation-key columns +
+     * value) cannot be derived from the name. The query builder supplies the
+     * schema when a query materializes; {@link applyDiffs} supplies an inferred
+     * one when persisted rows are replayed before the query re-materializes (e.g.
+     * on reload). Idempotent — the first caller wins.
+     */
+    getOrCreateAggregateSource(name: string, columns: Record<string, SchemaValue>, primaryKey: PrimaryKey, optimistic?: AggregateOptimisticDelta): MemorySource;
+    /**
+     * The server names of `columns` of `table`, in the same order. A column with
+     * no server name of its own, or of a table not in the schema, keeps its name.
+     */
+    serverColumnNames(table: string, columns: CompoundKey): CompoundKey;
+    /**
+     * The optimistic-aggregate registrations whose child rows live in `table`.
+     * An optimistic insert/delete of such a child row bumps these aggregates.
+     */
+    getOptimisticAggregates(table: string): Iterable<OptimisticAggregate>;
     clear(): void;
     /**
      * Mutates the current branch, advancing it to the new head
@@ -47,4 +102,9 @@ export declare class IVMSourceBranch {
     fork(): IVMSourceBranch;
 }
 export declare function initFromStore(branch: IVMSourceBranch, hash: Hash, store: Store): Promise<void>;
+/**
+ * An `add` diff for each row at `hash` that the IVM sources hold: the table
+ * rows under `e/` and the aggregate rows under `a/`, in key order.
+ */
+export declare function readRowDiffs(store: Store, hash: Hash): Promise<InternalDiffOperation[]>;
 //# sourceMappingURL=ivm-branch.d.ts.map

package/out/zero-client/src/client/ivm-branch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ivm-branch.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/ivm-branch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,WAAW,EACZ,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,2CAA2C,CAAC;AACzE,OAAO,EAAY,KAAK,KAAK,EAAC,MAAM,sCAAsC,CAAC;AAG3E,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,+CAA+C,CAAC;AASnF,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0CAA0C,CAAC;AAC1E,OAAO,EAAC,YAAY,EAAC,MAAM,uCAAuC,CAAC;AAQnE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAe;;IAI1B,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;IAEvB,YACE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACnC,IAAI,CAAC,EAAE,IAAI,EACX,OAAO,GAAE,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAa,EAK3D;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAahD;IAED,KAAK,SAEJ;IAQD;;;OAGG;IACH,OAAO,CAAC,YAAY,EAAE,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,QAiBxE;IAED;;OAEG;IACG,UAAU,CACd,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,IAAI,EACjB,WAAW,CAAC,EAAE,eAAe,GAC5B,OAAO,CAAC,eAAe,CAAC,CAY1B;IAED;;;;;;;OAOG;IACH,IAAI,oBAaH;CACF;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK,iBAkBb"}
+{"version":3,"file":"ivm-branch.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/ivm-branch.ts"],"names":[],"mappings":"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"}

package/out/zero-client/src/client/ivm-branch.js

@@ -1,52 +1,119 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { wrapIterable } from "../../../shared/src/iterables.js";
-import "../../../replicache/src/db/read.js";
+import { readFromHash } from "../../../replicache/src/db/read.js";
 import { diff } from "../../../replicache/src/sync/diff.js";
 import { using, withRead } from "../../../replicache/src/with-transactions.js";
 import { must } from "../../../shared/src/must.js";
-import { diffBinarySearch } from "../../../replicache/src/subscriptions.js";
+import { assignProperty } from "../../../shared/src/objects.js";
 import { consume } from "../../../zql/src/ivm/stream.js";
+import { AGGREGATE_KEY_COLUMN, AGGREGATE_PAYLOAD_COLUMNS, AGGREGATE_VALUE_COLUMN } from "../../../zql/src/ivm/aggregate.js";
+import { diffBinarySearch } from "../../../replicache/src/subscriptions.js";
 import { makeSourceChangeEdit, makeSourceChangeRemove } from "../../../zql/src/ivm/source.js";
 import { MemorySource } from "../../../zql/src/ivm/memory-source.js";
-import { sourceNameFromKey } from "./keys.js";
+import { isAggregateTableName, isTopLevelAggregateTableName } from "../../../zql/src/builder/builder.js";
+import { valueTypeOf } from "../../../zero-types/src/schema-value.js";
+import { ROW_KEY_PREFIXES, aggregateRowKeyColumns, sourceNameFromKey } from "./keys.js";
 //#region ../zero-client/src/client/ivm-branch.ts
-/**
-* Replicache needs to rebase mutations onto different
-* commits of it's b-tree. These mutations can have reads
-* in them and those reads must be run against the IVM sources.
-*
-* To ensure the reads get the correct state, the IVM
-* sources need to reflect the state of the commit
-* being rebased onto. `IVMSourceBranch` allows us to:
-* 1. fork the IVM sources
-* 2. patch them up to match the desired head
-* 3. run the reads against the forked sources
-*
-* (2) is expected to be a cheap operation as there should only
-* ever be a few outstanding diffs to apply given Zero is meant
-* to be run in a connected state.
-*/
 var IVMSourceBranch = class IVMSourceBranch {
 	#sources;
 	#tables;
+	#aggregateOptimism;
+	#isFork;
 	#advanceError;
 	hash;
-	constructor(tables, hash, sources = /* @__PURE__ */ new Map()) {
+	constructor(tables, hash, sources = /* @__PURE__ */ new Map(), aggregateOptimism = /* @__PURE__ */ new Map(), isFork = false) {
 		this.#tables = tables;
 		this.#sources = sources;
+		this.#aggregateOptimism = aggregateOptimism;
+		this.#isFork = isFork;
 		this.hash = hash;
 	}
 	getSource(name) {
 		this.#throwIfInvalid();
 		if (this.#sources.has(name)) return this.#sources.get(name);
 		const schema = this.#tables[name];
-		const source = schema ? new MemorySource(name, schema.columns, schema.primaryKey) : void 0;
+		let source;
+		if (schema) source = new MemorySource(name, schema.columns, schema.primaryKey);
+		else if (isTopLevelAggregateTableName(name)) {
+			const columns = { [AGGREGATE_KEY_COLUMN]: { type: "number" } };
+			for (const col of AGGREGATE_PAYLOAD_COLUMNS) columns[col] = {
+				type: "number",
+				optional: true
+			};
+			source = new MemorySource(name, columns, [AGGREGATE_KEY_COLUMN]);
+		} else source = void 0;
 		this.#sources.set(name, source);
 		return source;
 	}
+	/**
+	* Get-or-create the synthetic source for a *relationship* aggregate
+	* (`aggregate:<queryID>:<alias>`), whose shape (the correlation-key columns +
+	* value) cannot be derived from the name. The query builder supplies the
+	* schema when a query materializes; {@link applyDiffs} supplies an inferred
+	* one when persisted rows are replayed before the query re-materializes (e.g.
+	* on reload). Idempotent — the first caller wins.
+	*/
+	getOrCreateAggregateSource(name, columns, primaryKey, optimistic) {
+		if (optimistic && !this.#isFork) {
+			let byTable = this.#aggregateOptimism.get(optimistic.table);
+			if (!byTable) {
+				byTable = /* @__PURE__ */ new Map();
+				this.#aggregateOptimism.set(optimistic.table, byTable);
+			}
+			byTable.set(name, {
+				aggTableName: name,
+				childField: optimistic.childField,
+				keyField: optimistic.keyField,
+				fn: optimistic.fn,
+				field: optimistic.field,
+				path: optimistic.path,
+				predicate: optimistic.predicate,
+				grouped: optimistic.grouped ?? false
+			});
+		}
+		const existing = this.#sources.get(name);
+		if (existing) return existing;
+		const source = new MemorySource(name, columns, primaryKey);
+		this.#sources.set(name, source);
+		return source;
+	}
+	/**
+	* The server names of `columns` of `table`, in the same order. A column with
+	* no server name of its own, or of a table not in the schema, keeps its name.
+	*/
+	serverColumnNames(table, columns) {
+		const tableColumns = this.#tables[table]?.columns;
+		return columns.map((c) => tableColumns?.[c]?.serverName ?? c);
+	}
+	/**
+	* The optimistic-aggregate registrations whose child rows live in `table`.
+	* An optimistic insert/delete of such a child row bumps these aggregates.
+	*/
+	getOptimisticAggregates(table) {
+		return this.#aggregateOptimism.get(table)?.values() ?? [];
+	}
 	clear() {
 		this.#sources.clear();
 	}
+	/**
+	* Drops the synthetic aggregate sources that are empty and that no view
+	* reads, with their optimistic registrations. The server deletes an
+	* aggregate's rows when its query is removed, so this is how the query's
+	* client state goes away. A later materialization recreates both.
+	*
+	* Every advance checks every aggregate source, not just the ones it emptied:
+	* the server can empty a source while a view still reads it, and a source
+	* can be destroyed without ever getting a row.
+	*
+	* Only the main branch does this: a fork's sources have no views, and the
+	* registrations are shared with the main branch.
+	*/
+	#releaseAggregateSources() {
+		for (const [name, source] of this.#sources) if (source && isAggregateTableName(name) && source.data.size === 0 && !source.connected) {
+			this.#sources.delete(name);
+			for (const byTable of this.#aggregateOptimism.values()) byTable.delete(name);
+		}
+	}
 	#throwIfInvalid() {
 		if (this.#advanceError) throw this.#advanceError;
 	}
@@ -59,6 +126,7 @@ var IVMSourceBranch = class IVMSourceBranch {
 		assert(this.hash === expectedHead, () => `Expected head must match the main head. Got: ${this.hash}, expected: ${expectedHead}`);
 		try {
 			applyDiffs(diffs, this);
+			this.#releaseAggregateSources();
 			this.hash = newHead;
 		} catch (e) {
 			this.#advanceError = e;
@@ -87,9 +155,28 @@ var IVMSourceBranch = class IVMSourceBranch {
 	*/
 	fork() {
 		this.#throwIfInvalid();
-		return new IVMSourceBranch(this.#tables, this.hash, new Map(wrapIterable(this.#sources.entries()).map(([name, source]) => [name, source?.fork()])));
+		return new IVMSourceBranch(this.#tables, this.hash, new Map(wrapIterable(this.#sources.entries()).map(([name, source]) => [name, source?.fork()])), this.#aggregateOptimism, true);
 	}
 };
+/**
+* An `add` diff for each row at `hash` that the IVM sources hold: the table
+* rows under `e/` and the aggregate rows under `a/`, in key order.
+*/
+async function readRowDiffs(store, hash) {
+	const diffs = [];
+	await withRead(store, async (dagRead) => {
+		const read = await readFromHash(hash, dagRead, 7);
+		for (const prefix of ROW_KEY_PREFIXES) for await (const entry of read.map.scan(prefix, true)) {
+			if (!entry[0].startsWith(prefix)) break;
+			diffs.push({
+				op: "add",
+				key: entry[0],
+				newValue: entry[1]
+			});
+		}
+	});
+	return diffs;
+}
 async function patchBranch(desiredHead, store, fork, readOptions) {
 	const diffs = await computeDiffs(must(fork.hash), desiredHead, store, readOptions);
 	if (!diffs) return;
@@ -109,34 +196,42 @@ async function computeDiffs(startHash, endHash, store, readOptions) {
 	return diffs.get("");
 }
 function applyDiffs(diffs, branch) {
-	for (let i = diffBinarySearch(diffs, "e/", (diff) => diff.key); i < diffs.length; i++) {
+	for (const prefix of ROW_KEY_PREFIXES) applyRowDiffs(diffs, prefix, branch);
+}
+/** Applies the diffs of the rows under `prefix`, `e/` or `a/`. */
+function applyRowDiffs(diffs, prefix, branch) {
+	for (let i = diffBinarySearch(diffs, prefix, (diff) => diff.key); i < diffs.length; i++) {
 		const diff = diffs[i];
 		const { key } = diff;
-		if (!key.startsWith("e/")) break;
+		if (!key.startsWith(prefix)) break;
 		const name = sourceNameFromKey(key);
-		const source = must(branch.getSource(name));
+		let source = branch.getSource(name);
+		if (!source && isAggregateTableName(name)) {
+			const row = diff.op === "del" ? diff.oldValue : diff.newValue;
+			source = branch.getOrCreateAggregateSource(name, ...inferAggregateSchema(name, row));
+		}
+		source = must(source);
 		switch (diff.op) {
 			case "del":
 				consume(source.push(makeSourceChangeRemove(diff.oldValue)));
 				break;
 			case "add": {
-				const rows = takeAddsForSource(diffs, i, name);
+				const sourcePrefix = key.slice(0, key.indexOf("/", prefix.length) + 1);
+				const rows = takeAddsForSource(diffs, i, sourcePrefix);
 				i += rows.length - 1;
 				source.pushAdds(rows);
 				break;
 			}
-			case "change":
-				consume(source.push(makeSourceChangeEdit(diff.newValue, diff.oldValue)));
-				break;
+			case "change": consume(source.push(makeSourceChangeEdit(diff.newValue, diff.oldValue)));
 		}
 	}
 }
 /**
-* Returns the rows of the run of `add` diffs for the source `name` that starts
-* at `start`. Diffs are ordered by key so a table's rows are contiguous.
+* Returns the rows of the run of `add` diffs under `prefix` (a source's key
+* prefix, e.g. `e/issue/`) that starts at `start`. Diffs are ordered by key so
+* a table's rows are contiguous.
 */
-function takeAddsForSource(diffs, start, name) {
-	const prefix = "e/" + name + "/";
+function takeAddsForSource(diffs, start, prefix) {
 	const rows = [];
 	for (let i = start; i < diffs.length; i++) {
 		const diff = diffs[i];
@@ -145,7 +240,31 @@ function takeAddsForSource(diffs, start, name) {
 	}
 	return rows;
 }
+/**
+* Infers a synthetic aggregate source's schema from one of its rows: the key
+* columns are every column except the payload and the row-version, with types
+* read off the actual values. Used only on the reload path, where a
+* relationship aggregate's rows are replayed before its query (which would
+* otherwise supply the exact schema) materializes.
+*/
+function inferAggregateSchema(name, row) {
+	const columns = {};
+	for (const k of Object.keys(row)) {
+		if (k === "_0_version") continue;
+		if (AGGREGATE_PAYLOAD_COLUMNS.has(k)) assignProperty(columns, k, {
+			type: "number",
+			optional: true
+		});
+		else assignProperty(columns, k, { type: valueTypeOf(row[k]) });
+	}
+	const keyColumns = aggregateRowKeyColumns(name, row);
+	if (!("_0_value" in columns)) columns[AGGREGATE_VALUE_COLUMN] = {
+		type: "number",
+		optional: true
+	};
+	return [columns, keyColumns];
+}
 //#endregion
-export { IVMSourceBranch };
+export { IVMSourceBranch, readRowDiffs };
 
 //# sourceMappingURL=ivm-branch.js.map

package/out/zero-client/src/client/ivm-branch.js.map

@@ -1 +1 @@
-{"version":3,"file":"ivm-branch.js","names":["#sources","#tables","#throwIfInvalid","#advanceError"],"sources":["../../../../../zero-client/src/client/ivm-branch.ts"],"sourcesContent":["import type {\n  InternalDiff,\n  InternalDiffOperation,\n  NoIndexDiff,\n} from '../../../replicache/src/btree/node.ts';\nimport type {LazyStore} from '../../../replicache/src/dag/lazy-store.ts';\nimport {type Read, type Store} from '../../../replicache/src/dag/store.ts';\nimport {readFromHash} from '../../../replicache/src/db/read.ts';\nimport * as FormatVersion from '../../../replicache/src/format-version-enum.ts';\nimport type {Hash} from '../../../replicache/src/hash.ts';\nimport type {ZeroReadOptions} from '../../../replicache/src/replicache-options.ts';\nimport {diffBinarySearch} from '../../../replicache/src/subscriptions.ts';\nimport type {DiffsMap} from '../../../replicache/src/sync/diff.ts';\nimport {diff} from '../../../replicache/src/sync/diff.ts';\nimport {using, withRead} from '../../../replicache/src/with-transactions.ts';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {wrapIterable} from '../../../shared/src/iterables.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {TableSchema} from '../../../zero-schema/src/table-schema.ts';\nimport {MemorySource} from '../../../zql/src/ivm/memory-source.ts';\nimport {consume} from '../../../zql/src/ivm/stream.ts';\nimport {ENTITIES_KEY_PREFIX, sourceNameFromKey} from './keys.ts';\n\nimport {\n  makeSourceChangeEdit,\n  makeSourceChangeRemove,\n} from '../../../zql/src/ivm/source.ts';\n/**\n * Replicache needs to rebase mutations onto different\n * commits of it's b-tree. These mutations can have reads\n * in them and those reads must be run against the IVM sources.\n *\n * To ensure the reads get the correct state, the IVM\n * sources need to reflect the state of the commit\n * being rebased onto. `IVMSourceBranch` allows us to:\n * 1. fork the IVM sources\n * 2. patch them up to match the desired head\n * 3. run the reads against the forked sources\n *\n * (2) is expected to be a cheap operation as there should only\n * ever be a few outstanding diffs to apply given Zero is meant\n * to be run in a connected state.\n */\nexport class IVMSourceBranch {\n  readonly #sources: Map<string, MemorySource | undefined>;\n  readonly #tables: Record<string, TableSchema>;\n  #advanceError: unknown;\n  hash: Hash | undefined;\n\n  constructor(\n    tables: Record<string, TableSchema>,\n    hash?: Hash,\n    sources: Map<string, MemorySource | undefined> = new Map(),\n  ) {\n    this.#tables = tables;\n    this.#sources = sources;\n    this.hash = hash;\n  }\n\n  getSource(name: string): MemorySource | undefined {\n    this.#throwIfInvalid();\n\n    if (this.#sources.has(name)) {\n      return this.#sources.get(name);\n    }\n\n    const schema = this.#tables[name];\n    const source = schema\n      ? new MemorySource(name, schema.columns, schema.primaryKey)\n      : undefined;\n    this.#sources.set(name, source);\n    return source;\n  }\n\n  clear() {\n    this.#sources.clear();\n  }\n\n  #throwIfInvalid() {\n    if (this.#advanceError) {\n      throw this.#advanceError;\n    }\n  }\n\n  /**\n   * Mutates the current branch, advancing it to the new head\n   * by applying the given diffs.\n   */\n  advance(expectedHead: Hash | undefined, newHead: Hash, diffs: NoIndexDiff) {\n    this.#throwIfInvalid();\n\n    assert(\n      this.hash === expectedHead,\n      () =>\n        `Expected head must match the main head. Got: ${this.hash}, expected: ${expectedHead}`,\n    );\n\n    try {\n      applyDiffs(diffs, this);\n      this.hash = newHead;\n    } catch (e) {\n      this.#advanceError = e;\n      this.clear();\n      throw e;\n    }\n  }\n\n  /**\n   * Fork the branch and patch it up to match the desired head.\n   */\n  async forkToHead(\n    store: LazyStore,\n    desiredHead: Hash,\n    readOptions?: ZeroReadOptions,\n  ): Promise<IVMSourceBranch> {\n    this.#throwIfInvalid();\n\n    const fork = this.fork();\n\n    if (fork.hash === desiredHead) {\n      return fork;\n    }\n\n    await patchBranch(desiredHead, store, fork, readOptions);\n    fork.hash = desiredHead;\n    return fork;\n  }\n\n  /**\n   * Creates a new IVMSourceBranch that is a copy of the current one.\n   * This is a cheap operation since the b-trees are shared until a write is performed\n   * and then only the modified nodes are copied.\n   *\n   * IVM branches are forked when we need to rebase mutations.\n   * The mutations modify the fork rather than original branch.\n   */\n  fork() {\n    this.#throwIfInvalid();\n\n    return new IVMSourceBranch(\n      this.#tables,\n      this.hash,\n      new Map(\n        wrapIterable(this.#sources.entries()).map(([name, source]) => [\n          name,\n          source?.fork(),\n        ]),\n      ),\n    );\n  }\n}\n\nexport async function initFromStore(\n  branch: IVMSourceBranch,\n  hash: Hash,\n  store: Store,\n) {\n  const diffs: InternalDiffOperation[] = [];\n  await withRead(store, async dagRead => {\n    const read = await readFromHash(hash, dagRead, FormatVersion.Latest);\n    for await (const entry of read.map.scan(ENTITIES_KEY_PREFIX, true)) {\n      if (!entry[0].startsWith(ENTITIES_KEY_PREFIX)) {\n        break;\n      }\n      diffs.push({\n        op: 'add',\n        key: entry[0],\n        newValue: entry[1],\n      });\n    }\n  });\n\n  branch.advance(undefined, hash, diffs);\n}\n\nasync function patchBranch(\n  desiredHead: Hash,\n  store: LazyStore,\n  fork: IVMSourceBranch,\n  readOptions: ZeroReadOptions | undefined,\n) {\n  const diffs = await computeDiffs(\n    must(fork.hash),\n    desiredHead,\n    store,\n    readOptions,\n  );\n  if (!diffs) {\n    return;\n  }\n  applyDiffs(diffs, fork);\n}\n\nasync function computeDiffs(\n  startHash: Hash,\n  endHash: Hash,\n  store: LazyStore,\n  readOptions: ZeroReadOptions | undefined,\n): Promise<InternalDiff | undefined> {\n  const readFn = (dagRead: Read) =>\n    diff(\n      startHash,\n      endHash,\n      dagRead,\n      {\n        shouldComputeDiffs: () => true,\n        shouldComputeDiffsForIndex(_name) {\n          return false;\n        },\n      },\n      FormatVersion.Latest,\n    );\n\n  let diffs: DiffsMap;\n  if (readOptions?.openLazySourceRead) {\n    diffs = await using(store.read(readOptions.openLazySourceRead), readFn);\n  } else if (readOptions?.openLazyRead) {\n    diffs = await readFn(readOptions.openLazyRead);\n  } else {\n    diffs = await withRead(store, readFn);\n  }\n\n  return diffs.get('');\n}\n\nfunction applyDiffs(diffs: NoIndexDiff, branch: IVMSourceBranch) {\n  for (\n    let i = diffBinarySearch(diffs, ENTITIES_KEY_PREFIX, diff => diff.key);\n    i < diffs.length;\n    i++\n  ) {\n    const diff = diffs[i];\n    const {key} = diff;\n    if (!key.startsWith(ENTITIES_KEY_PREFIX)) {\n      break;\n    }\n    const name = sourceNameFromKey(key);\n    const source = must(branch.getSource(name));\n    switch (diff.op) {\n      case 'del':\n        consume(source.push(makeSourceChangeRemove(diff.oldValue as Row)));\n        break;\n      case 'add': {\n        const rows = takeAddsForSource(diffs, i, name);\n        i += rows.length - 1;\n        source.pushAdds(rows);\n        break;\n      }\n      case 'change':\n        consume(\n          source.push(\n            makeSourceChangeEdit(diff.newValue as Row, diff.oldValue as Row),\n          ),\n        );\n        break;\n    }\n  }\n}\n\n/**\n * Returns the rows of the run of `add` diffs for the source `name` that starts\n * at `start`. Diffs are ordered by key so a table's rows are contiguous.\n */\nfunction takeAddsForSource(\n  diffs: NoIndexDiff,\n  start: number,\n  name: string,\n): Row[] {\n  const prefix = ENTITIES_KEY_PREFIX + name + '/';\n  const rows: Row[] = [];\n  for (let i = start; i < diffs.length; i++) {\n    const diff = diffs[i];\n    if (diff.op !== 'add' || !diff.key.startsWith(prefix)) {\n      break;\n    }\n    rows.push(diff.newValue as Row);\n  }\n  return rows;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ivm-branch.js","names":[],"sources":["../../../../../zero-client/src/client/ivm-branch.ts"],"sourcesContent":["import type {\n  InternalDiff,\n  InternalDiffOperation,\n  NoIndexDiff,\n} from '../../../replicache/src/btree/node.ts';\nimport type {LazyStore} from '../../../replicache/src/dag/lazy-store.ts';\nimport {type Read, type Store} from '../../../replicache/src/dag/store.ts';\nimport {readFromHash} from '../../../replicache/src/db/read.ts';\nimport * as FormatVersion from '../../../replicache/src/format-version-enum.ts';\nimport type {Hash} from '../../../replicache/src/hash.ts';\nimport type {ZeroReadOptions} from '../../../replicache/src/replicache-options.ts';\nimport {diffBinarySearch} from '../../../replicache/src/subscriptions.ts';\nimport type {DiffsMap} from '../../../replicache/src/sync/diff.ts';\nimport {diff} from '../../../replicache/src/sync/diff.ts';\nimport {using, withRead} from '../../../replicache/src/with-transactions.ts';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {wrapIterable} from '../../../shared/src/iterables.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {assignProperty} from '../../../shared/src/objects.ts';\nimport type {\n  AggregateFunction,\n  CompoundKey,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {TableSchema} from '../../../zero-schema/src/table-schema.ts';\nimport {\n  valueTypeOf,\n  type SchemaValue,\n} from '../../../zero-types/src/schema-value.ts';\nimport {\n  isAggregateTableName,\n  isTopLevelAggregateTableName,\n  type AggregateOptimisticDelta,\n} from '../../../zql/src/builder/builder.ts';\nimport {\n  AGGREGATE_KEY_COLUMN,\n  AGGREGATE_PAYLOAD_COLUMNS,\n  AGGREGATE_VALUE_COLUMN,\n} from '../../../zql/src/ivm/aggregate.ts';\nimport {MemorySource} from '../../../zql/src/ivm/memory-source.ts';\nimport {consume} from '../../../zql/src/ivm/stream.ts';\nimport {\n  aggregateRowKeyColumns,\n  ROW_KEY_PREFIXES,\n  ROW_VERSION_COLUMN,\n  sourceNameFromKey,\n} from './keys.ts';\n\nimport {\n  makeSourceChangeEdit,\n  makeSourceChangeRemove,\n} from '../../../zql/src/ivm/source.ts';\n/**\n * Replicache needs to rebase mutations onto different\n * commits of it's b-tree. These mutations can have reads\n * in them and those reads must be run against the IVM sources.\n *\n * To ensure the reads get the correct state, the IVM\n * sources need to reflect the state of the commit\n * being rebased onto. `IVMSourceBranch` allows us to:\n * 1. fork the IVM sources\n * 2. patch them up to match the desired head\n * 3. run the reads against the forked sources\n *\n * (2) is expected to be a cheap operation as there should only\n * ever be a few outstanding diffs to apply given Zero is meant\n * to be run in a connected state.\n */\n/**\n * Metadata for optimistically updating a synced aggregate when a child row is\n * locally mutated. Registered when a relationship-aggregate query materializes.\n */\nexport type OptimisticAggregate = {\n  /** The synthetic aggregate table, e.g. `aggregate:<queryID>:<alias>`. */\n  readonly aggTableName: string;\n  /** The correlation columns of a child row, as the client names them. */\n  readonly childField: readonly string[];\n  /**\n   * The same columns as the synced aggregate rows name them (server names), in\n   * the same order. An aggregate row's key is built from these.\n   */\n  readonly keyField: readonly string[];\n  /** The aggregate function (`count`/`sum`/`avg` are optimistically deltaed). */\n  readonly fn: AggregateFunction;\n  /** The aggregated field, for `sum`/`avg` (`undefined` for `count`). */\n  readonly field: string | undefined;\n  /** A JSON path into `field` (see `Aggregate.path`). */\n  readonly path: readonly (string | number)[] | undefined;\n  /**\n   * The aggregate's `where`, compiled to a per-row predicate. A child row\n   * contributes only when it returns true; `undefined` means no filter (every\n   * child contributes). Only set when the whole `where` is per-row evaluable —\n   * a correlated subquery in the `where` makes the aggregate\n   * server-authoritative (it is never registered for optimism at all).\n   */\n  readonly predicate: ((row: Row) => boolean) | undefined;\n  /** The rows are a grouped query's groups (see `AggregateOptimisticDelta`). */\n  readonly grouped: boolean;\n};\n\nexport class IVMSourceBranch {\n  readonly #sources: Map<string, MemorySource | undefined>;\n  readonly #tables: Record<string, TableSchema>;\n  // Registry for optimistic aggregate deltas: child table name -> (synthetic\n  // aggregate table name -> metadata). Lets an optimistic child mutation find\n  // the aggregate rows it should bump. Shared by reference across forks (it is\n  // query metadata, independent of branch row state).\n  readonly #aggregateOptimism: Map<string, Map<string, OptimisticAggregate>>;\n  // Only the main branch registers optimistic aggregates: see\n  // getOrCreateAggregateSource.\n  readonly #isFork: boolean;\n  #advanceError: unknown;\n  hash: Hash | undefined;\n\n  constructor(\n    tables: Record<string, TableSchema>,\n    hash?: Hash,\n    sources: Map<string, MemorySource | undefined> = new Map(),\n    aggregateOptimism: Map<\n      string,\n      Map<string, OptimisticAggregate>\n    > = new Map(),\n    isFork = false,\n  ) {\n    this.#tables = tables;\n    this.#sources = sources;\n    this.#aggregateOptimism = aggregateOptimism;\n    this.#isFork = isFork;\n    this.hash = hash;\n  }\n\n  getSource(name: string): MemorySource | undefined {\n    this.#throwIfInvalid();\n\n    if (this.#sources.has(name)) {\n      return this.#sources.get(name);\n    }\n\n    const schema = this.#tables[name];\n    let source: MemorySource | undefined;\n    if (schema) {\n      source = new MemorySource(name, schema.columns, schema.primaryKey);\n    } else if (isTopLevelAggregateTableName(name)) {\n      // Synthetic source for a synced top-level aggregate (e.g. `count()`). It\n      // is not in the static schema; its shape is fixed (the singleton key\n      // column + the result value), so it can be provisioned from the name\n      // alone — including at reload time, before the query re-materializes. The\n      // server streams the precomputed value here; the underlying rows are never\n      // synced. The payload is typed as `inferAggregateSchema` types it: the\n      // value is null over no rows, and `sum`/`avg` add their components.\n      const columns: Record<string, SchemaValue> = {\n        [AGGREGATE_KEY_COLUMN]: {type: 'number'},\n      };\n      for (const col of AGGREGATE_PAYLOAD_COLUMNS) {\n        columns[col] = {type: 'number', optional: true};\n      }\n      source = new MemorySource(name, columns, [AGGREGATE_KEY_COLUMN]);\n    } else {\n      source = undefined;\n    }\n    this.#sources.set(name, source);\n    return source;\n  }\n\n  /**\n   * Get-or-create the synthetic source for a *relationship* aggregate\n   * (`aggregate:<queryID>:<alias>`), whose shape (the correlation-key columns +\n   * value) cannot be derived from the name. The query builder supplies the\n   * schema when a query materializes; {@link applyDiffs} supplies an inferred\n   * one when persisted rows are replayed before the query re-materializes (e.g.\n   * on reload). Idempotent — the first caller wins.\n   */\n  getOrCreateAggregateSource(\n    name: string,\n    columns: Record<string, SchemaValue>,\n    primaryKey: PrimaryKey,\n    optimistic?: AggregateOptimisticDelta,\n  ): MemorySource {\n    // A fork (a mutator's `tx.run`, or a rebase) shares the main branch's\n    // registry, but only the main branch releases registrations, when the\n    // server empties a source a view of it holds. A query materialized on a\n    // fork is never synced, so its registration would never be released, and\n    // a synced one is registered by the main branch already.\n    if (optimistic && !this.#isFork) {\n      let byTable = this.#aggregateOptimism.get(optimistic.table);\n      if (!byTable) {\n        byTable = new Map();\n        this.#aggregateOptimism.set(optimistic.table, byTable);\n      }\n      // Keyed by aggregate table name so re-registering the same query is a\n      // no-op (idempotent).\n      byTable.set(name, {\n        aggTableName: name,\n        childField: optimistic.childField,\n        keyField: optimistic.keyField,\n        fn: optimistic.fn,\n        field: optimistic.field,\n        path: optimistic.path,\n        predicate: optimistic.predicate,\n        grouped: optimistic.grouped ?? false,\n      });\n    }\n    const existing = this.#sources.get(name);\n    if (existing) {\n      return existing;\n    }\n    const source = new MemorySource(name, columns, primaryKey);\n    this.#sources.set(name, source);\n    return source;\n  }\n\n  /**\n   * The server names of `columns` of `table`, in the same order. A column with\n   * no server name of its own, or of a table not in the schema, keeps its name.\n   */\n  serverColumnNames(table: string, columns: CompoundKey): CompoundKey {\n    const tableColumns = this.#tables[table]?.columns;\n    return columns.map(\n      c => tableColumns?.[c]?.serverName ?? c,\n    ) as unknown as CompoundKey;\n  }\n\n  /**\n   * The optimistic-aggregate registrations whose child rows live in `table`.\n   * An optimistic insert/delete of such a child row bumps these aggregates.\n   */\n  getOptimisticAggregates(table: string): Iterable<OptimisticAggregate> {\n    return this.#aggregateOptimism.get(table)?.values() ?? [];\n  }\n\n  clear() {\n    this.#sources.clear();\n  }\n\n  /**\n   * Drops the synthetic aggregate sources that are empty and that no view\n   * reads, with their optimistic registrations. The server deletes an\n   * aggregate's rows when its query is removed, so this is how the query's\n   * client state goes away. A later materialization recreates both.\n   *\n   * Every advance checks every aggregate source, not just the ones it emptied:\n   * the server can empty a source while a view still reads it, and a source\n   * can be destroyed without ever getting a row.\n   *\n   * Only the main branch does this: a fork's sources have no views, and the\n   * registrations are shared with the main branch.\n   */\n  #releaseAggregateSources() {\n    for (const [name, source] of this.#sources) {\n      if (\n        source &&\n        isAggregateTableName(name) &&\n        source.data.size === 0 &&\n        !source.connected\n      ) {\n        this.#sources.delete(name);\n        for (const byTable of this.#aggregateOptimism.values()) {\n          byTable.delete(name);\n        }\n      }\n    }\n  }\n\n  #throwIfInvalid() {\n    if (this.#advanceError) {\n      throw this.#advanceError;\n    }\n  }\n\n  /**\n   * Mutates the current branch, advancing it to the new head\n   * by applying the given diffs.\n   */\n  advance(expectedHead: Hash | undefined, newHead: Hash, diffs: NoIndexDiff) {\n    this.#throwIfInvalid();\n\n    assert(\n      this.hash === expectedHead,\n      () =>\n        `Expected head must match the main head. Got: ${this.hash}, expected: ${expectedHead}`,\n    );\n\n    try {\n      applyDiffs(diffs, this);\n      this.#releaseAggregateSources();\n      this.hash = newHead;\n    } catch (e) {\n      this.#advanceError = e;\n      this.clear();\n      throw e;\n    }\n  }\n\n  /**\n   * Fork the branch and patch it up to match the desired head.\n   */\n  async forkToHead(\n    store: LazyStore,\n    desiredHead: Hash,\n    readOptions?: ZeroReadOptions,\n  ): Promise<IVMSourceBranch> {\n    this.#throwIfInvalid();\n\n    const fork = this.fork();\n\n    if (fork.hash === desiredHead) {\n      return fork;\n    }\n\n    await patchBranch(desiredHead, store, fork, readOptions);\n    fork.hash = desiredHead;\n    return fork;\n  }\n\n  /**\n   * Creates a new IVMSourceBranch that is a copy of the current one.\n   * This is a cheap operation since the b-trees are shared until a write is performed\n   * and then only the modified nodes are copied.\n   *\n   * IVM branches are forked when we need to rebase mutations.\n   * The mutations modify the fork rather than original branch.\n   */\n  fork() {\n    this.#throwIfInvalid();\n\n    return new IVMSourceBranch(\n      this.#tables,\n      this.hash,\n      new Map(\n        wrapIterable(this.#sources.entries()).map(([name, source]) => [\n          name,\n          source?.fork(),\n        ]),\n      ),\n      // Share the optimistic-aggregate registry by reference: it is query\n      // metadata, the same for the fork as for the main branch.\n      this.#aggregateOptimism,\n      true,\n    );\n  }\n}\n\nexport async function initFromStore(\n  branch: IVMSourceBranch,\n  hash: Hash,\n  store: Store,\n) {\n  branch.advance(undefined, hash, await readRowDiffs(store, hash));\n}\n\n/**\n * An `add` diff for each row at `hash` that the IVM sources hold: the table\n * rows under `e/` and the aggregate rows under `a/`, in key order.\n */\nexport async function readRowDiffs(\n  store: Store,\n  hash: Hash,\n): Promise<InternalDiffOperation[]> {\n  const diffs: InternalDiffOperation[] = [];\n  await withRead(store, async dagRead => {\n    const read = await readFromHash(hash, dagRead, FormatVersion.Latest);\n    for (const prefix of ROW_KEY_PREFIXES) {\n      for await (const entry of read.map.scan(prefix, true)) {\n        if (!entry[0].startsWith(prefix)) {\n          break;\n        }\n        diffs.push({\n          op: 'add',\n          key: entry[0],\n          newValue: entry[1],\n        });\n      }\n    }\n  });\n  return diffs;\n}\n\nasync function patchBranch(\n  desiredHead: Hash,\n  store: LazyStore,\n  fork: IVMSourceBranch,\n  readOptions: ZeroReadOptions | undefined,\n) {\n  const diffs = await computeDiffs(\n    must(fork.hash),\n    desiredHead,\n    store,\n    readOptions,\n  );\n  if (!diffs) {\n    return;\n  }\n  applyDiffs(diffs, fork);\n}\n\nasync function computeDiffs(\n  startHash: Hash,\n  endHash: Hash,\n  store: LazyStore,\n  readOptions: ZeroReadOptions | undefined,\n): Promise<InternalDiff | undefined> {\n  const readFn = (dagRead: Read) =>\n    diff(\n      startHash,\n      endHash,\n      dagRead,\n      {\n        shouldComputeDiffs: () => true,\n        shouldComputeDiffsForIndex(_name) {\n          return false;\n        },\n      },\n      FormatVersion.Latest,\n    );\n\n  let diffs: DiffsMap;\n  if (readOptions?.openLazySourceRead) {\n    diffs = await using(store.read(readOptions.openLazySourceRead), readFn);\n  } else if (readOptions?.openLazyRead) {\n    diffs = await readFn(readOptions.openLazyRead);\n  } else {\n    diffs = await withRead(store, readFn);\n  }\n\n  return diffs.get('');\n}\n\nfunction applyDiffs(diffs: NoIndexDiff, branch: IVMSourceBranch) {\n  for (const prefix of ROW_KEY_PREFIXES) {\n    applyRowDiffs(diffs, prefix, branch);\n  }\n}\n\n/** Applies the diffs of the rows under `prefix`, `e/` or `a/`. */\nfunction applyRowDiffs(\n  diffs: NoIndexDiff,\n  prefix: string,\n  branch: IVMSourceBranch,\n) {\n  for (\n    let i = diffBinarySearch(diffs, prefix, diff => diff.key);\n    i < diffs.length;\n    i++\n  ) {\n    const diff = diffs[i];\n    const {key} = diff;\n    if (!key.startsWith(prefix)) {\n      break;\n    }\n    const name = sourceNameFromKey(key);\n    let source = branch.getSource(name);\n    if (!source && isAggregateTableName(name)) {\n      // A relationship aggregate source isn't derivable from the name, so it\n      // may not exist yet when persisted rows are replayed before the query\n      // re-materializes (reload). Provision it from the row's own shape; the\n      // builder will reuse this same source when the query materializes.\n      const row = (diff.op === 'del' ? diff.oldValue : diff.newValue) as Row;\n      source = branch.getOrCreateAggregateSource(\n        name,\n        ...inferAggregateSchema(name, row),\n      );\n    }\n    source = must(source);\n    switch (diff.op) {\n      case 'del':\n        consume(source.push(makeSourceChangeRemove(diff.oldValue as Row)));\n        break;\n      case 'add': {\n        // The source's own prefix: the key up to the slash after its name.\n        const sourcePrefix = key.slice(0, key.indexOf('/', prefix.length) + 1);\n        const rows = takeAddsForSource(diffs, i, sourcePrefix);\n        i += rows.length - 1;\n        source.pushAdds(rows);\n        break;\n      }\n      case 'change':\n        consume(\n          source.push(\n            makeSourceChangeEdit(diff.newValue as Row, diff.oldValue as Row),\n          ),\n        );\n        break;\n    }\n  }\n}\n\n/**\n * Returns the rows of the run of `add` diffs under `prefix` (a source's key\n * prefix, e.g. `e/issue/`) that starts at `start`. Diffs are ordered by key so\n * a table's rows are contiguous.\n */\nfunction takeAddsForSource(\n  diffs: NoIndexDiff,\n  start: number,\n  prefix: string,\n): Row[] {\n  const rows: Row[] = [];\n  for (let i = start; i < diffs.length; i++) {\n    const diff = diffs[i];\n    if (diff.op !== 'add' || !diff.key.startsWith(prefix)) {\n      break;\n    }\n    rows.push(diff.newValue as Row);\n  }\n  return rows;\n}\n\n/**\n * Infers a synthetic aggregate source's schema from one of its rows: the key\n * columns are every column except the payload and the row-version, with types\n * read off the actual values. Used only on the reload path, where a\n * relationship aggregate's rows are replayed before its query (which would\n * otherwise supply the exact schema) materializes.\n */\nfunction inferAggregateSchema(\n  name: string,\n  row: Row,\n): [columns: Record<string, SchemaValue>, primaryKey: PrimaryKey] {\n  const columns: Record<string, SchemaValue> = {};\n  for (const k of Object.keys(row)) {\n    if (k === ROW_VERSION_COLUMN) {\n      continue;\n    }\n    if (AGGREGATE_PAYLOAD_COLUMNS.has(k)) {\n      // The result (and, for sum/avg, its components) — numeric payload, never part of the key.\n      assignProperty(columns, k, {type: 'number', optional: true});\n    } else {\n      assignProperty(columns, k, {type: valueTypeOf(row[k])});\n    }\n  }\n  const keyColumns = aggregateRowKeyColumns(name, row);\n  // The result column is always present even if absent from this particular row.\n  if (!(AGGREGATE_VALUE_COLUMN in columns)) {\n    columns[AGGREGATE_VALUE_COLUMN] = {type: 'number', optional: true};\n  }\n  return [columns, keyColumns as unknown as PrimaryKey];\n}\n"],"mappings":"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"}

package/out/zero-client/src/client/keys.d.ts

@@ -1,14 +1,46 @@
 import type { CompoundKey } from '../../../zero-protocol/src/ast.ts';
 import type { Row } from '../../../zero-protocol/src/data.ts';
 import type { MutationID } from '../../../zero-protocol/src/mutation-id.ts';
-export declare const DESIRED_QUERIES_KEY_PREFIX = "d/";
+export declare const ROW_VERSION_COLUMN = "_0_version";
 export declare const GOT_QUERIES_KEY_PREFIX = "g/";
 export declare const ENTITIES_KEY_PREFIX = "e/";
+/**
+ * Synced aggregate results live outside `e/`. A client from before them loads
+ * every `e/` row into a table of its schema and fails to open a database that
+ * has rows of an `aggregate:` table there, while it skips keys outside `e/`.
+ * Keeping them apart lets both versions share a database (STORAGE_VERSION).
+ */
+export declare const AGGREGATES_KEY_PREFIX = "a/";
+/** The prefixes of the rows the IVM sources hold, in key order. */
+export declare const ROW_KEY_PREFIXES: readonly ["a/", "e/"];
 export declare const MUTATIONS_KEY_PREFIX = "m/";
 export declare function toDesiredQueriesKey(clientID: string, hash: string): string;
 export declare function desiredQueriesPrefixForClient(clientID: string): string;
 export declare function toGotQueriesKey(hash: string): string;
 export declare function toMutationResponseKey(mid: MutationID): string;
 export declare function toPrimaryKeyString(tableName: string, primaryKey: CompoundKey, value: Row): string;
+/**
+ * The source (table) name of an `e/` or `a/` row key. An `a/` key leaves out
+ * the `aggregate:` every aggregate table name starts with.
+ */
 export declare function sourceNameFromKey(key: string): string;
+/**
+ * The Replicache key for a synthetic aggregate row: `a/`, the table name
+ * without its `aggregate:`, and the row's key. The key columns
+ * are every column except the payload (`_0_value`, plus `_0_sum`/`_0_count`)
+ * and the row-version, sorted so a `put` (full
+ * row), a `del`/`update` (row key only), and an optimistic delta from a mutation
+ * all produce the same key. Works for both top-level (`{_0_key: 0, …}`) and
+ * relationship (`{…childFields, …}`) rows.
+ */
+export declare function aggregateRowKey(tableName: string, row: Row): string;
+/**
+ * The key columns of a row of the synthetic aggregate table `tableName`:
+ * `_0_key` for a top-level aggregate's or a grouped query's, which also
+ * carries the columns it encodes, and otherwise, for a relationship aggregate's,
+ * every column except the payload and the row-version, sorted. The table
+ * name decides, not the row, so a relationship aggregate's key is the same
+ * whatever its columns are named.
+ */
+export declare function aggregateRowKeyColumns(tableName: string, row: Row): string[];
 //# sourceMappingURL=keys.d.ts.map

package/out/zero-client/src/client/keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/keys.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAG1E,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAC/C,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAE7D;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,GAAG,GACT,MAAM,CAeR;AA0BD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrD"}
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/keys.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAW1E,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAG/C,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAC1C,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,uBAGnB,CAAC;AACX,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAE7D;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,GAAG,GACT,MAAM,CAER;AAgDD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAQnE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE,CAO5E"}

package/out/zero-client/src/client/keys.js

@@ -1,11 +1,19 @@
 import { parse } from "../../../shared/src/valita.js";
 import { h128 } from "../../../shared/src/hash.js";
+import { AGGREGATE_KEY_COLUMN, AGGREGATE_PAYLOAD_COLUMNS } from "../../../zql/src/ivm/aggregate.js";
+import { AGGREGATE_TABLE_PREFIX } from "../../../zero-protocol/src/aggregate-table.js";
 import { primaryKeyValueSchema } from "../../../zero-protocol/src/primary-key.js";
+import { isKeyedAggregateTableName } from "../../../zql/src/builder/builder.js";
+//#region ../zero-client/src/client/keys.ts
+var ROW_VERSION_COLUMN = "_0_version";
+var DESIRED_QUERIES_KEY_PREFIX = "d/";
+/** The prefixes of the rows the IVM sources hold, in key order. */
+var ROW_KEY_PREFIXES = ["a/", "e/"];
 function toDesiredQueriesKey(clientID, hash) {
-	return "d/" + clientID + "/" + hash;
+	return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash;
 }
 function desiredQueriesPrefixForClient(clientID) {
-	return "d/" + clientID + "/";
+	return DESIRED_QUERIES_KEY_PREFIX + clientID + "/";
 }
 function toGotQueriesKey(hash) {
 	return "g/" + hash;
@@ -14,10 +22,14 @@ function toMutationResponseKey(mid) {
 	return "m/" + mid.clientID + "/" + mid.id;
 }
 function toPrimaryKeyString(tableName, primaryKey, value) {
-	if (primaryKey.length === 1) return "e/" + tableName + "/" + parse(value[primaryKey[0]], primaryKeyValueSchema);
+	return rowKey("e/", tableName, primaryKey, value);
+}
+function rowKey(prefix, tableName, primaryKey, value) {
+	if (primaryKey.length === 1) return prefix + tableName + "/" + parse(value[primaryKey[0]], primaryKeyValueSchema);
 	const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
-	const idSegment = u128ToDecimal(h128(JSON.stringify(values)));
-	return "e/" + tableName + "/" + idSegment;
+	const str = JSON.stringify(values);
+	const idSegment = u128ToDecimal(h128(str));
+	return prefix + tableName + "/" + idSegment;
 }
 var E19 = 10n ** 19n;
 /**
@@ -37,11 +49,41 @@ function u128ToDecimal(x) {
 	if (t < E19) return String(t) + low;
 	return String(t / E19) + String(t % E19).padStart(19, "0") + low;
 }
+/**
+* The source (table) name of an `e/` or `a/` row key. An `a/` key leaves out
+* the `aggregate:` every aggregate table name starts with.
+*/
 function sourceNameFromKey(key) {
 	const slash = key.indexOf("/", 2);
-	return key.slice(2, slash);
+	const name = key.slice(2, slash);
+	return key.startsWith("a/") ? AGGREGATE_TABLE_PREFIX + name : name;
+}
+/**
+* The Replicache key for a synthetic aggregate row: `a/`, the table name
+* without its `aggregate:`, and the row's key. The key columns
+* are every column except the payload (`_0_value`, plus `_0_sum`/`_0_count`)
+* and the row-version, sorted so a `put` (full
+* row), a `del`/`update` (row key only), and an optimistic delta from a mutation
+* all produce the same key. Works for both top-level (`{_0_key: 0, …}`) and
+* relationship (`{…childFields, …}`) rows.
+*/
+function aggregateRowKey(tableName, row) {
+	const keyColumns = aggregateRowKeyColumns(tableName, row);
+	return rowKey("a/", tableName.slice(AGGREGATE_TABLE_PREFIX.length), keyColumns, row);
+}
+/**
+* The key columns of a row of the synthetic aggregate table `tableName`:
+* `_0_key` for a top-level aggregate's or a grouped query's, which also
+* carries the columns it encodes, and otherwise, for a relationship aggregate's,
+* every column except the payload and the row-version, sorted. The table
+* name decides, not the row, so a relationship aggregate's key is the same
+* whatever its columns are named.
+*/
+function aggregateRowKeyColumns(tableName, row) {
+	if (isKeyedAggregateTableName(tableName)) return [AGGREGATE_KEY_COLUMN];
+	return Object.keys(row).filter((k) => !AGGREGATE_PAYLOAD_COLUMNS.has(k) && k !== "_0_version").sort();
 }
 //#endregion
-export { desiredQueriesPrefixForClient, sourceNameFromKey, toDesiredQueriesKey, toGotQueriesKey, toMutationResponseKey, toPrimaryKeyString };
+export { ROW_KEY_PREFIXES, ROW_VERSION_COLUMN, aggregateRowKey, aggregateRowKeyColumns, desiredQueriesPrefixForClient, sourceNameFromKey, toDesiredQueriesKey, toGotQueriesKey, toMutationResponseKey, toPrimaryKeyString };
 
 //# sourceMappingURL=keys.js.map

package/out/zero-client/src/client/keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"keys.js","names":[],"sources":["../../../../../zero-client/src/client/keys.ts"],"sourcesContent":["import {h128} from '../../../shared/src/hash.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {MutationID} from '../../../zero-protocol/src/mutation-id.ts';\nimport {primaryKeyValueSchema} from '../../../zero-protocol/src/primary-key.ts';\n\nexport const DESIRED_QUERIES_KEY_PREFIX = 'd/';\nexport const GOT_QUERIES_KEY_PREFIX = 'g/';\nexport const ENTITIES_KEY_PREFIX = 'e/';\nexport const MUTATIONS_KEY_PREFIX = 'm/';\n\nexport function toDesiredQueriesKey(clientID: string, hash: string): string {\n  return DESIRED_QUERIES_KEY_PREFIX + clientID + '/' + hash;\n}\n\nexport function desiredQueriesPrefixForClient(clientID: string): string {\n  return DESIRED_QUERIES_KEY_PREFIX + clientID + '/';\n}\n\nexport function toGotQueriesKey(hash: string): string {\n  return GOT_QUERIES_KEY_PREFIX + hash;\n}\n\nexport function toMutationResponseKey(mid: MutationID): string {\n  return MUTATIONS_KEY_PREFIX + mid.clientID + '/' + mid.id;\n}\n\nexport function toPrimaryKeyString(\n  tableName: string,\n  primaryKey: CompoundKey,\n  value: Row,\n): string {\n  if (primaryKey.length === 1) {\n    return (\n      ENTITIES_KEY_PREFIX +\n      tableName +\n      '/' +\n      v.parse(value[primaryKey[0]], primaryKeyValueSchema)\n    );\n  }\n\n  const values = primaryKey.map(k => v.parse(value[k], primaryKeyValueSchema));\n  const str = JSON.stringify(values);\n\n  const idSegment = u128ToDecimal(h128(str));\n  return ENTITIES_KEY_PREFIX + tableName + '/' + idSegment;\n}\n\nconst E19 = 10n ** 19n;\n\n/**\n * `String(x)` for an unsigned 128-bit `x`: the decimal form entity keys have\n * always used for compound primary keys, so it must not change.\n *\n * Chromium 148 (V8 14.8) takes ~4us to stringify a bigint wider than 64 bits\n * in base 10, against ~100ns in node 24, Firefox and WebKit; bigints that fit\n * in 64 bits stay fast everywhere. Splitting `x` into base-10^19 pieces, each\n * under 2^64, keeps every conversion on that fast path: ~35x faster in\n * Chromium and within ~10% elsewhere.\n */\nfunction u128ToDecimal(x: bigint): string {\n  if (x < E19) {\n    return String(x);\n  }\n  const t = x / E19;\n  const low = String(x % E19).padStart(19, '0');\n  if (t < E19) {\n    return String(t) + low;\n  }\n  return String(t / E19) + String(t % E19).padStart(19, '0') + low;\n}\n\nexport function sourceNameFromKey(key: string): string {\n  const slash = key.indexOf('/', ENTITIES_KEY_PREFIX.length);\n  return key.slice(ENTITIES_KEY_PREFIX.length, slash);\n}\n"],"mappings":";;;AAYA,SAAgB,oBAAoB,UAAkB,MAAsB;CAC1E,OAAA,OAAoC,WAAW,MAAM;AACvD;AAEA,SAAgB,8BAA8B,UAA0B;CACtE,OAAA,OAAoC,WAAW;AACjD;AAEA,SAAgB,gBAAgB,MAAsB;CACpD,OAAA,OAAgC;AAClC;AAEA,SAAgB,sBAAsB,KAAyB;CAC7D,OAAA,OAA8B,IAAI,WAAW,MAAM,IAAI;AACzD;AAEA,SAAgB,mBACd,WACA,YACA,OACQ;CACR,IAAI,WAAW,WAAW,GACxB,OAAA,OAEE,YACA,MACA,MAAQ,MAAM,WAAW,KAAK,qBAAqB;CAIvD,MAAM,SAAS,WAAW,KAAI,MAAK,MAAQ,MAAM,IAAI,qBAAqB,CAAC;CAG3E,MAAM,YAAY,cAAc,KAFpB,KAAK,UAAU,MAEU,CAAG,CAAC;CACzC,OAAA,OAA6B,YAAY,MAAM;AACjD;AAEA,IAAM,MAAM,OAAO;;;;;;;;;;;AAYnB,SAAS,cAAc,GAAmB;CACxC,IAAI,IAAI,KACN,OAAO,OAAO,CAAC;CAEjB,MAAM,IAAI,IAAI;CACd,MAAM,MAAM,OAAO,IAAI,GAAG,EAAE,SAAS,IAAI,GAAG;CAC5C,IAAI,IAAI,KACN,OAAO,OAAO,CAAC,IAAI;CAErB,OAAO,OAAO,IAAI,GAAG,IAAI,OAAO,IAAI,GAAG,EAAE,SAAS,IAAI,GAAG,IAAI;AAC/D;AAEA,SAAgB,kBAAkB,KAAqB;CACrD,MAAM,QAAQ,IAAI,QAAQ,KAAK,CAA0B;CACzD,OAAO,IAAI,MAAM,GAA4B,KAAK;AACpD"}
+{"version":3,"file":"keys.js","names":["v.parse"],"sources":["../../../../../zero-client/src/client/keys.ts"],"sourcesContent":["import {h128} from '../../../shared/src/hash.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport {AGGREGATE_TABLE_PREFIX} from '../../../zero-protocol/src/aggregate-table.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {MutationID} from '../../../zero-protocol/src/mutation-id.ts';\nimport {primaryKeyValueSchema} from '../../../zero-protocol/src/primary-key.ts';\nimport {isKeyedAggregateTableName} from '../../../zql/src/builder/builder.ts';\nimport {\n  AGGREGATE_KEY_COLUMN,\n  AGGREGATE_PAYLOAD_COLUMNS,\n} from '../../../zql/src/ivm/aggregate.ts';\n\n// The replicated row-version column the server stamps on synced rows; not part\n// of an aggregate's key. (Mirrors zero-cache's ZERO_VERSION_COLUMN_NAME, which\n// is server-side; inlined here to avoid a server dependency.)\nexport const ROW_VERSION_COLUMN = '_0_version';\n\nconst DESIRED_QUERIES_KEY_PREFIX = 'd/';\nexport const GOT_QUERIES_KEY_PREFIX = 'g/';\nexport const ENTITIES_KEY_PREFIX = 'e/';\n/**\n * Synced aggregate results live outside `e/`. A client from before them loads\n * every `e/` row into a table of its schema and fails to open a database that\n * has rows of an `aggregate:` table there, while it skips keys outside `e/`.\n * Keeping them apart lets both versions share a database (STORAGE_VERSION).\n */\nexport const AGGREGATES_KEY_PREFIX = 'a/';\n/** The prefixes of the rows the IVM sources hold, in key order. */\nexport const ROW_KEY_PREFIXES = [\n  AGGREGATES_KEY_PREFIX,\n  ENTITIES_KEY_PREFIX,\n] as const;\nexport const MUTATIONS_KEY_PREFIX = 'm/';\n\nexport function toDesiredQueriesKey(clientID: string, hash: string): string {\n  return DESIRED_QUERIES_KEY_PREFIX + clientID + '/' + hash;\n}\n\nexport function desiredQueriesPrefixForClient(clientID: string): string {\n  return DESIRED_QUERIES_KEY_PREFIX + clientID + '/';\n}\n\nexport function toGotQueriesKey(hash: string): string {\n  return GOT_QUERIES_KEY_PREFIX + hash;\n}\n\nexport function toMutationResponseKey(mid: MutationID): string {\n  return MUTATIONS_KEY_PREFIX + mid.clientID + '/' + mid.id;\n}\n\nexport function toPrimaryKeyString(\n  tableName: string,\n  primaryKey: CompoundKey,\n  value: Row,\n): string {\n  return rowKey(ENTITIES_KEY_PREFIX, tableName, primaryKey, value);\n}\n\nfunction rowKey(\n  prefix: string,\n  tableName: string,\n  primaryKey: CompoundKey,\n  value: Row,\n): string {\n  if (primaryKey.length === 1) {\n    return (\n      prefix +\n      tableName +\n      '/' +\n      v.parse(value[primaryKey[0]], primaryKeyValueSchema)\n    );\n  }\n\n  const values = primaryKey.map(k => v.parse(value[k], primaryKeyValueSchema));\n  const str = JSON.stringify(values);\n\n  const idSegment = u128ToDecimal(h128(str));\n  return prefix + tableName + '/' + idSegment;\n}\n\nconst E19 = 10n ** 19n;\n\n/**\n * `String(x)` for an unsigned 128-bit `x`: the decimal form entity keys have\n * always used for compound primary keys, so it must not change.\n *\n * Chromium 148 (V8 14.8) takes ~4us to stringify a bigint wider than 64 bits\n * in base 10, against ~100ns in node 24, Firefox and WebKit; bigints that fit\n * in 64 bits stay fast everywhere. Splitting `x` into base-10^19 pieces, each\n * under 2^64, keeps every conversion on that fast path: ~35x faster in\n * Chromium and within ~10% elsewhere.\n */\nfunction u128ToDecimal(x: bigint): string {\n  if (x < E19) {\n    return String(x);\n  }\n  const t = x / E19;\n  const low = String(x % E19).padStart(19, '0');\n  if (t < E19) {\n    return String(t) + low;\n  }\n  return String(t / E19) + String(t % E19).padStart(19, '0') + low;\n}\n\n/**\n * The source (table) name of an `e/` or `a/` row key. An `a/` key leaves out\n * the `aggregate:` every aggregate table name starts with.\n */\nexport function sourceNameFromKey(key: string): string {\n  // Both prefixes are two characters long.\n  const slash = key.indexOf('/', ENTITIES_KEY_PREFIX.length);\n  const name = key.slice(ENTITIES_KEY_PREFIX.length, slash);\n  return key.startsWith(AGGREGATES_KEY_PREFIX)\n    ? AGGREGATE_TABLE_PREFIX + name\n    : name;\n}\n\n/**\n * The Replicache key for a synthetic aggregate row: `a/`, the table name\n * without its `aggregate:`, and the row's key. The key columns\n * are every column except the payload (`_0_value`, plus `_0_sum`/`_0_count`)\n * and the row-version, sorted so a `put` (full\n * row), a `del`/`update` (row key only), and an optimistic delta from a mutation\n * all produce the same key. Works for both top-level (`{_0_key: 0, …}`) and\n * relationship (`{…childFields, …}`) rows.\n */\nexport function aggregateRowKey(tableName: string, row: Row): string {\n  const keyColumns = aggregateRowKeyColumns(tableName, row);\n  return rowKey(\n    AGGREGATES_KEY_PREFIX,\n    tableName.slice(AGGREGATE_TABLE_PREFIX.length),\n    keyColumns as unknown as CompoundKey,\n    row,\n  );\n}\n\n/**\n * The key columns of a row of the synthetic aggregate table `tableName`:\n * `_0_key` for a top-level aggregate's or a grouped query's, which also\n * carries the columns it encodes, and otherwise, for a relationship aggregate's,\n * every column except the payload and the row-version, sorted. The table\n * name decides, not the row, so a relationship aggregate's key is the same\n * whatever its columns are named.\n */\nexport function aggregateRowKeyColumns(tableName: string, row: Row): string[] {\n  if (isKeyedAggregateTableName(tableName)) {\n    return [AGGREGATE_KEY_COLUMN];\n  }\n  return Object.keys(row)\n    .filter(k => !AGGREGATE_PAYLOAD_COLUMNS.has(k) && k !== ROW_VERSION_COLUMN)\n    .sort();\n}\n"],"mappings":";;;;;;;AAgBA,IAAa,qBAAqB;AAElC,IAAM,6BAA6B;;AAWnC,IAAa,mBAAmB,CAAA,MAAA,IAGhC;AAGA,SAAgB,oBAAoB,UAAkB,MAAsB;CAC1E,OAAO,6BAA6B,WAAW,MAAM;AACvD;AAEA,SAAgB,8BAA8B,UAA0B;CACtE,OAAO,6BAA6B,WAAW;AACjD;AAEA,SAAgB,gBAAgB,MAAsB;CACpD,OAAA,OAAgC;AAClC;AAEA,SAAgB,sBAAsB,KAAyB;CAC7D,OAAA,OAA8B,IAAI,WAAW,MAAM,IAAI;AACzD;AAEA,SAAgB,mBACd,WACA,YACA,OACQ;CACR,OAAO,OAAA,MAA4B,WAAW,YAAY,KAAK;AACjE;AAEA,SAAS,OACP,QACA,WACA,YACA,OACQ;CACR,IAAI,WAAW,WAAW,GACxB,OACE,SACA,YACA,MACAA,MAAQ,MAAM,WAAW,KAAK,qBAAqB;CAIvD,MAAM,SAAS,WAAW,KAAI,MAAKA,MAAQ,MAAM,IAAI,qBAAqB,CAAC;CAC3E,MAAM,MAAM,KAAK,UAAU,MAAM;CAEjC,MAAM,YAAY,cAAc,KAAK,GAAG,CAAC;CACzC,OAAO,SAAS,YAAY,MAAM;AACpC;AAEA,IAAM,MAAM,OAAO;;;;;;;;;;;AAYnB,SAAS,cAAc,GAAmB;CACxC,IAAI,IAAI,KACN,OAAO,OAAO,CAAC;CAEjB,MAAM,IAAI,IAAI;CACd,MAAM,MAAM,OAAO,IAAI,GAAG,CAAC,CAAC,SAAS,IAAI,GAAG;CAC5C,IAAI,IAAI,KACN,OAAO,OAAO,CAAC,IAAI;CAErB,OAAO,OAAO,IAAI,GAAG,IAAI,OAAO,IAAI,GAAG,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI;AAC/D;;;;;AAMA,SAAgB,kBAAkB,KAAqB;CAErD,MAAM,QAAQ,IAAI,QAAQ,KAAK,CAA0B;CACzD,MAAM,OAAO,IAAI,MAAM,GAA4B,KAAK;CACxD,OAAO,IAAI,WAAA,IAAgC,IACvC,yBAAyB,OACzB;AACN;;;;;;;;;;AAWA,SAAgB,gBAAgB,WAAmB,KAAkB;CACnE,MAAM,aAAa,uBAAuB,WAAW,GAAG;CACxD,OAAO,OAAA,MAEL,UAAU,MAAM,uBAAuB,MAAM,GAC7C,YACA,GACF;AACF;;;;;;;;;AAUA,SAAgB,uBAAuB,WAAmB,KAAoB;CAC5E,IAAI,0BAA0B,SAAS,GACrC,OAAO,CAAC,oBAAoB;CAE9B,OAAO,OAAO,KAAK,GAAG,CAAC,CACpB,QAAO,MAAK,CAAC,0BAA0B,IAAI,CAAC,KAAK,MAAA,YAAwB,CAAC,CAC1E,KAAK;AACV"}