@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.2

package/out/zql/src/ivm/memory-source.js

@@ -4,12 +4,12 @@ import { once, toSorted } from "../../../shared/src/iterables.js";
 import { must } from "../../../shared/src/must.js";
 import { skipYields } from "./skip-yields.js";
 import { makeAddChange, makeEditChange, makeRemoveChange } from "./change.js";
-import { assertOrderingIncludesPK } from "../query/complete-ordering.js";
 import { compareValues, makeComparator, valuesEqual } from "./data.js";
 import { filterPush } from "./filter-push.js";
 import { constraintMatchesPrimaryKey, constraintMatchesRow, primaryKeyConstraintFromFilters } from "./constraint.js";
 import { BTreeSet } from "../../../shared/src/btree-set.js";
 import { createPredicate, transformFilters } from "../builder/filter.js";
+import { assertOrderingIncludesPK } from "../query/complete-ordering.js";
 import { makeSourceChangeAdd, makeSourceChangeRemove } from "./source.js";
 //#region ../zql/src/ivm/memory-source.ts
 /**

package/out/zql/src/ivm/take.js

@@ -2,8 +2,8 @@ import { assert, unreachable } from "../../../shared/src/asserts.js";
 import { hasOwn } from "../../../shared/src/has-own.js";
 import { throwOutput } from "./operator.js";
 import { makeAddChange, makeRemoveChange } from "./change.js";
-import { assertOrderingIncludesPK } from "../query/complete-ordering.js";
 import { compareValues } from "./data.js";
+import { assertOrderingIncludesPK } from "../query/complete-ordering.js";
 //#region ../zql/src/ivm/take.ts
 var MAX_BOUND_KEY = "maxBound";
 /**
@@ -405,6 +405,6 @@ function makePartitionKeyComparator(partitionKey) {
 	};
 }
 //#endregion
-export { Take, constraintMatchesPartitionKey, makePartitionKeyComparator };
+export { Take };
 
 //# sourceMappingURL=take.js.map

package/out/zqlite/src/table-source.js

@@ -1,8 +1,8 @@
 import { assert, unreachable } from "../../shared/src/asserts.js";
 import { must } from "../../shared/src/must.js";
-import { assertOrderingIncludesPK } from "../../zql/src/query/complete-ordering.js";
 import { makeComparator } from "../../zql/src/ivm/data.js";
 import { createPredicate, transformFilters } from "../../zql/src/builder/filter.js";
+import { assertOrderingIncludesPK } from "../../zql/src/query/complete-ordering.js";
 import { genPushAndWriteWithSplitEdit, generateWithOverlay, generateWithOverlayUnordered, generateWithStart } from "../../zql/src/ivm/memory-source.js";
 import { timeSampled } from "../../otel/src/maybe-time.js";
 import { compile, format, sql } from "./internal/sql.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocicorp/zero",
-  "version": "1.6.0-canary.0",
+  "version": "1.6.0-canary.2",
   "description": "Zero is a web framework for serverless web development.",
   "homepage": "https://zero.rocicorp.dev",
   "bugs": {

package/out/zql/src/ivm/cap.d.ts

@@ -1,32 +0,0 @@
-import { type Change } from './change.ts';
-import type { Node } from './data.ts';
-import { type FetchRequest, type Input, type Operator, type Output, type Storage } from './operator.ts';
-import type { SourceSchema } from './schema.ts';
-import { type Stream } from './stream.ts';
-import { type PartitionKey } from './take.ts';
-/**
- * The Cap operator is a count-based limiter for EXISTS subqueries that
- * does not require ordering. Unlike Take, it tracks membership by primary
- * key set rather than by a sorted bound. This means:
- *
- * - No comparator needed (no ordering requirement)
- * - No `start` or `reverse` fetch support
- * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)
- *
- * Cap is used in EXISTS child pipelines where only the count of matching
- * rows matters, not their order. This allows SQLite to skip ORDER BY
- * entirely, enabling much faster query plans.
- *
- * Cap can count rows globally or by unique value of some partition key
- * (same as Take).
- */
-export declare class Cap implements Operator {
-    #private;
-    constructor(input: Input, storage: Storage, limit: number, partitionKey?: PartitionKey);
-    setOutput(output: Output): void;
-    getSchema(): SourceSchema;
-    fetch(req: FetchRequest): Stream<Node | 'yield'>;
-    push(change: Change): Stream<'yield'>;
-    destroy(): void;
-}
-//# sourceMappingURL=cap.d.ts.map

package/out/zql/src/ivm/cap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cap.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/cap.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,MAAM,EAAkB,MAAM,aAAa,CAAC;AAExE,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAanB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,GAAI,YAAW,QAAQ;;gBAWhC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY;IAa7B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,SAAS,IAAI,YAAY;IAIxB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC;IA0FhD,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;IAsHtC,OAAO,IAAI,IAAI;CAGhB"}

package/out/zql/src/ivm/cap.js

@@ -1,205 +0,0 @@
-import { assert } from "../../../shared/src/asserts.js";
-import { throwOutput } from "./operator.js";
-import { makeAddChange } from "./change.js";
-import { constraintMatchesPartitionKey, makePartitionKeyComparator } from "./take.js";
-//#region ../zql/src/ivm/cap.ts
-/**
-* The Cap operator is a count-based limiter for EXISTS subqueries that
-* does not require ordering. Unlike Take, it tracks membership by primary
-* key set rather than by a sorted bound. This means:
-*
-* - No comparator needed (no ordering requirement)
-* - No `start` or `reverse` fetch support
-* - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)
-*
-* Cap is used in EXISTS child pipelines where only the count of matching
-* rows matters, not their order. This allows SQLite to skip ORDER BY
-* entirely, enabling much faster query plans.
-*
-* Cap can count rows globally or by unique value of some partition key
-* (same as Take).
-*/
-var Cap = class {
-	#input;
-	#storage;
-	#limit;
-	#partitionKey;
-	#partitionKeyComparator;
-	#primaryKey;
-	#output = throwOutput;
-	constructor(input, storage, limit, partitionKey) {
-		assert(limit >= 0, "Limit must be non-negative");
-		input.setOutput(this);
-		this.#input = input;
-		this.#storage = storage;
-		this.#limit = limit;
-		this.#partitionKey = partitionKey;
-		this.#partitionKeyComparator = partitionKey && makePartitionKeyComparator(partitionKey);
-		this.#primaryKey = input.getSchema().primaryKey;
-	}
-	setOutput(output) {
-		this.#output = output;
-	}
-	getSchema() {
-		return this.#input.getSchema();
-	}
-	*fetch(req) {
-		assert(!req.start, "Cap does not support start");
-		assert(!req.reverse, "Cap does not support reverse");
-		assert(!this.#partitionKey || req.constraint !== void 0 && constraintMatchesPartitionKey(req.constraint, this.#partitionKey), "Cap fetch: constraint must match partition key when partitioned");
-		const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);
-		const capState = this.#storage.get(capStateKey);
-		if (!capState) {
-			yield* this.#initialFetch(req);
-			return;
-		}
-		if (capState.size === 0) return;
-		for (const pk of capState.pks) {
-			const constraint = deserializePKToConstraint(pk, this.#primaryKey);
-			for (const inputNode of this.#input.fetch({ constraint })) {
-				if (inputNode === "yield") {
-					yield inputNode;
-					continue;
-				}
-				yield inputNode;
-			}
-		}
-	}
-	*#initialFetch(req) {
-		if (this.#limit === 0) return;
-		assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey), "Constraint should match partition key");
-		const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);
-		assert(this.#storage.get(capStateKey) === void 0, "Cap state should be undefined");
-		let size = 0;
-		const pks = [];
-		let downstreamEarlyReturn = true;
-		let exceptionThrown = false;
-		try {
-			for (const inputNode of this.#input.fetch(req)) {
-				if (inputNode === "yield") {
-					yield "yield";
-					continue;
-				}
-				yield inputNode;
-				pks.push(serializePK(inputNode.row, this.#primaryKey));
-				size++;
-				if (size === this.#limit) break;
-			}
-			downstreamEarlyReturn = false;
-		} catch (e) {
-			exceptionThrown = true;
-			throw e;
-		} finally {
-			if (!exceptionThrown) {
-				this.#storage.set(capStateKey, {
-					size,
-					pks
-				});
-				assert(!downstreamEarlyReturn, "Unexpected early return prevented full hydration");
-			}
-		}
-	}
-	*push(change) {
-		if (change[0] === 2) {
-			yield* this.#pushEditChange(change);
-			return;
-		}
-		const capStateKey = getCapStateKey(this.#partitionKey, change[1].row);
-		const capState = this.#storage.get(capStateKey);
-		if (!capState) return;
-		const pk = serializePK(change[1].row, this.#primaryKey);
-		if (change[0] === 0) {
-			if (capState.size < this.#limit) {
-				const pks = [...capState.pks, pk];
-				this.#storage.set(capStateKey, {
-					size: capState.size + 1,
-					pks
-				});
-				yield* this.#output.push(change, this);
-				return;
-			}
-			return;
-		} else if (change[0] === 1) {
-			const pkIndex = capState.pks.indexOf(pk);
-			if (pkIndex === -1) return;
-			const pks = [...capState.pks];
-			pks.splice(pkIndex, 1);
-			const newSize = capState.size - 1;
-			const pkSet = new Set(pks);
-			const constraint = this.#partitionKey ? Object.fromEntries(this.#partitionKey.map((key) => [key, change[1].row[key]])) : void 0;
-			let replacement;
-			for (const node of this.#input.fetch({ constraint })) {
-				if (node === "yield") {
-					yield node;
-					continue;
-				}
-				const nodePK = serializePK(node.row, this.#primaryKey);
-				if (!pkSet.has(nodePK)) {
-					replacement = node;
-					break;
-				}
-			}
-			if (replacement) {
-				this.#storage.set(capStateKey, {
-					size: newSize,
-					pks
-				});
-				yield* this.#output.push(change, this);
-				const replacementPK = serializePK(replacement.row, this.#primaryKey);
-				pks.push(replacementPK);
-				this.#storage.set(capStateKey, {
-					size: newSize + 1,
-					pks
-				});
-				yield* this.#output.push(makeAddChange(replacement), this);
-			} else {
-				this.#storage.set(capStateKey, {
-					size: newSize,
-					pks
-				});
-				yield* this.#output.push(change, this);
-			}
-		} else if (change[0] === 3) {
-			if (new Set(capState.pks).has(pk)) yield* this.#output.push(change, this);
-		}
-	}
-	*#pushEditChange(change) {
-		assert(!this.#partitionKeyComparator || this.#partitionKeyComparator(change[2].row, change[1].row) === 0, "Unexpected change of partition key");
-		const capStateKey = getCapStateKey(this.#partitionKey, change[2].row);
-		const capState = this.#storage.get(capStateKey);
-		if (!capState) return;
-		const oldPK = serializePK(change[2].row, this.#primaryKey);
-		if (new Set(capState.pks).has(oldPK)) {
-			const newPK = serializePK(change[1].row, this.#primaryKey);
-			if (oldPK !== newPK) {
-				const pks = capState.pks.map((p) => p === oldPK ? newPK : p);
-				this.#storage.set(capStateKey, {
-					size: capState.size,
-					pks
-				});
-			}
-			yield* this.#output.push(change, this);
-		}
-	}
-	destroy() {
-		this.#input.destroy();
-	}
-};
-function getCapStateKey(partitionKey, rowOrConstraint) {
-	const partitionValues = [];
-	if (partitionKey && rowOrConstraint) for (const key of partitionKey) partitionValues.push(rowOrConstraint[key]);
-	return JSON.stringify(["cap", ...partitionValues]);
-}
-function serializePK(row, primaryKey) {
-	return JSON.stringify(primaryKey.map((k) => row[k]));
-}
-function deserializePKToConstraint(pk, primaryKey) {
-	const values = JSON.parse(pk);
-	const constraint = {};
-	for (let i = 0; i < primaryKey.length; i++) constraint[primaryKey[i]] = values[i];
-	return constraint;
-}
-//#endregion
-export { Cap };
-
-//# sourceMappingURL=cap.js.map

package/out/zql/src/ivm/cap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cap.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#primaryKey","#output","#initialFetch","#pushEditChange"],"sources":["../../../../../zql/src/ivm/cap.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, type Change, type EditChange} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport {\n  constraintMatchesPartitionKey,\n  makePartitionKeyComparator,\n  type PartitionKey,\n} from './take.ts';\n\ntype CapState = {\n  size: number;\n  pks: string[];\n};\n\ninterface CapStorage {\n  get(key: string): CapState | undefined;\n  set(key: string, value: CapState): void;\n  del(key: string): void;\n}\n\n/**\n * The Cap operator is a count-based limiter for EXISTS subqueries that\n * does not require ordering. Unlike Take, it tracks membership by primary\n * key set rather than by a sorted bound. This means:\n *\n * - No comparator needed (no ordering requirement)\n * - No `start` or `reverse` fetch support\n * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)\n *\n * Cap is used in EXISTS child pipelines where only the count of matching\n * rows matters, not their order. This allows SQLite to skip ORDER BY\n * entirely, enabling much faster query plans.\n *\n * Cap can count rows globally or by unique value of some partition key\n * (same as Take).\n */\nexport class Cap implements Operator {\n  readonly #input: Input;\n  readonly #storage: CapStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  readonly #primaryKey: PrimaryKey;\n\n  #output: Output = throwOutput;\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as CapStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n    this.#primaryKey = input.getSchema().primaryKey;\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(!req.start, 'Cap does not support start');\n    assert(!req.reverse, 'Cap does not support reverse');\n\n    // Cap is only built for non-flipped EXISTS subqueries, whose only\n    // downstream consumer is a Join that always fetches with a constraint\n    // built from the correlation's childField — which is Cap's partition\n    // key. So either partitionKey is undefined, or constraint matches.\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintMatchesPartitionKey(req.constraint, this.#partitionKey)),\n      'Cap fetch: constraint must match partition key when partitioned',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      yield* this.#initialFetch(req);\n      return;\n    }\n    if (capState.size === 0) {\n      return;\n    }\n    // PK-based point lookups: fetch each tracked row by its PK directly,\n    // rather than scanning the partition and filtering.\n    for (const pk of capState.pks) {\n      const constraint = deserializePKToConstraint(pk, this.#primaryKey);\n      for (const inputNode of this.#input.fetch({constraint})) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(capStateKey) === undefined,\n      'Cap state should be undefined',\n    );\n\n    let size = 0;\n    const pks: string[] = [];\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        pks.push(serializePK(inputNode.row, this.#primaryKey));\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#storage.set(capStateKey, {size, pks});\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that capState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const pk = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (capState.size < this.#limit) {\n        const pks = [...capState.pks, pk];\n        this.#storage.set(capStateKey, {size: capState.size + 1, pks});\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // Full — drop\n      return;\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const pkIndex = capState.pks.indexOf(pk);\n      if (pkIndex === -1) {\n        // Not in our set — drop\n        return;\n      }\n      // Remove from set\n      const pks = [...capState.pks];\n      pks.splice(pkIndex, 1);\n      const newSize = capState.size - 1;\n\n      // Try to refill: fetch from input with partition constraint,\n      // find first row NOT in PK set\n      const pkSet = new Set(pks);\n      const constraint = this.#partitionKey\n        ? (Object.fromEntries(\n            this.#partitionKey.map(\n              key => [key, change[ChangeIndex.NODE].row[key]] as const,\n            ),\n          ) as Constraint)\n        : undefined;\n\n      let replacement: Node | undefined;\n      for (const node of this.#input.fetch({constraint})) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        const nodePK = serializePK(node.row, this.#primaryKey);\n        if (!pkSet.has(nodePK)) {\n          replacement = node;\n          break;\n        }\n      }\n\n      if (replacement) {\n        // Store state WITHOUT replacement during remove forward,\n        // matching Take's pattern of hiding in-flight changes from re-fetches.\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n        // Now add replacement to set and forward the add.\n        const replacementPK = serializePK(replacement.row, this.#primaryKey);\n        pks.push(replacementPK);\n        this.#storage.set(capStateKey, {size: newSize + 1, pks});\n        yield* this.#output.push(makeAddChange(replacement), this);\n      } else {\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n      }\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      const pkSet = new Set(capState.pks);\n      if (pkSet.has(pk)) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const oldPK = serializePK(\n      change[ChangeIndex.OLD_NODE].row,\n      this.#primaryKey,\n    );\n    const pkSet = new Set(capState.pks);\n    if (pkSet.has(oldPK)) {\n      // Update the PK in our set if it changed\n      const newPK = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n      if (oldPK !== newPK) {\n        const pks = capState.pks.map(p => (p === oldPK ? newPK : p));\n        this.#storage.set(capStateKey, {size: capState.size, pks});\n      }\n      yield* this.#output.push(change, this);\n    }\n    // If not in our set, drop\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n}\n\nfunction getCapStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['cap', ...partitionValues]);\n}\n\nfunction serializePK(row: Row, primaryKey: PrimaryKey): string {\n  return JSON.stringify(primaryKey.map(k => row[k]));\n}\n\nfunction deserializePKToConstraint(\n  pk: string,\n  primaryKey: PrimaryKey,\n): Constraint {\n  const values = JSON.parse(pk) as Value[];\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < primaryKey.length; i++) {\n    constraint[primaryKey[i]] = values[i];\n  }\n  return constraint;\n}\n"],"mappings":"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"}