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

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

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

@@ -1 +0,0 @@
-{"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/zql/src/builder/correlated-predicate-pushdown.d.ts

@@ -1,43 +0,0 @@
-import type { AST, SimpleCondition } from '../../../zero-protocol/src/ast.ts';
-import type { SchemaValue } from '../../../zero-types/src/schema-value.ts';
-/**
- * The longest `IN` list that is copied into a child. `IN` compiles to
- * `IN (SELECT value FROM json_each(?))`, and every per-parent fetch of the
- * child carries the whole list.
- */
-export declare const MAX_PUSHED_IN_VALUES = 32;
-/**
- * Copies a parent's condition on a correlation column into the child
- * subquery, renamed to the matching child column. For example,
- * `user.where('user_id', X).related('reading')` becomes
- * `user.where('user_id', X).related('reading', r => r.where('user_id', X))`.
- *
- * The result is the same. Only child rows that cannot join to a parent that
- * matters are removed. But a push that climbs the tree then fetches parents
- * with SQL that includes the ancestor's condition, and a change to a child row
- * that cannot match stops at the child's source.
- *
- * Conditions are copied only when they are true for every parent row where
- * the edge can affect the result:
- * - for `related`, the top-level AND conjuncts of the parent's `where`;
- * - for EXISTS and NOT EXISTS, the conjuncts of every AND on the path from
- *   the root of `where` to the subquery condition. An OR adds no facts.
- *
- * A condition is copied when it is `column = literal`, `column IS literal`, or
- * `column IN literal-list` (at most {@link MAX_PUSHED_IN_VALUES} values), the
- * column is a `parentField` of the correlation, and the parent and child
- * columns have the same Zero type, which is not `json`.
- *
- * A condition is not copied when the child already has the same condition as
- * a conjunct. So the pass does not change an AST that it already pushed.
- *
- * Does not change its input. Returns the same object for every part of the
- * AST that it does not change.
- *
- * @param pushed When given, receives each child conjunct that is a copy of a
- * parent condition: the copies that the pass adds, and the child's own
- * conjuncts that equal a copy. The parent's condition implies each of them
- * wherever the join binds its column, so the planner ignores them there.
- */
-export declare function pushDownCorrelatedPredicates(ast: AST, columnsOf: (table: string) => Record<string, SchemaValue>, pushed?: Set<SimpleCondition> | undefined): AST;
-//# sourceMappingURL=correlated-predicate-pushdown.d.ts.map

package/out/zql/src/builder/correlated-predicate-pushdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"correlated-predicate-pushdown.d.ts","sourceRoot":"","sources":["../../../../../zql/src/builder/correlated-predicate-pushdown.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,GAAG,EAIH,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yCAAyC,CAAC;AAGzE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAMvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACzD,MAAM,CAAC,EAAE,GAAG,CAAC,eAAe,CAAC,GAAG,SAAS,GACxC,GAAG,CAyGL"}

package/out/zql/src/builder/correlated-predicate-pushdown.js

@@ -1,161 +0,0 @@
-import { deepEqual } from "../../../shared/src/json.js";
-import { simplifyCondition } from "../query/expression.js";
-/**
-* Copies a parent's condition on a correlation column into the child
-* subquery, renamed to the matching child column. For example,
-* `user.where('user_id', X).related('reading')` becomes
-* `user.where('user_id', X).related('reading', r => r.where('user_id', X))`.
-*
-* The result is the same. Only child rows that cannot join to a parent that
-* matters are removed. But a push that climbs the tree then fetches parents
-* with SQL that includes the ancestor's condition, and a change to a child row
-* that cannot match stops at the child's source.
-*
-* Conditions are copied only when they are true for every parent row where
-* the edge can affect the result:
-* - for `related`, the top-level AND conjuncts of the parent's `where`;
-* - for EXISTS and NOT EXISTS, the conjuncts of every AND on the path from
-*   the root of `where` to the subquery condition. An OR adds no facts.
-*
-* A condition is copied when it is `column = literal`, `column IS literal`, or
-* `column IN literal-list` (at most {@link MAX_PUSHED_IN_VALUES} values), the
-* column is a `parentField` of the correlation, and the parent and child
-* columns have the same Zero type, which is not `json`.
-*
-* A condition is not copied when the child already has the same condition as
-* a conjunct. So the pass does not change an AST that it already pushed.
-*
-* Does not change its input. Returns the same object for every part of the
-* AST that it does not change.
-*
-* @param pushed When given, receives each child conjunct that is a copy of a
-* parent condition: the copies that the pass adds, and the child's own
-* conjuncts that equal a copy. The parent's condition implies each of them
-* wherever the join binds its column, so the planner ignores them there.
-*/
-function pushDownCorrelatedPredicates(ast, columnsOf, pushed) {
-	function visit(ast) {
-		const where = ast.where && visitCondition(ast.where, ast.table, []);
-		const facts = where ? simpleConjuncts(where) : [];
-		const related = ast.related && mapShared(ast.related, (csq) => {
-			const subquery = visit(pushInto(csq, facts, ast.table));
-			return subquery === csq.subquery ? csq : {
-				...csq,
-				subquery
-			};
-		});
-		if (where === ast.where && related === ast.related) return ast;
-		return {
-			...ast,
-			where,
-			related
-		};
-	}
-	function visitCondition(c, table, facts) {
-		switch (c.type) {
-			case "simple": return c;
-			case "and": return visitConjunction(c, table, [...facts, ...simpleConjuncts(c)]);
-			case "or": {
-				const conditions = mapShared(c.conditions, (x) => visitCondition(x, table, facts));
-				return conditions === c.conditions ? c : {
-					...c,
-					conditions
-				};
-			}
-			case "correlatedSubquery": {
-				const subquery = visit(pushInto(c.related, facts, table));
-				return subquery === c.related.subquery ? c : {
-					...c,
-					related: {
-						...c.related,
-						subquery
-					}
-				};
-			}
-		}
-	}
-	function visitConjunction(c, table, facts) {
-		const conditions = mapShared(c.conditions, (x) => x.type === "and" ? visitConjunction(x, table, facts) : visitCondition(x, table, facts));
-		return conditions === c.conditions ? c : {
-			...c,
-			conditions
-		};
-	}
-	function pushInto(csq, facts, parentTable) {
-		const { parentField, childField } = csq.correlation;
-		const { subquery } = csq;
-		const conjuncts = subquery.where ? simpleConjuncts(subquery.where) : [];
-		const added = [];
-		for (const fact of facts) {
-			if (!isPushable(fact)) continue;
-			for (let i = 0; i < parentField.length; i++) if (parentField[i] === fact.left.name && haveSameScalarType(columnsOf(parentTable)[parentField[i]], columnsOf(subquery.table)[childField[i]])) {
-				const copy = {
-					...fact,
-					left: {
-						type: "column",
-						name: childField[i]
-					}
-				};
-				const same = conjuncts.find((c) => isSameCondition(c, copy));
-				if (same) pushed?.add(same);
-				else {
-					conjuncts.push(copy);
-					added.push(copy);
-					pushed?.add(copy);
-				}
-			}
-		}
-		if (added.length === 0) return subquery;
-		return {
-			...subquery,
-			where: simplifyCondition({
-				type: "and",
-				conditions: subquery.where ? [subquery.where, ...added] : added
-			})
-		};
-	}
-	return visit(ast);
-}
-/**
-* The simple conditions that are conjuncts of `c`, including those of ANDs
-* nested in ANDs.
-*/
-function simpleConjuncts(c) {
-	switch (c.type) {
-		case "simple": return [c];
-		case "and": return c.conditions.flatMap(simpleConjuncts);
-		default: return [];
-	}
-}
-function isPushable(c) {
-	if (c.left.type !== "column" || c.right.type !== "literal") return false;
-	switch (c.op) {
-		case "=":
-		case "IS": return true;
-		case "IN": return Array.isArray(c.right.value) && c.right.value.length <= 32;
-		default: return false;
-	}
-}
-function isSameCondition(a, b) {
-	return a.op === b.op && a.left.type === "column" && b.left.type === "column" && a.left.name === b.left.name && a.right.type === "literal" && b.right.type === "literal" && deepEqual(a.right.value, b.right.value);
-}
-function haveSameScalarType(parent, child) {
-	return parent !== void 0 && child !== void 0 && parent.type === child.type && parent.type !== "json";
-}
-/**
-* Like `Array.prototype.map`, but returns `arr` itself when `f` returns every
-* element unchanged.
-*/
-function mapShared(arr, f) {
-	let result;
-	for (let i = 0; i < arr.length; i++) {
-		const x = f(arr[i]);
-		if (result === void 0 && x !== arr[i]) result = arr.slice(0, i);
-		result?.push(x);
-	}
-	return result ?? arr;
-}
-//#endregion
-export { pushDownCorrelatedPredicates };
-
-//# sourceMappingURL=correlated-predicate-pushdown.js.map

package/out/zql/src/builder/correlated-predicate-pushdown.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"correlated-predicate-pushdown.js","names":[],"sources":["../../../../../zql/src/builder/correlated-predicate-pushdown.ts"],"sourcesContent":["import {deepEqual} from '../../../shared/src/json.ts';\nimport type {\n  AST,\n  Condition,\n  Conjunction,\n  CorrelatedSubquery,\n  SimpleCondition,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {SchemaValue} from '../../../zero-types/src/schema-value.ts';\nimport {simplifyCondition} from '../query/expression.ts';\n\n/**\n * The longest `IN` list that is copied into a child. `IN` compiles to\n * `IN (SELECT value FROM json_each(?))`, and every per-parent fetch of the\n * child carries the whole list.\n */\nexport const MAX_PUSHED_IN_VALUES = 32;\n\ntype ColumnCondition = SimpleCondition & {\n  readonly left: {readonly type: 'column'; readonly name: string};\n};\n\n/**\n * Copies a parent's condition on a correlation column into the child\n * subquery, renamed to the matching child column. For example,\n * `user.where('user_id', X).related('reading')` becomes\n * `user.where('user_id', X).related('reading', r => r.where('user_id', X))`.\n *\n * The result is the same. Only child rows that cannot join to a parent that\n * matters are removed. But a push that climbs the tree then fetches parents\n * with SQL that includes the ancestor's condition, and a change to a child row\n * that cannot match stops at the child's source.\n *\n * Conditions are copied only when they are true for every parent row where\n * the edge can affect the result:\n * - for `related`, the top-level AND conjuncts of the parent's `where`;\n * - for EXISTS and NOT EXISTS, the conjuncts of every AND on the path from\n *   the root of `where` to the subquery condition. An OR adds no facts.\n *\n * A condition is copied when it is `column = literal`, `column IS literal`, or\n * `column IN literal-list` (at most {@link MAX_PUSHED_IN_VALUES} values), the\n * column is a `parentField` of the correlation, and the parent and child\n * columns have the same Zero type, which is not `json`.\n *\n * A condition is not copied when the child already has the same condition as\n * a conjunct. So the pass does not change an AST that it already pushed.\n *\n * Does not change its input. Returns the same object for every part of the\n * AST that it does not change.\n *\n * @param pushed When given, receives each child conjunct that is a copy of a\n * parent condition: the copies that the pass adds, and the child's own\n * conjuncts that equal a copy. The parent's condition implies each of them\n * wherever the join binds its column, so the planner ignores them there.\n */\nexport function pushDownCorrelatedPredicates(\n  ast: AST,\n  columnsOf: (table: string) => Record<string, SchemaValue>,\n  pushed?: Set<SimpleCondition> | undefined,\n): AST {\n  function visit(ast: AST): AST {\n    const where = ast.where && visitCondition(ast.where, ast.table, []);\n    const facts = where ? simpleConjuncts(where) : [];\n    const related =\n      ast.related &&\n      mapShared(ast.related, csq => {\n        const subquery = visit(pushInto(csq, facts, ast.table));\n        return subquery === csq.subquery ? csq : {...csq, subquery};\n      });\n    if (where === ast.where && related === ast.related) {\n      return ast;\n    }\n    return {...ast, where, related};\n  }\n\n  function visitCondition(\n    c: Condition,\n    table: string,\n    facts: readonly SimpleCondition[],\n  ): Condition {\n    switch (c.type) {\n      case 'simple':\n        return c;\n      case 'and':\n        return visitConjunction(c, table, [...facts, ...simpleConjuncts(c)]);\n      case 'or': {\n        const conditions = mapShared(c.conditions, x =>\n          visitCondition(x, table, facts),\n        );\n        return conditions === c.conditions ? c : {...c, conditions};\n      }\n      case 'correlatedSubquery': {\n        const subquery = visit(pushInto(c.related, facts, table));\n        return subquery === c.related.subquery\n          ? c\n          : {...c, related: {...c.related, subquery}};\n      }\n    }\n  }\n\n  // `facts` already holds the simple conjuncts of `c` and of the ANDs nested\n  // directly in it, so nested ANDs must not add them again.\n  function visitConjunction(\n    c: Conjunction,\n    table: string,\n    facts: readonly SimpleCondition[],\n  ): Conjunction {\n    const conditions = mapShared(c.conditions, x =>\n      x.type === 'and'\n        ? visitConjunction(x, table, facts)\n        : visitCondition(x, table, facts),\n    );\n    return conditions === c.conditions ? c : {...c, conditions};\n  }\n\n  function pushInto(\n    csq: CorrelatedSubquery,\n    facts: readonly SimpleCondition[],\n    parentTable: string,\n  ): AST {\n    const {parentField, childField} = csq.correlation;\n    const {subquery} = csq;\n    const conjuncts = subquery.where ? simpleConjuncts(subquery.where) : [];\n    const added: SimpleCondition[] = [];\n    for (const fact of facts) {\n      if (!isPushable(fact)) {\n        continue;\n      }\n      for (let i = 0; i < parentField.length; i++) {\n        if (\n          parentField[i] === fact.left.name &&\n          haveSameScalarType(\n            columnsOf(parentTable)[parentField[i]],\n            columnsOf(subquery.table)[childField[i]],\n          )\n        ) {\n          const copy: SimpleCondition = {\n            ...fact,\n            left: {type: 'column', name: childField[i]},\n          };\n          const same = conjuncts.find(c => isSameCondition(c, copy));\n          if (same) {\n            pushed?.add(same);\n          } else {\n            conjuncts.push(copy);\n            added.push(copy);\n            pushed?.add(copy);\n          }\n        }\n      }\n    }\n    if (added.length === 0) {\n      return subquery;\n    }\n    return {\n      ...subquery,\n      where: simplifyCondition({\n        type: 'and',\n        conditions: subquery.where ? [subquery.where, ...added] : added,\n      }),\n    };\n  }\n\n  return visit(ast);\n}\n\n/**\n * The simple conditions that are conjuncts of `c`, including those of ANDs\n * nested in ANDs.\n */\nfunction simpleConjuncts(c: Condition): SimpleCondition[] {\n  switch (c.type) {\n    case 'simple':\n      return [c];\n    case 'and':\n      return c.conditions.flatMap(simpleConjuncts);\n    default:\n      return [];\n  }\n}\n\nfunction isPushable(c: SimpleCondition): c is ColumnCondition {\n  if (c.left.type !== 'column' || c.right.type !== 'literal') {\n    return false;\n  }\n  switch (c.op) {\n    case '=':\n    case 'IS':\n      return true;\n    case 'IN':\n      return (\n        Array.isArray(c.right.value) &&\n        c.right.value.length <= MAX_PUSHED_IN_VALUES\n      );\n    default:\n      return false;\n  }\n}\n\nfunction isSameCondition(a: SimpleCondition, b: SimpleCondition): boolean {\n  return (\n    a.op === b.op &&\n    a.left.type === 'column' &&\n    b.left.type === 'column' &&\n    a.left.name === b.left.name &&\n    a.right.type === 'literal' &&\n    b.right.type === 'literal' &&\n    deepEqual(a.right.value, b.right.value)\n  );\n}\n\nfunction haveSameScalarType(\n  parent: SchemaValue | undefined,\n  child: SchemaValue | undefined,\n): boolean {\n  return (\n    parent !== undefined &&\n    child !== undefined &&\n    parent.type === child.type &&\n    parent.type !== 'json'\n  );\n}\n\n/**\n * Like `Array.prototype.map`, but returns `arr` itself when `f` returns every\n * element unchanged.\n */\nfunction mapShared<T>(arr: readonly T[], f: (x: T) => T): readonly T[] {\n  let result: T[] | undefined;\n  for (let i = 0; i < arr.length; i++) {\n    const x = f(arr[i]);\n    if (result === undefined && x !== arr[i]) {\n      result = arr.slice(0, i);\n    }\n    result?.push(x);\n  }\n  return result ?? arr;\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/connection-index.d.ts

@@ -1,68 +0,0 @@
-import type { Row, Value } from '../../../zero-protocol/src/data.ts';
-import type { NoSubqueryCondition } from '../builder/filter.ts';
-import type { SourceChange } from './source.ts';
-/**
- * The static equality constraint a connection's filters place on a single
- * column: the row is accepted only if `row[column]` is one of `values`.
- * The push-time counterpart of the fetch-time `Constraint` in
- * `constraint.ts`, which pins columns to single values.
- */
-export type StaticConstraint = {
-    readonly column: string;
-    readonly values: readonly Value[];
-};
-/**
- * Indexes the connections of a source by a static equality constraint
- * (`column = literal` or `column IN (literals)`) taken from each
- * connection's filters, so that a push can determine in O(distinct indexed
- * columns) whether any connection could possibly accept a row, before doing
- * any per-connection work.
- *
- * The index is conservative: {@link mayAccept} returns `true` whenever a
- * connection's filters could accept the row, and may return `true` when they
- * do not (e.g. the connection has further conditions that reject it).
- * It only ever returns `false` when every connection's filters reject the
- * row. Connections without a static equality constraint (no filters, or
- * filters whose top level is not an equality) count as unconstrained and
- * make every row a candidate, as does an index with no connections at all.
- *
- * Values are matched with SameValueZero (`Map` key semantics), which agrees
- * with the `=` / `IN` predicates (`===` / `Set#has`) for every value except
- * `NaN`, where the index is merely more permissive.
- */
-export declare class ConnectionIndex<C> {
-    #private;
-    add(connection: C, filters: NoSubqueryCondition | undefined): void;
-    remove(connection: C): void;
-    get size(): number;
-    /**
-     * Returns `false` only if the filters of every indexed connection reject
-     * `row`. An empty index accepts every row: a source with no connections
-     * is still written to (e.g. to populate it).
-     */
-    mayAccept(row: Row): boolean;
-    /**
-     * Returns `false` only if the filters of every indexed connection reject
-     * the row(s) of `change`: the row for an add or remove, and both the old
-     * and the new row for an edit.
-     */
-    mayAcceptChange(change: SourceChange): boolean;
-}
-/**
- * Extracts a static equality constraint that every row accepted by
- * `condition` must satisfy, or `undefined` if there is none.
- *
- * - `column = literal`, `column IS literal` and `column IN (literals)`
- *   constrain the column. `column = null` (which the predicate folds to
- *   `false`) and an empty `IN` constrain it to the empty set, i.e. the
- *   connection never accepts a row.
- * - An `and` is constrained by any of its constrained conditions; the one
- *   with the fewest values is chosen, so a never-matching condition wins.
- * - An `or` is constrained only if all of its branches constrain the same
- *   column, by the union of their values. Never-matching branches cannot
- *   widen the result and are ignored.
- * - Anything else (`!=`, `IS NOT`, `NOT IN`, ranges, `LIKE`, a literal on
- *   the left) is unconstrained.
- */
-export declare function staticConstraint(condition: NoSubqueryCondition | undefined): StaticConstraint | undefined;
-//# sourceMappingURL=connection-index.d.ts.map