@rocicorp/zero 1.10.0-canary.21 → 1.10.0-canary.23

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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/out/zero-protocol/src/query-hash-visitor.js

@@ -0,0 +1,324 @@
+import { unreachable } from "../../shared/src/asserts.js";
+import { PRIME32_1, PRIME32_5, avalanche32, round32 } from "../../shared/src/xxhash32.js";
+import "../../shared/src/hash.js";
+//#region ../zero-protocol/src/query-hash-visitor.ts
+var h1 = 0;
+var h2 = 0;
+/**
+* Fold one 32-bit word into both lanes.
+*
+* Both lanes run xxHash32's own round; only their starting values differ, so
+* they diverge immediately and stay diverged. That is the same construction
+* `h64` uses to widen xxHash32 past 32 bits, just fed words taken from a
+* structure rather than bytes taken from a string.
+*/
+function mix(w) {
+	h1 = round32(h1, w);
+	h2 = round32(h2, w);
+}
+/**
+* Fold a string, two UTF-16 units per word.
+*
+* The leading length keeps `['ab','c']` and `['a','bc']` apart. STR_MARK is
+* folded into that same word rather than mixed separately: it costs nothing,
+* and since every other count written by this file is a small array length, a
+* string can never fold like one.
+*/
+function mixString(s) {
+	const n = s.length;
+	mix(n | STR_MARK);
+	let i = 0;
+	for (; i + 1 < n; i += 2) mix(s.charCodeAt(i) | s.charCodeAt(i + 1) << 16);
+	if (i < n) mix(s.charCodeAt(i));
+}
+var numView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+/** Fold a number: one word for an int32, two for anything else. */
+function mixNumber(n) {
+	if ((n | 0) === n) mix(n);
+	else {
+		numView.setFloat64(0, n, true);
+		mix(numView.getInt32(0, true));
+		mix(numView.getInt32(4, true));
+	}
+}
+var TAG_NULL = 4097;
+var TAG_FALSE = 4098;
+var TAG_TRUE = 4099;
+var TAG_INT = 4100;
+var TAG_FLOAT = 4101;
+var TAG_ARR = 4103;
+var TAG_OBJ = 4104;
+var TAG_END = 4105;
+var TAG_UNDEF = 4106;
+var TAG_LITERAL = 8193;
+var TAG_COLUMN = 8194;
+var TAG_STATIC = 8195;
+var TAG_SIMPLE = 8196;
+var TAG_SUBQUERY = 8197;
+var TAG_AND = 8198;
+var TAG_OR = 8199;
+var TAG_FORMAT = 8200;
+var TAG_NAME_ARGS = 8201;
+var TAG_SYSTEM_PERMISSIONS = 8202;
+var TAG_SYSTEM_CLIENT = 8203;
+var TAG_SYSTEM_TEST = 8204;
+var TAG_JUNCTION = 8205;
+var STR_MARK = 1073741824;
+function reset() {
+	h1 = PRIME32_5;
+	h2 = PRIME32_1;
+}
+/** Collapse the two lanes into one 64-bit value, avalanching each first. */
+function finalize() {
+	return avalanche32(h1).toString(36).padStart(7, "0") + avalanche32(h2).toString(36).padStart(7, "0");
+}
+function visitValue(v) {
+	switch (typeof v) {
+		case "string":
+			mixString(v);
+			return;
+		case "number":
+			if (!Number.isFinite(v)) {
+				mix(TAG_NULL);
+				return;
+			}
+			mix((v | 0) === v ? TAG_INT : TAG_FLOAT);
+			mixNumber(v);
+			return;
+		case "boolean":
+			mix(v ? TAG_TRUE : TAG_FALSE);
+			return;
+		case "object": {
+			if (v === null) {
+				mix(TAG_NULL);
+				return;
+			}
+			if (Array.isArray(v)) {
+				mix(TAG_ARR);
+				for (let i = 0; i < v.length; i++) {
+					const e = v[i];
+					visitValue(e === void 0 ? null : e);
+				}
+				mix(TAG_END);
+				return;
+			}
+			mix(TAG_OBJ);
+			const keys = Object.keys(v).sort();
+			for (const k of keys) {
+				const val = v[k];
+				if (val === void 0) continue;
+				mixString(k);
+				visitValue(val);
+			}
+			mix(TAG_END);
+			return;
+		}
+		default: return;
+	}
+}
+function visitOptionalString(s) {
+	if (s === void 0) mix(TAG_UNDEF);
+	else mixString(s);
+}
+function mixOptionalSystem(system) {
+	if (system === void 0) mix(TAG_UNDEF);
+	else mixSystem(system);
+}
+function mixSystem(system) {
+	switch (system) {
+		case "permissions":
+			mix(TAG_SYSTEM_PERMISSIONS);
+			break;
+		case "client":
+			mix(TAG_SYSTEM_CLIENT);
+			break;
+		case "test":
+			mix(TAG_SYSTEM_TEST);
+			break;
+		default: unreachable(system);
+	}
+}
+function visitCompoundKey(k) {
+	mix(k.length);
+	for (let i = 0; i < k.length; i++) mixString(k[i]);
+}
+function visitOrdering(o) {
+	if (o === void 0) {
+		mix(TAG_UNDEF);
+		return;
+	}
+	mix(o.length);
+	for (let i = 0; i < o.length; i++) {
+		const [field, dir] = o[i];
+		mixString(field);
+		mix(dir === "asc" ? TAG_TRUE : TAG_FALSE);
+	}
+}
+function visitValuePosition(v) {
+	switch (v.type) {
+		case "literal":
+			mix(TAG_LITERAL);
+			visitValue(v.value);
+			return;
+		case "column":
+			mix(TAG_COLUMN);
+			mixString(v.name);
+			return;
+		case "static":
+			mix(TAG_STATIC);
+			mixString(v.anchor);
+			if (typeof v.field === "string") mixString(v.field);
+			else visitCompoundKey(v.field);
+			return;
+		default: unreachable(v);
+	}
+}
+function visitCondition(c) {
+	switch (c.type) {
+		case "simple":
+			mix(TAG_SIMPLE);
+			mixString(c.op);
+			visitValuePosition(c.left);
+			visitValuePosition(c.right);
+			return;
+		case "correlatedSubquery":
+			mix(TAG_SUBQUERY);
+			mixString(c.op);
+			mix(c.flip === void 0 ? TAG_UNDEF : c.flip ? TAG_TRUE : TAG_FALSE);
+			mix(c.scalar === void 0 ? TAG_UNDEF : c.scalar ? TAG_TRUE : TAG_FALSE);
+			visitCorrelatedSubquery(c.related);
+			return;
+		default: {
+			c.type;
+			mix(c.type === "and" ? TAG_AND : TAG_OR);
+			const conds = c.conditions;
+			mix(conds.length);
+			for (let i = 0; i < conds.length; i++) visitCondition(conds[i]);
+			return;
+		}
+	}
+}
+function visitCorrelatedSubquery(csq) {
+	visitCompoundKey(csq.correlation.parentField);
+	visitCompoundKey(csq.correlation.childField);
+	mix(csq.hidden === void 0 ? TAG_UNDEF : csq.hidden ? TAG_TRUE : TAG_FALSE);
+	mixOptionalSystem(csq.system);
+	visitAST(csq.subquery);
+}
+function visitAST(ast) {
+	mix(TAG_OBJ);
+	visitOptionalString(ast.schema);
+	mixString(ast.table);
+	visitOptionalString(ast.alias);
+	if (ast.where === void 0) mix(TAG_UNDEF);
+	else visitCondition(ast.where);
+	const related = ast.related;
+	if (related === void 0) mix(TAG_UNDEF);
+	else {
+		mix(related.length);
+		for (let i = 0; i < related.length; i++) visitCorrelatedSubquery(related[i]);
+	}
+	const start = ast.start;
+	if (start === void 0) mix(TAG_UNDEF);
+	else {
+		mix(start.exclusive ? TAG_TRUE : TAG_FALSE);
+		visitValue(start.row);
+	}
+	if (ast.limit === void 0) mix(TAG_UNDEF);
+	else {
+		mix(TAG_INT);
+		mixNumber(ast.limit);
+	}
+	visitOrdering(ast.orderBy);
+	mix(TAG_END);
+}
+function hashAST(ast) {
+	const s1 = h1;
+	const s2 = h2;
+	try {
+		reset();
+		visitAST(ast);
+		return finalize();
+	} finally {
+		h1 = s1;
+		h2 = s2;
+	}
+}
+/**
+* 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.
+*/
+function hashNameAndArgs(name, args) {
+	const s1 = h1;
+	const s2 = h2;
+	try {
+		reset();
+		mix(TAG_NAME_ARGS);
+		mixString(name);
+		visitValue(args);
+		return finalize();
+	} finally {
+		h1 = s1;
+		h2 = s2;
+	}
+}
+/**
+* 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.
+*/
+function hashOfQueryInternals(ast, format, system, currentJunction, customQueryName, customQueryArgs) {
+	const s1 = h1;
+	const s2 = h2;
+	try {
+		reset();
+		visitAST(ast);
+		mix(TAG_FORMAT);
+		visitValue(format);
+		mixSystem(system);
+		if (currentJunction === void 0) mix(TAG_UNDEF);
+		else {
+			mix(TAG_JUNCTION);
+			mixString(currentJunction);
+		}
+		if (customQueryName === void 0) mix(TAG_UNDEF);
+		else {
+			mix(TAG_NAME_ARGS);
+			mixString(customQueryName);
+			visitValue(customQueryArgs);
+		}
+		return finalize();
+	} finally {
+		h1 = s1;
+		h2 = s2;
+	}
+}
+//#endregion
+export { hashAST, hashNameAndArgs, hashOfQueryInternals };
+
+//# sourceMappingURL=query-hash-visitor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-hash-visitor.js","names":[],"sources":["../../../../zero-protocol/src/query-hash-visitor.ts"],"sourcesContent":["import {unreachable} from '../../shared/src/asserts.ts';\n// These live in shared/src/xxhash32.ts, imported via hash.ts's re-export\n// rather than directly: the direct zero-protocol -> shared/xxhash32.ts edge\n// makes tsc 7.0.2 mis-evaluate Query-type relations in other programs --\n// phantom TS2345s in zql's runnable-query-impl.ts under the packages/zero\n// declaration build, and zero-client silently losing the type error that\n// custom.test.ts pins with a ts-expect-error directive. Bisected cold-cache\n// to that one import statement; the hash.ts route checks clean everywhere.\n// Collapse to a direct import when TypeScript is upgraded past this.\nimport {\n  avalanche32,\n  PRIME32_1,\n  PRIME32_5,\n  round32,\n} from '../../shared/src/hash.ts';\nimport type {Format} from '../../zero-types/src/format.ts';\n\n/**\n * Hashes a normalized AST by visiting it, rather than by rendering it to JSON\n * and hashing the bytes. `hashOfAST` and `hashOfNameAndArgs` in\n * `query-hash.ts` are both built on this, so these digests are the query IDs\n * the client registers and the transformation hashes the server stores.\n *\n * The pipeline this replaced was\n * `h64(JSON.stringify(normalizeAST(ast))).toString(36)`, which materialized\n * the whole AST as a string, UTF-8 encoded it, and only then hashed it — three\n * passes over the data, two of which existed purely to produce bytes to hash.\n *\n * A visitor can fold values into the hash state as it walks, so nothing is\n * materialized at all. The primitives that make that pay off:\n *\n * - Two 32-bit accumulators held in module-level `let`s, so the \"state\" is\n *   plain numbers in registers rather than an object being threaded through\n *   the walk.\n * - xxHash32's own round and final mix, shared with `shared/src/hash.ts` via\n *   `shared/src/xxhash32.ts`. Only the ingestion differs: that one feeds them\n *   UTF-8 bytes, this one feeds them words straight out of the structure.\n * - Strings folded straight from `charCodeAt`, two UTF-16 units at a time, into\n *   one 32-bit word. No UTF-8 encoding, and half the loop iterations a\n *   byte-oriented hash would need over ASCII.\n *\n * These digests do not agree with xxHash32 over the old JSON encoding, and are\n * not meant to: nothing recomputes a hash produced elsewhere and compares it,\n * so the encoding is free to change as long as every writer moves together.\n * What it does have to give is distinct words for structurally distinct\n * queries — a 64-bit digest cannot promise that absolutely, but every field\n * and node kind must at least reach the mixer, and no two of them may be\n * written so as to be confusable. `query-hash-visitor.test.ts` holds that\n * line with a corpus and a per-field mutation test.\n *\n * The walk is deliberately specialized to the AST shape rather than written as\n * a generic JSON-value walk. That is not premature: a generic version was\n * measured alongside this one and came out ~2.4x slower, no better than the\n * `JSON.stringify` it was meant to replace, because `for...in` and the\n * megamorphic property loads cost about what the native stringify costs. Only\n * `visitValue` below stays generic, for the two places an AST holds arbitrary\n * JSON: a literal's value and a bound's row.\n */\nimport type {\n  AST,\n  Condition,\n  CorrelatedSubquery,\n  Ordering,\n  System,\n  ValuePosition,\n} from './ast.ts';\n\n// Two 32-bit lanes, combined into 64 bits at the end. Module-level so the walk\n// mutates registers rather than allocating or threading state through it.\nlet h1 = 0;\nlet h2 = 0;\n\n/**\n * Fold one 32-bit word into both lanes.\n *\n * Both lanes run xxHash32's own round; only their starting values differ, so\n * they diverge immediately and stay diverged. That is the same construction\n * `h64` uses to widen xxHash32 past 32 bits, just fed words taken from a\n * structure rather than bytes taken from a string.\n */\nfunction mix(w: number): void {\n  h1 = round32(h1, w);\n  h2 = round32(h2, w);\n}\n\n/**\n * Fold a string, two UTF-16 units per word.\n *\n * The leading length keeps `['ab','c']` and `['a','bc']` apart. STR_MARK is\n * folded into that same word rather than mixed separately: it costs nothing,\n * and since every other count written by this file is a small array length, a\n * string can never fold like one.\n */\nfunction mixString(s: string): void {\n  const n = s.length;\n  mix(n | STR_MARK);\n  let i = 0;\n  for (; i + 1 < n; i += 2) {\n    mix(s.charCodeAt(i) | (s.charCodeAt(i + 1) << 16));\n  }\n  if (i < n) {\n    mix(s.charCodeAt(i));\n  }\n}\n\n// A DataView with an explicit byte order, not a Float64Array/Int32Array\n// aliasing pair: typed arrays read the buffer in host byte order, and these\n// digests are persisted, so a big-endian runtime would fold a float's words\n// swapped and disagree with every little-endian peer.\nconst numView = new DataView(new ArrayBuffer(8));\n\n/** Fold a number: one word for an int32, two for anything else. */\nfunction mixNumber(n: number): void {\n  if ((n | 0) === n) {\n    mix(n);\n  } else {\n    numView.setFloat64(0, n, true);\n    mix(numView.getInt32(0, true));\n    mix(numView.getInt32(4, true));\n  }\n}\n\n// Structural tags. Distinct constants so that, say, a string \"1\" and the\n// number 1 cannot fold to the same state.\nconst TAG_NULL = 0x1001;\nconst TAG_FALSE = 0x1002;\nconst TAG_TRUE = 0x1003;\nconst TAG_INT = 0x1004;\nconst TAG_FLOAT = 0x1005;\nconst TAG_ARR = 0x1007;\nconst TAG_OBJ = 0x1008;\nconst TAG_END = 0x1009;\nconst TAG_UNDEF = 0x100a;\n\n// Discriminators for the AST's own unions, kept distinct from the value tags\n// above so a node kind can never fold like a value of some other type.\nconst TAG_LITERAL = 0x2001;\nconst TAG_COLUMN = 0x2002;\nconst TAG_STATIC = 0x2003;\nconst TAG_SIMPLE = 0x2004;\nconst TAG_SUBQUERY = 0x2005;\nconst TAG_AND = 0x2006;\nconst TAG_OR = 0x2007;\nconst TAG_FORMAT = 0x2008;\nconst TAG_NAME_ARGS = 0x2009;\n// `System` is a closed set of three, so it folds as one word rather than as a\n// string -- on an AST it appears once per correlated subquery, so this is on\n// the walk's hot path. The switch below is exhaustive, so adding a member is a\n// type error rather than a silent collision with an existing one.\nconst TAG_SYSTEM_PERMISSIONS = 0x200a;\nconst TAG_SYSTEM_CLIENT = 0x200b;\nconst TAG_SYSTEM_TEST = 0x200c;\nconst TAG_JUNCTION = 0x200d;\n\n// Set on a string's length word. High enough that no array length reaches it.\nconst STR_MARK = 0x40000000;\n\nfunction reset(): void {\n  h1 = PRIME32_5;\n  h2 = PRIME32_1;\n}\n\n/** Collapse the two lanes into one 64-bit value, avalanching each first. */\nfunction finalize(): string {\n  return (\n    avalanche32(h1).toString(36).padStart(7, '0') +\n    avalanche32(h2).toString(36).padStart(7, '0')\n  );\n}\n\n// ---------------------------------------------------------------------------\n// The generic part: arbitrary JSON, for literal values and bound rows.\n// ---------------------------------------------------------------------------\n\nfunction visitValue(v: unknown): void {\n  switch (typeof v) {\n    case 'string':\n      mixString(v);\n      return;\n    case 'number':\n      // NaN and Infinity are null by the time they reach the wire, because\n      // that is what JSON.stringify writes for them. Two queries identical on\n      // the wire must not get different IDs.\n      if (!Number.isFinite(v)) {\n        mix(TAG_NULL);\n        return;\n      }\n      mix((v | 0) === v ? TAG_INT : TAG_FLOAT);\n      mixNumber(v);\n      return;\n    case 'boolean':\n      mix(v ? TAG_TRUE : TAG_FALSE);\n      return;\n    case 'object': {\n      if (v === null) {\n        mix(TAG_NULL);\n        return;\n      }\n      if (Array.isArray(v)) {\n        mix(TAG_ARR);\n        for (let i = 0; i < v.length; i++) {\n          // An `undefined` element is `null` by the time it reaches the wire,\n          // because that is what JSON.stringify makes of it. Dropping it\n          // instead would fold `[undefined]` onto `[]`.\n          const e: unknown = v[i];\n          visitValue(e === undefined ? null : e);\n        }\n        mix(TAG_END);\n        return;\n      }\n      mix(TAG_OBJ);\n      // Sorted, so the digest is a function of the object's contents and not\n      // of its key order. Rows and custom-query args round-trip through\n      // Postgres JSONB, which reorders keys; an order-sensitive digest made\n      // reloaded query records look changed. (The AST's own fields don't need\n      // this: visitAST reads them in a fixed order by name.)\n      const keys = Object.keys(v).sort();\n      for (const k of keys) {\n        const val = (v as Record<string, unknown>)[k];\n        if (val === undefined) {\n          continue; // as JSON.stringify does\n        }\n        mixString(k);\n        visitValue(val);\n      }\n      mix(TAG_END);\n      return;\n    }\n    default:\n      // `undefined` and functions as an object's value: dropped, as\n      // JSON.stringify drops them. Array elements are handled above.\n      return;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// The specialized part: the AST's own shape.\n// ---------------------------------------------------------------------------\n\nfunction visitOptionalString(s: string | undefined): void {\n  if (s === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mixString(s);\n  }\n}\n\nfunction mixOptionalSystem(system: System | undefined): void {\n  if (system === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mixSystem(system);\n  }\n}\n\nfunction mixSystem(system: System): void {\n  switch (system) {\n    case 'permissions':\n      mix(TAG_SYSTEM_PERMISSIONS);\n      break;\n    case 'client':\n      mix(TAG_SYSTEM_CLIENT);\n      break;\n    case 'test':\n      mix(TAG_SYSTEM_TEST);\n      break;\n    default:\n      unreachable(system);\n  }\n}\n\nfunction visitCompoundKey(k: readonly string[]): void {\n  mix(k.length);\n  for (let i = 0; i < k.length; i++) {\n    mixString(k[i]);\n  }\n}\n\nfunction visitOrdering(o: Ordering | undefined): void {\n  if (o === undefined) {\n    mix(TAG_UNDEF);\n    return;\n  }\n  mix(o.length);\n  for (let i = 0; i < o.length; i++) {\n    const [field, dir] = o[i];\n    mixString(field);\n    mix(dir === 'asc' ? TAG_TRUE : TAG_FALSE);\n  }\n}\n\nfunction visitValuePosition(v: ValuePosition): void {\n  switch (v.type) {\n    case 'literal':\n      mix(TAG_LITERAL);\n      visitValue(v.value);\n      return;\n    case 'column':\n      mix(TAG_COLUMN);\n      mixString(v.name);\n      return;\n    case 'static': {\n      mix(TAG_STATIC);\n      mixString(v.anchor);\n      if (typeof v.field === 'string') {\n        mixString(v.field);\n      } else {\n        visitCompoundKey(v.field);\n      }\n      return;\n    }\n    default:\n      unreachable(v);\n  }\n}\n\nfunction visitCondition(c: Condition): void {\n  switch (c.type) {\n    case 'simple':\n      mix(TAG_SIMPLE);\n      mixString(c.op);\n      visitValuePosition(c.left);\n      visitValuePosition(c.right);\n      return;\n    case 'correlatedSubquery':\n      mix(TAG_SUBQUERY);\n      mixString(c.op);\n      mix(c.flip === undefined ? TAG_UNDEF : c.flip ? TAG_TRUE : TAG_FALSE);\n      mix(c.scalar === undefined ? TAG_UNDEF : c.scalar ? TAG_TRUE : TAG_FALSE);\n      visitCorrelatedSubquery(c.related);\n      return;\n    default: {\n      c.type satisfies 'and' | 'or';\n      mix(c.type === 'and' ? TAG_AND : TAG_OR);\n      const conds = c.conditions;\n      mix(conds.length);\n      for (let i = 0; i < conds.length; i++) {\n        visitCondition(conds[i]);\n      }\n      return;\n    }\n  }\n}\n\nfunction visitCorrelatedSubquery(csq: CorrelatedSubquery): void {\n  visitCompoundKey(csq.correlation.parentField);\n  visitCompoundKey(csq.correlation.childField);\n  mix(csq.hidden === undefined ? TAG_UNDEF : csq.hidden ? TAG_TRUE : TAG_FALSE);\n  mixOptionalSystem(csq.system);\n  visitAST(csq.subquery);\n}\n\nfunction visitAST(ast: AST): void {\n  mix(TAG_OBJ);\n  visitOptionalString(ast.schema);\n  mixString(ast.table);\n  visitOptionalString(ast.alias);\n\n  if (ast.where === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    visitCondition(ast.where);\n  }\n\n  const related = ast.related;\n  if (related === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mix(related.length);\n    for (let i = 0; i < related.length; i++) {\n      visitCorrelatedSubquery(related[i]);\n    }\n  }\n\n  const start = ast.start;\n  if (start === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    mix(start.exclusive ? TAG_TRUE : TAG_FALSE);\n    visitValue(start.row);\n  }\n\n  if (ast.limit === undefined) {\n    mix(TAG_UNDEF);\n  } else {\n    // Tagged, because this is the one optional field whose present and absent\n    // forms would otherwise both write a single bare word: an untagged\n    // `limit: 4106` is the same word as TAG_UNDEF. The other optionals are\n    // safe -- a present string carries STR_MARK, a condition or bound leads\n    // with its own kind tag, and `related`/`orderBy` write a count followed by\n    // that many items, so their streams diverge straight after.\n    mix(TAG_INT);\n    mixNumber(ast.limit);\n  }\n\n  visitOrdering(ast.orderBy);\n  mix(TAG_END);\n}\n\nexport function hashAST(ast: AST): string {\n  // Save and restore the lanes: `visitValue` reads properties of arbitrary\n  // runtime objects, and a getter is free to ask for another hash mid-walk.\n  // Without this, the inner call's reset() would corrupt the outer digest.\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    visitAST(ast);\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n\n/**\n * The identity of a custom query: its name and its arguments.\n *\n * Same walk, entered at a different node. `args` is arbitrary JSON, which is\n * what `visitValue` already exists to handle. The leading tag keeps this hash\n * space disjoint from `hashAST`'s -- both produce query IDs that live in the\n * same namespace, so an AST must not be able to fold to the same words as some\n * name and args.\n */\nexport function hashNameAndArgs(\n  name: string,\n  args: readonly unknown[],\n): string {\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    mix(TAG_NAME_ARGS);\n    mixString(name);\n    visitValue(args);\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n\n/**\n * The identity of a query as the client sees it: its AST, the shape it returns,\n * the system it was built for, and -- for a custom query -- the name and\n * arguments it was declared with.\n *\n * Everything past the AST is here because it is part of what makes two queries\n * different while leaving no trace, or an incomplete one, in the AST itself:\n *\n * - **name and args**: `nameAndArgs` reuses the AST it is given and only\n *   attaches a `CustomQueryID`, so without these two different named queries\n *   over the same table would be indistinguishable.\n * - **system**: a query stamps it onto every `related` entry and every `exists`\n *   correlation it builds, so it is already hashed via\n *   {@link visitCorrelatedSubquery} -- but a query with neither has nowhere to\n *   put it, and would otherwise hash the same whether it was built for the\n *   client or for permissions.\n * - **currentJunction**: builder state, set on the sub-query handed to a\n *   two-hop relationship's callback, which makes `limit` and `orderBy` throw.\n *   It leaves no trace in the AST at all, so two queries that differ only in\n *   whether those methods work would otherwise be indistinguishable.\n *\n * The name and args are taken apart rather than as a `CustomQueryID` because\n * that type lives in `zql`, which is above this package; `hashNameAndArgs`\n * splits them the same way.\n */\nexport function hashOfQueryInternals(\n  ast: AST,\n  format: Format,\n  system: System,\n  currentJunction: string | undefined,\n  customQueryName: string | undefined,\n  customQueryArgs: readonly unknown[] | undefined,\n): string {\n  const s1 = h1;\n  const s2 = h2;\n  try {\n    reset();\n    visitAST(ast);\n    mix(TAG_FORMAT);\n    visitValue(format);\n    mixSystem(system);\n    if (currentJunction === undefined) {\n      mix(TAG_UNDEF);\n    } else {\n      mix(TAG_JUNCTION);\n      mixString(currentJunction);\n    }\n    if (customQueryName === undefined) {\n      mix(TAG_UNDEF);\n    } else {\n      mix(TAG_NAME_ARGS);\n      mixString(customQueryName);\n      visitValue(customQueryArgs);\n    }\n    return finalize();\n  } finally {\n    h1 = s1;\n    h2 = s2;\n  }\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,9 @@
-import { type AST } from './ast.ts';
+import { type AST, type NormalizedAST } from './ast.ts';
 export declare function hashOfAST(ast: AST): string;
-export declare function hashOfNameAndArgs(name: string, args: readonly unknown[]): string;
+/**
+ * The hash of an AST that is already normalized, e.g. the AST of a query
+ * whose builder kept it normalized as it built it.
+ */
+export declare function hashOfNormalizedAST(ast: NormalizedAST): string;
+export { hashNameAndArgs as hashOfNameAndArgs } from './query-hash-visitor.ts';
 //# sourceMappingURL=query-hash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"query-hash.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,GAAG,EAAC,MAAM,UAAU,CAAC;AAIhD,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAS1C;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB,MAAM,CAGR"}
+{"version":3,"file":"query-hash.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/query-hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,GAAG,EAAE,KAAK,aAAa,EAAC,MAAM,UAAU,CAAC;AAKpE,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAE1C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAQ9D;AAED,OAAO,EAAC,eAAe,IAAI,iBAAiB,EAAC,MAAM,yBAAyB,CAAC"}

package/out/zero-protocol/src/query-hash.js

@@ -1,19 +1,22 @@
 import { normalizeAST } from "./ast.js";
-import { h64 } from "../../shared/src/hash.js";
+import { hashAST } from "./query-hash-visitor.js";
 //#region ../zero-protocol/src/query-hash.ts
 var hashCache = /* @__PURE__ */ new WeakMap();
 function hashOfAST(ast) {
-	const normalized = normalizeAST(ast);
-	const cached = hashCache.get(normalized);
+	return hashOfNormalizedAST(normalizeAST(ast));
+}
+/**
+* The hash of an AST that is already normalized, e.g. the AST of a query
+* whose builder kept it normalized as it built it.
+*/
+function hashOfNormalizedAST(ast) {
+	const cached = hashCache.get(ast);
 	if (cached) return cached;
-	const hash = h64(JSON.stringify(normalized)).toString(36);
-	hashCache.set(normalized, hash);
+	const hash = hashAST(ast);
+	hashCache.set(ast, hash);
 	return hash;
 }
-function hashOfNameAndArgs(name, args) {
-	return h64(`${name}:${JSON.stringify(args)}`).toString(36);
-}
 //#endregion
-export { hashOfAST, hashOfNameAndArgs };
+export { hashOfAST };
 
 //# sourceMappingURL=query-hash.js.map

package/out/zero-protocol/src/query-hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"query-hash.js","names":[],"sources":["../../../../zero-protocol/src/query-hash.ts"],"sourcesContent":["import {h64} from '../../shared/src/hash.ts';\nimport {normalizeAST, type AST} from './ast.ts';\n\nconst hashCache = new WeakMap<AST, string>();\n\nexport function hashOfAST(ast: AST): string {\n  const normalized = normalizeAST(ast);\n  const cached = hashCache.get(normalized);\n  if (cached) {\n    return cached;\n  }\n  const hash = h64(JSON.stringify(normalized)).toString(36);\n  hashCache.set(normalized, hash);\n  return hash;\n}\n\nexport function hashOfNameAndArgs(\n  name: string,\n  args: readonly unknown[],\n): string {\n  const argsString = JSON.stringify(args);\n  return h64(`${name}:${argsString}`).toString(36);\n}\n"],"mappings":";;;AAGA,IAAM,4BAAY,IAAI,QAAqB;AAE3C,SAAgB,UAAU,KAAkB;CAC1C,MAAM,aAAa,aAAa,GAAG;CACnC,MAAM,SAAS,UAAU,IAAI,UAAU;CACvC,IAAI,QACF,OAAO;CAET,MAAM,OAAO,IAAI,KAAK,UAAU,UAAU,CAAC,EAAE,SAAS,EAAE;CACxD,UAAU,IAAI,YAAY,IAAI;CAC9B,OAAO;AACT;AAEA,SAAgB,kBACd,MACA,MACQ;CAER,OAAO,IAAI,GAAG,KAAK,GADA,KAAK,UAAU,IACZ,GAAY,EAAE,SAAS,EAAE;AACjD"}
+{"version":3,"file":"query-hash.js","names":[],"sources":["../../../../zero-protocol/src/query-hash.ts"],"sourcesContent":["import {normalizeAST, type AST, type NormalizedAST} from './ast.ts';\nimport {hashAST} from './query-hash-visitor.ts';\n\nconst hashCache = new WeakMap<AST, string>();\n\nexport function hashOfAST(ast: AST): string {\n  return hashOfNormalizedAST(normalizeAST(ast));\n}\n\n/**\n * The hash of an AST that is already normalized, e.g. the AST of a query\n * whose builder kept it normalized as it built it.\n */\nexport function hashOfNormalizedAST(ast: NormalizedAST): string {\n  const cached = hashCache.get(ast);\n  if (cached) {\n    return cached;\n  }\n  const hash = hashAST(ast);\n  hashCache.set(ast, hash);\n  return hash;\n}\n\nexport {hashNameAndArgs as hashOfNameAndArgs} from './query-hash-visitor.ts';\n"],"mappings":";;;AAGA,IAAM,4BAAY,IAAI,QAAqB;AAE3C,SAAgB,UAAU,KAAkB;CAC1C,OAAO,oBAAoB,aAAa,GAAG,CAAC;AAC9C;;;;;AAMA,SAAgB,oBAAoB,KAA4B;CAC9D,MAAM,SAAS,UAAU,IAAI,GAAG;CAChC,IAAI,QACF,OAAO;CAET,MAAM,OAAO,QAAQ,GAAG;CACxB,UAAU,IAAI,KAAK,IAAI;CACvB,OAAO;AACT"}

package/out/zero-react/src/use-query.d.ts

@@ -25,10 +25,11 @@ export type UseSuspenseQueryOptions = UseQueryOptions & {
      * Whether to suspend until:
      * - 'partial': the query has partial results (partial array or defined
      *   value for singular results) which may be of result type 'unknown',
-     *   or the query result type is 'complete' (in which case results may be
-     *   empty).  This is useful for suspending until there are partial
-     *   optimistic local results, or the query has completed loading from the
-     *   server.
+     *   or the query result type is 'complete' or 'cached' (in which case
+     *   results may be empty: a server-confirmed empty answer, from this
+     *   connection or a previous one, is something to render). This is useful
+     *   for suspending until there are partial optimistic local results, or
+     *   the query has completed loading from the server.
      * - 'complete': the query result type is 'complete'.
      *
      * Default is 'partial'.

package/out/zero-react/src/use-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-query.d.ts","sourceRoot":"","sources":["../../../../zero-react/src/use-query.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-query.d.ts","sourceRoot":"","sources":["../../../../zero-react/src/use-query.tsx"],"names":[],"mappings":"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"}