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

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

@@ -1,82 +0,0 @@
-import { assert } from "../../../shared/src/asserts.js";
-import { stringCompare } from "../../../shared/src/string-compare.js";
-import { valuesEqual } from "./data.js";
-//#region ../zql/src/ivm/constraint.ts
-function constraintMatchesRow(constraint, row) {
-	for (const key in constraint) if (!valuesEqual(row[key], constraint[key])) return false;
-	return true;
-}
-/**
-* Constraints are compatible if:
-* 1. They do not have any keys in common
-* 2. They have keys in common, but the values for those keys are equal
-*/
-function constraintsAreCompatible(left, right) {
-	for (const key in left) if (key in right && !valuesEqual(left[key], right[key])) return false;
-	return true;
-}
-function constraintMatchesPrimaryKey(constraint, primary) {
-	return keyMatchesPrimaryKey(Object.keys(constraint), primary);
-}
-function keyMatchesPrimaryKey(key, primary) {
-	const constraintKeys = [...key];
-	if (constraintKeys.length !== primary.length) return false;
-	constraintKeys.sort(stringCompare);
-	for (let i = 0; i < constraintKeys.length; i++) if (constraintKeys[i] !== primary[i]) return false;
-	return true;
-}
-/**
-* Pulls top level `and` components out of a condition tree.
-* The resulting array of simple conditions would match a superset of
-* values that the original condition would match.
-*
-* Examples:
-* a AND b OR c
-*
-* In this case we cannot pull anything because the `or` is at the top level.
-*
-* a AND b AND c
-* We can pull all three.
-*
-* a AND (b OR c)
-* We can only pull `a`.
-*/
-function pullSimpleAndComponents(condition) {
-	if (condition.type === "and") return condition.conditions.flatMap(pullSimpleAndComponents);
-	if (condition.type === "simple") return [condition];
-	if (condition.type === "or" && condition.conditions.length === 1) return pullSimpleAndComponents(condition.conditions[0]);
-	return [];
-}
-/**
-* Checks if the supplied filters constitute a primary key lookup.
-* If so, returns the constraint that would be used to look up the primary key.
-* If not, returns undefined.
-*/
-function primaryKeyConstraintFromFilters(condition, primary) {
-	if (condition === void 0) return;
-	const conditions = pullSimpleAndComponents(condition);
-	if (conditions.length === 0) return;
-	const ret = {};
-	for (const subCondition of conditions) if (subCondition.op === "=") {
-		const column = extractColumn(subCondition);
-		if (column !== void 0) {
-			if (!primary.includes(column.name)) continue;
-			ret[column.name] = column.value;
-		}
-	}
-	if (Object.keys(ret).length !== primary.length) return;
-	return ret;
-}
-function extractColumn(condition) {
-	if (condition.left.type === "column") {
-		assert(condition.right.type === "literal", () => `extractColumn: expected right side to be literal, got ${condition.right.type}`);
-		return {
-			name: condition.left.name,
-			value: condition.right.value
-		};
-	}
-}
-//#endregion
-export { constraintMatchesPrimaryKey, constraintMatchesRow, constraintsAreCompatible, keyMatchesPrimaryKey, primaryKeyConstraintFromFilters };
-
-//# sourceMappingURL=constraint.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"constraint.js","names":["#data","#indexOf"],"sources":["../../../../../zql/src/ivm/constraint.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {stringCompare} from '../../../shared/src/string-compare.ts';\nimport {assertTesting} from '../../../shared/src/testing.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {\n  Condition,\n  SimpleCondition,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {valuesEqual} from './data.ts';\n\nexport type Constraint = {\n  readonly [key: string]: Value;\n};\n\nexport function constraintMatchesRow(\n  constraint: Constraint,\n  row: Row,\n): boolean {\n  for (const key in constraint) {\n    if (!valuesEqual(row[key], constraint[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Constraints are compatible if:\n * 1. They do not have any keys in common\n * 2. They have keys in common, but the values for those keys are equal\n */\nexport function constraintsAreCompatible(\n  left: Constraint,\n  right: Constraint,\n): boolean {\n  for (const key in left) {\n    if (key in right && !valuesEqual(left[key], right[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintMatchesPrimaryKey(\n  constraint: Constraint,\n  primary: PrimaryKey,\n): boolean {\n  return keyMatchesPrimaryKey(Object.keys(constraint), primary);\n}\n\nexport function keyMatchesPrimaryKey(\n  key: Iterable<string>,\n  primary: PrimaryKey,\n): boolean {\n  const constraintKeys = [...key];\n\n  if (constraintKeys.length !== primary.length) {\n    return false;\n  }\n\n  // Primary key is always sorted\n  // Constraint does not have to be sorted\n  constraintKeys.sort(stringCompare);\n\n  for (let i = 0; i < constraintKeys.length; i++) {\n    if (constraintKeys[i] !== primary[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Pulls top level `and` components out of a condition tree.\n * The resulting array of simple conditions would match a superset of\n * values that the original condition would match.\n *\n * Examples:\n * a AND b OR c\n *\n * In this case we cannot pull anything because the `or` is at the top level.\n *\n * a AND b AND c\n * We can pull all three.\n *\n * a AND (b OR c)\n * We can only pull `a`.\n */\nexport function pullSimpleAndComponents(\n  condition: Condition,\n): SimpleCondition[] {\n  if (condition.type === 'and') {\n    return condition.conditions.flatMap(pullSimpleAndComponents);\n  }\n\n  if (condition.type === 'simple') {\n    return [condition];\n  }\n\n  if (condition.type === 'or' && condition.conditions.length === 1) {\n    return pullSimpleAndComponents(condition.conditions[0]);\n  }\n\n  return [];\n}\n\n/**\n * Checks if the supplied filters constitute a primary key lookup.\n * If so, returns the constraint that would be used to look up the primary key.\n * If not, returns undefined.\n */\nexport function primaryKeyConstraintFromFilters(\n  condition: Condition | undefined,\n  primary: PrimaryKey,\n): Constraint | undefined {\n  if (condition === undefined) {\n    return undefined;\n  }\n\n  const conditions = pullSimpleAndComponents(condition);\n  if (conditions.length === 0) {\n    return undefined;\n  }\n\n  const ret: Writable<Constraint> = {};\n  for (const subCondition of conditions) {\n    if (subCondition.op === '=') {\n      const column = extractColumn(subCondition);\n      if (column !== undefined) {\n        if (!primary.includes(column.name)) {\n          continue;\n        }\n        ret[column.name] = column.value;\n      }\n    }\n  }\n\n  if (Object.keys(ret).length !== primary.length) {\n    return undefined;\n  }\n\n  return ret;\n}\n\nfunction extractColumn(\n  condition: SimpleCondition,\n): {name: string; value: Value} | undefined {\n  if (condition.left.type === 'column') {\n    assert(\n      condition.right.type === 'literal',\n      () =>\n        `extractColumn: expected right side to be literal, got ${condition.right.type}`,\n    );\n    return {name: condition.left.name, value: condition.right.value};\n  }\n\n  return undefined;\n}\n\nexport class SetOfConstraint {\n  #data: Constraint[] = [];\n\n  constructor() {\n    assertTesting('SetOfConstraint is only available in testing');\n  }\n\n  #indexOf(value: Constraint): number {\n    return this.#data.findIndex(v => constraintEquals(v, value));\n  }\n\n  has(value: Constraint): boolean {\n    return this.#indexOf(value) !== -1;\n  }\n\n  add(value: Constraint): this {\n    if (!this.has(value)) {\n      this.#data.push(value);\n    }\n    return this;\n  }\n}\n\nfunction constraintEquals(a: Constraint, b: Constraint): boolean {\n  const aEntries = Object.entries(a);\n  const bEntries = Object.entries(b);\n  if (aEntries.length !== bEntries.length) {\n    return false;\n  }\n  for (let i = 0; i < aEntries.length; i++) {\n    if (\n      aEntries[i][0] !== bEntries[i][0] ||\n      !valuesEqual(aEntries[i][1], bEntries[i][1])\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;AAgBA,SAAgB,qBACd,YACA,KACS;AACT,MAAK,MAAM,OAAO,WAChB,KAAI,CAAC,YAAY,IAAI,MAAM,WAAW,KAAK,CACzC,QAAO;AAGX,QAAO;;;;;;;AAQT,SAAgB,yBACd,MACA,OACS;AACT,MAAK,MAAM,OAAO,KAChB,KAAI,OAAO,SAAS,CAAC,YAAY,KAAK,MAAM,MAAM,KAAK,CACrD,QAAO;AAGX,QAAO;;AAGT,SAAgB,4BACd,YACA,SACS;AACT,QAAO,qBAAqB,OAAO,KAAK,WAAW,EAAE,QAAQ;;AAG/D,SAAgB,qBACd,KACA,SACS;CACT,MAAM,iBAAiB,CAAC,GAAG,IAAI;AAE/B,KAAI,eAAe,WAAW,QAAQ,OACpC,QAAO;AAKT,gBAAe,KAAK,cAAc;AAElC,MAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,IACzC,KAAI,eAAe,OAAO,QAAQ,GAChC,QAAO;AAGX,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,wBACd,WACmB;AACnB,KAAI,UAAU,SAAS,MACrB,QAAO,UAAU,WAAW,QAAQ,wBAAwB;AAG9D,KAAI,UAAU,SAAS,SACrB,QAAO,CAAC,UAAU;AAGpB,KAAI,UAAU,SAAS,QAAQ,UAAU,WAAW,WAAW,EAC7D,QAAO,wBAAwB,UAAU,WAAW,GAAG;AAGzD,QAAO,EAAE;;;;;;;AAQX,SAAgB,gCACd,WACA,SACwB;AACxB,KAAI,cAAc,KAAA,EAChB;CAGF,MAAM,aAAa,wBAAwB,UAAU;AACrD,KAAI,WAAW,WAAW,EACxB;CAGF,MAAM,MAA4B,EAAE;AACpC,MAAK,MAAM,gBAAgB,WACzB,KAAI,aAAa,OAAO,KAAK;EAC3B,MAAM,SAAS,cAAc,aAAa;AAC1C,MAAI,WAAW,KAAA,GAAW;AACxB,OAAI,CAAC,QAAQ,SAAS,OAAO,KAAK,CAChC;AAEF,OAAI,OAAO,QAAQ,OAAO;;;AAKhC,KAAI,OAAO,KAAK,IAAI,CAAC,WAAW,QAAQ,OACtC;AAGF,QAAO;;AAGT,SAAS,cACP,WAC0C;AAC1C,KAAI,UAAU,KAAK,SAAS,UAAU;AACpC,SACE,UAAU,MAAM,SAAS,iBAEvB,yDAAyD,UAAU,MAAM,OAC5E;AACD,SAAO;GAAC,MAAM,UAAU,KAAK;GAAM,OAAO,UAAU,MAAM;GAAM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"data.js","names":[],"sources":["../../../../../zql/src/ivm/data.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport type {Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * A row flowing through the pipeline, plus its relationships.\n * Relationships are generated lazily as read.\n */\nexport type Node = {\n  row: Row;\n  /**\n   * Relationships are generated lazily as read.\n   * The stream may contain 'yield' to indicate the operator has yielded control.\n   * See {@linkcode Operator.fetch} for more details about yields.\n   */\n  relationships: Record<string, () => Stream<Node | 'yield'>>;\n};\n\n/**\n * Compare two values. The values must be of the same type. This function\n * throws at runtime if the types differ.\n *\n * Note, this function considers `null === null` and\n * `undefined === undefined`. This is different than SQL. In join code,\n * null must be treated separately.\n *\n * See: https://github.com/rocicorp/mono/pull/2116/files#r1704811479\n *\n * @returns < 0 if a < b, 0 if a === b, > 0 if a > b\n */\nexport function compareValues(a: Value, b: Value): number {\n  a = a ?? null;\n  b = b ?? null;\n\n  if (a === b) {\n    return 0;\n  }\n\n  if (typeof a === 'string' && typeof b === 'string') {\n    // We compare all strings in Zero as UTF-8. This is the default on SQLite\n    // and we need to match it. See:\n    // https://blog.replicache.dev/blog/replicache-11-adventures-in-text-encoding.\n    //\n    // TODO: We could change this since SQLite supports UTF-16. Microbenchmark\n    // to see if there's a big win.\n    //\n    // https://www.sqlite.org/c3ref/create_collation.html\n    return compareUTF8(a, b);\n  }\n\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n\n  if (typeof a === 'boolean' && typeof b === 'boolean') {\n    return a ? 1 : -1;\n  }\n\n  // check with null after since it is less likely to be the common case and we\n  // want to avoid the extra checks in that case\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  if (typeof a !== typeof b) {\n    throw new Error(\n      `Cannot compare values of different types: ${typeof a} and ${typeof b}`,\n    );\n  }\n\n  throw new Error(`Unsupported type: ${a}`);\n}\n\nexport type NormalizedValue = Exclude<Value, undefined>;\n\n/**\n * We allow undefined to be passed for the convenience of developers, but we\n * treat it equivalently to null. It's better for perf to not create an copy\n * of input values, so we just normalize at use when necessary.\n */\nexport function normalizeUndefined(v: Value): NormalizedValue {\n  return v ?? null;\n}\n\nexport type Comparator = (r1: Row, r2: Row) => number;\n\nexport function makeComparator(order: Ordering, reverse?: boolean): Comparator {\n  return (a, b) => {\n    // Skip destructuring here since it is hot code.\n    for (const ord of order) {\n      const field = ord[0];\n      const comp = compareValues(a[field], b[field]);\n      if (comp !== 0) {\n        const result = ord[1] === 'asc' ? comp : -comp;\n        return reverse ? -result : result;\n      }\n    }\n    return 0;\n  };\n}\n\n/**\n * Determine if two values are equal. Note that unlike compareValues() above,\n * this function treats `null` as unequal to itself (and same for `undefined`).\n * This is required to make joins work correctly, but may not be the right\n * semantic for your application.\n */\nexport function valuesEqual(a: Value, b: Value): boolean {\n  // oxlint-disable-next-line eqeqeq\n  if (a == null || b == null) {\n    return false;\n  }\n  return a === b;\n}\n\nexport function drainStreams(node: Node | 'yield') {\n  if (node === 'yield') {\n    return;\n  }\n  for (const stream of Object.values(node.relationships)) {\n    for (const node of stream()) {\n      drainStreams(node);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AA+BA,SAAgB,cAAc,GAAU,GAAkB;AACxD,KAAI,KAAK;AACT,KAAI,KAAK;AAET,KAAI,MAAM,EACR,QAAO;AAGT,KAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SASxC,QAAO,YAAY,GAAG,EAAE;AAG1B,KAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SACxC,QAAO,IAAI;AAGb,KAAI,OAAO,MAAM,aAAa,OAAO,MAAM,UACzC,QAAO,IAAI,IAAI;AAKjB,KAAI,MAAM,KACR,QAAO;AAET,KAAI,MAAM,KACR,QAAO;AAGT,KAAI,OAAO,MAAM,OAAO,EACtB,OAAM,IAAI,MACR,6CAA6C,OAAO,EAAE,OAAO,OAAO,IACrE;AAGH,OAAM,IAAI,MAAM,qBAAqB,IAAI;;;;;;;AAU3C,SAAgB,mBAAmB,GAA2B;AAC5D,QAAO,KAAK;;AAKd,SAAgB,eAAe,OAAiB,SAA+B;AAC7E,SAAQ,GAAG,MAAM;AAEf,OAAK,MAAM,OAAO,OAAO;GACvB,MAAM,QAAQ,IAAI;GAClB,MAAM,OAAO,cAAc,EAAE,QAAQ,EAAE,OAAO;AAC9C,OAAI,SAAS,GAAG;IACd,MAAM,SAAS,IAAI,OAAO,QAAQ,OAAO,CAAC;AAC1C,WAAO,UAAU,CAAC,SAAS;;;AAG/B,SAAO;;;;;;;;;AAUX,SAAgB,YAAY,GAAU,GAAmB;AAEvD,KAAI,KAAK,QAAQ,KAAK,KACpB,QAAO;AAET,QAAO,MAAM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"exists.js","names":["#input","#relationshipName","#not","#parentJoinKey","#noSizeReuse","#cache","#cacheHitCountsForTesting","#output","#inPush","#getCacheKey","#fetchExists","#filter","#pushWithFilter","#fetchSize"],"sources":["../../../../../zql/src/ivm/exists.ts"],"sourcesContent":["import {areEqual} from '../../../shared/src/arrays.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, makeRemoveChange, type Change} from './change.ts';\nimport {normalizeUndefined, type Node, type NormalizedValue} from './data.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The Exists operator filters data based on whether or not a relationship is\n * non-empty.\n */\nexport class Exists implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #relationshipName: string;\n  readonly #not: boolean;\n  readonly #parentJoinKey: CompoundKey;\n  readonly #noSizeReuse: boolean;\n  #cache: Map<string, boolean>;\n  #cacheHitCountsForTesting: Map<string, number> | undefined;\n  #output: FilterOutput = throwFilterOutput;\n\n  /**\n   * This instance variable is `true` when this operator is processing a `push`,\n   * and is used to disable reuse of cached sizes across rows with the\n   * same parent join key value.\n   * This is necessary because during a push relationships can be inconsistent\n   * due to push communicating changes (which may change multiple Nodes) one\n   * Node at a time.\n   */\n  #inPush = false;\n\n  constructor(\n    input: FilterInput,\n    relationshipName: string,\n    parentJoinKey: CompoundKey,\n    type: 'EXISTS' | 'NOT EXISTS',\n    cacheHitCountsForTesting?: Map<string, number>,\n  ) {\n    this.#input = input;\n    this.#relationshipName = relationshipName;\n    this.#input.setFilterOutput(this);\n    this.#cache = new Map();\n    this.#cacheHitCountsForTesting = cacheHitCountsForTesting;\n    assert(\n      this.#input.getSchema().relationships[relationshipName],\n      `Input schema missing ${relationshipName}`,\n    );\n    this.#not = type === 'NOT EXISTS';\n    this.#parentJoinKey = parentJoinKey;\n\n    // If the parentJoinKey is the primary key, no sense in trying to reuse.\n    this.#noSizeReuse = areEqual(\n      parentJoinKey,\n      this.#input.getSchema().primaryKey,\n    );\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#output = output;\n  }\n\n  beginFilter() {\n    this.#output.beginFilter();\n  }\n\n  endFilter() {\n    this.#cache = new Map();\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    let exists: boolean | undefined;\n    if (!this.#noSizeReuse && !this.#inPush) {\n      const key = this.#getCacheKey(node, this.#parentJoinKey);\n      exists = this.#cache.get(key);\n      if (exists === undefined) {\n        exists = yield* this.#fetchExists(node);\n        this.#cache.set(key, exists);\n      } else if (this.#cacheHitCountsForTesting) {\n        this.#cacheHitCountsForTesting.set(\n          key,\n          (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1,\n        );\n      }\n    }\n\n    const result =\n      (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));\n    return result;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    assert(!this.#inPush, 'Unexpected re-entrancy');\n    this.#inPush = true;\n    try {\n      switch (change[ChangeIndex.TYPE]) {\n        // add, remove and edit cannot change the size of the\n        // this.#relationshipName relationship, so simply #pushWithFilter\n        case ChangeType.ADD:\n        case ChangeType.EDIT:\n        case ChangeType.REMOVE: {\n          yield* this.#pushWithFilter(change);\n          return;\n        }\n        case ChangeType.CHILD:\n          // Only add and remove child changes for the\n          // this.#relationshipName relationship, can change the size\n          // of the this.#relationshipName relationship, for other\n          // child changes simply #pushWithFilter\n          if (\n            change[ChangeIndex.CHILD_DATA].relationshipName !==\n              this.#relationshipName ||\n            change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n              ChangeType.EDIT ||\n            change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n              ChangeType.CHILD\n          ) {\n            yield* this.#pushWithFilter(change);\n            return;\n          }\n          switch (change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE]) {\n            case ChangeType.ADD: {\n              const size = yield* this.#fetchSize(change[ChangeIndex.NODE]);\n              if (size === 1) {\n                if (this.#not) {\n                  // Since the add child change currently being processed is not\n                  // pushed to output, the added child needs to be excluded from\n                  // the remove being pushed to output (since the child has\n                  // never been added to the output).\n                  yield* this.#output.push(\n                    makeRemoveChange({\n                      row: change[ChangeIndex.NODE].row,\n                      relationships: {\n                        ...change[ChangeIndex.NODE].relationships,\n                        [this.#relationshipName]: () => [],\n                      },\n                    }),\n                    this,\n                  );\n                } else {\n                  yield* this.#output.push(\n                    makeAddChange(change[ChangeIndex.NODE]),\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n            case ChangeType.REMOVE: {\n              const size = yield* this.#fetchSize(change[ChangeIndex.NODE]);\n              if (size === 0) {\n                if (this.#not) {\n                  yield* this.#output.push(\n                    makeAddChange(change[ChangeIndex.NODE]),\n                    this,\n                  );\n                } else {\n                  // Since the remove child change currently being processed is\n                  // not pushed to output, the removed child needs to be added to\n                  // the remove being pushed to output.\n                  yield* this.#output.push(\n                    makeRemoveChange({\n                      row: change[ChangeIndex.NODE].row,\n                      relationships: {\n                        ...change[ChangeIndex.NODE].relationships,\n                        [this.#relationshipName]: () => [\n                          change[ChangeIndex.CHILD_DATA].change[\n                            ChangeIndex.NODE\n                          ],\n                        ],\n                      },\n                    }),\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n          }\n          return;\n        default:\n          unreachable(change);\n      }\n    } finally {\n      this.#inPush = false;\n    }\n  }\n\n  /**\n   * Returns whether or not the node's this.#relationshipName\n   * relationship passes the exist/not exists filter condition.\n   * If the optional `size` is passed it is used.\n   * Otherwise, if there is a stored size for the row it is used.\n   * Otherwise the size is computed by streaming the node's\n   * relationship with this.#relationshipName (this computed size is also\n   * stored).\n   */\n  *#filter(node: Node, exists?: boolean): Generator<'yield', boolean> {\n    exists = exists ?? (yield* this.#fetchExists(node));\n    return this.#not ? !exists : exists;\n  }\n\n  #getCacheKey(node: Node, def: CompoundKey): string {\n    const values: NormalizedValue[] = [];\n    for (const key of def) {\n      values.push(normalizeUndefined(node.row[key]));\n    }\n    return JSON.stringify(values);\n  }\n\n  /**\n   * Pushes a change if this.#filter is true for its row.\n   */\n  *#pushWithFilter(change: Change, exists?: boolean): Stream<'yield'> {\n    if (yield* this.#filter(change[ChangeIndex.NODE], exists)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  *#fetchExists(node: Node): Generator<'yield', boolean> {\n    // While it seems like this should be able to fetch just 1 node\n    // to check for exists, we can't because Take does not support\n    // early return during initial fetch.\n    return (yield* this.#fetchSize(node)) > 0;\n  }\n\n  *#fetchSize(node: Node): Generator<'yield', number> {\n    const relationship = node.relationships[this.#relationshipName];\n    assert(\n      relationship,\n      () =>\n        `Exists: relationship \"${this.#relationshipName}\" not found on node`,\n    );\n    let size = 0;\n    for (const n of relationship()) {\n      if (n === 'yield') {\n        yield 'yield';\n      } else {\n        size++;\n      }\n    }\n    return size;\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/fan-in.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fan-in.js","names":["#inputs","#schema","#output","#accumulatedPushes"],"sources":["../../../../../zql/src/ivm/fan-in.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray, identity} from '../../../shared/src/sentinels.ts';\nimport type {ChangeType} from './change-type.ts';\nimport {type Change} from './change.ts';\nimport {type Node} from './data.ts';\nimport type {FanOut} from './fan-out.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport {pushAccumulatedChanges} from './push-accumulated.ts';\nimport type {SourceSchema} from './schema.ts';\n\n/**\n * The FanIn operator merges multiple streams into one.\n * It eliminates duplicates and must be paired with a fan-out operator\n * somewhere upstream of the fan-in.\n *\n *  issue\n *    |\n * fan-out\n * /      \\\n * a      b\n *  \\    /\n * fan-in\n *   |\n */\nexport class FanIn implements FilterOperator {\n  readonly #inputs: readonly FilterInput[];\n  readonly #schema: SourceSchema;\n  #output: FilterOutput = throwFilterOutput;\n  #accumulatedPushes: Change[] = [];\n\n  constructor(fanOut: FanOut, inputs: FilterInput[]) {\n    this.#inputs = inputs;\n    this.#schema = fanOut.getSchema();\n    for (const input of inputs) {\n      input.setFilterOutput(this);\n      assert(this.#schema === input.getSchema(), `Schema mismatch in fan-in`);\n    }\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    for (const input of this.#inputs) {\n      input.destroy();\n    }\n  }\n\n  getSchema() {\n    return this.#schema;\n  }\n\n  beginFilter(): void {\n    this.#output.beginFilter();\n  }\n\n  endFilter(): void {\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    return yield* this.#output.filter(node);\n  }\n\n  push(change: Change) {\n    this.#accumulatedPushes.push(change);\n    return emptyArray;\n  }\n\n  *fanOutDonePushingToAllBranches(fanOutChangeType: ChangeType) {\n    if (this.#inputs.length === 0) {\n      assert(\n        this.#accumulatedPushes.length === 0,\n        'If there are no inputs then fan-in should not receive any pushes.',\n      );\n      return;\n    }\n\n    yield* pushAccumulatedChanges(\n      this.#accumulatedPushes,\n      this.#output,\n      this,\n      fanOutChangeType,\n      identity,\n      identity,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,QAAb,MAA6C;CAC3C;CACA;CACA,UAAwB;CACxB,qBAA+B,EAAE;CAEjC,YAAY,QAAgB,QAAuB;AACjD,QAAA,SAAe;AACf,QAAA,SAAe,OAAO,WAAW;AACjC,OAAK,MAAM,SAAS,QAAQ;AAC1B,SAAM,gBAAgB,KAAK;AAC3B,UAAO,MAAA,WAAiB,MAAM,WAAW,EAAE,4BAA4B;;;CAI3E,gBAAgB,QAA4B;AAC1C,QAAA,SAAe;;CAGjB,UAAgB;AACd,OAAK,MAAM,SAAS,MAAA,OAClB,OAAM,SAAS;;CAInB,YAAY;AACV,SAAO,MAAA;;CAGT,cAAoB;AAClB,QAAA,OAAa,aAAa;;CAG5B,YAAkB;AAChB,QAAA,OAAa,WAAW;;CAG1B,CAAC,OAAO,MAAyC;AAC/C,SAAO,OAAO,MAAA,OAAa,OAAO,KAAK;;CAGzC,KAAK,QAAgB;AACnB,QAAA,kBAAwB,KAAK,OAAO;AACpC,SAAO;;CAGT,CAAC,+BAA+B,kBAA8B;AAC5D,MAAI,MAAA,OAAa,WAAW,GAAG;AAC7B,UACE,MAAA,kBAAwB,WAAW,GACnC,oEACD;AACD;;AAGF,SAAO,uBACL,MAAA,mBACA,MAAA,QACA,MACA,kBACA,UACA,SACD"}

package/out/zql/src/ivm/fan-out.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fan-out.js","names":["#input","#outputs","#fanIn","#destroyCount"],"sources":["../../../../../zql/src/ivm/fan-out.ts"],"sourcesContent":["import {must} from '../../../shared/src/must.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport type {Change} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {FanIn} from './fan-in.ts';\nimport type {\n  FilterInput,\n  FilterOperator,\n  FilterOutput,\n} from './filter-operators.ts';\n\n/**\n * Forks a stream into multiple streams.\n * Is meant to be paired with a `FanIn` operator which will\n * later merge the forks back together.\n */\nexport class FanOut implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #outputs: FilterOutput[] = [];\n  #fanIn: FanIn | undefined;\n  #destroyCount: number = 0;\n\n  constructor(input: FilterInput) {\n    this.#input = input;\n    input.setFilterOutput(this);\n  }\n\n  setFanIn(fanIn: FanIn) {\n    this.#fanIn = fanIn;\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#outputs.push(output);\n  }\n\n  destroy(): void {\n    if (this.#destroyCount < this.#outputs.length) {\n      ++this.#destroyCount;\n      if (this.#destroyCount === this.#outputs.length) {\n        this.#input.destroy();\n      }\n    } else {\n      throw new Error('FanOut already destroyed once for each output');\n    }\n  }\n\n  getSchema() {\n    return this.#input.getSchema();\n  }\n\n  beginFilter(): void {\n    for (const output of this.#outputs) {\n      output.beginFilter();\n    }\n  }\n\n  endFilter(): void {\n    for (const output of this.#outputs) {\n      output.endFilter();\n    }\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    let result = false;\n    for (const output of this.#outputs) {\n      result = (yield* output.filter(node)) || result;\n      if (result) {\n        return true;\n      }\n    }\n    return result;\n  }\n\n  *push(change: Change) {\n    for (const out of this.#outputs) {\n      yield* out.push(change, this);\n    }\n    yield* must(\n      this.#fanIn,\n      'fan-out must have a corresponding fan-in set!',\n    ).fanOutDonePushingToAllBranches(change[ChangeIndex.TYPE]);\n  }\n}\n"],"mappings":";;;;;;;AAgBA,IAAa,SAAb,MAA8C;CAC5C;CACA,WAAoC,EAAE;CACtC;CACA,gBAAwB;CAExB,YAAY,OAAoB;AAC9B,QAAA,QAAc;AACd,QAAM,gBAAgB,KAAK;;CAG7B,SAAS,OAAc;AACrB,QAAA,QAAc;;CAGhB,gBAAgB,QAA4B;AAC1C,QAAA,QAAc,KAAK,OAAO;;CAG5B,UAAgB;AACd,MAAI,MAAA,eAAqB,MAAA,QAAc,QAAQ;AAC7C,KAAE,MAAA;AACF,OAAI,MAAA,iBAAuB,MAAA,QAAc,OACvC,OAAA,MAAY,SAAS;QAGvB,OAAM,IAAI,MAAM,gDAAgD;;CAIpE,YAAY;AACV,SAAO,MAAA,MAAY,WAAW;;CAGhC,cAAoB;AAClB,OAAK,MAAM,UAAU,MAAA,QACnB,QAAO,aAAa;;CAIxB,YAAkB;AAChB,OAAK,MAAM,UAAU,MAAA,QACnB,QAAO,WAAW;;CAItB,CAAC,OAAO,MAAyC;EAC/C,IAAI,SAAS;AACb,OAAK,MAAM,UAAU,MAAA,SAAe;AAClC,aAAU,OAAO,OAAO,OAAO,KAAK,KAAK;AACzC,OAAI,OACF,QAAO;;AAGX,SAAO;;CAGT,CAAC,KAAK,QAAgB;AACpB,OAAK,MAAM,OAAO,MAAA,QAChB,QAAO,IAAI,KAAK,QAAQ,KAAK;AAE/B,SAAO,KACL,MAAA,OACA,gDACD,CAAC,+BAA+B,OAAO,GAAkB"}

package/out/zql/src/ivm/filter-operators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter-operators.js","names":["#input","#output","#start"],"sources":["../../../../../zql/src/ivm/filter-operators.ts"],"sourcesContent":["import type {BuilderDelegate} from '../builder/builder.ts';\nimport type {Change} from './change.ts';\nimport {type Node} from './data.ts';\nimport type {FetchRequest, Input, InputBase, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The `where` clause of a ZQL query is implemented using a sub-graph of\n * `FilterOperators`.  This sub-graph starts with a `FilterStart` operator,\n * that adapts from the normal `Operator` `Output`, to the\n * `FilterOperator` `FilterInput`, and ends with a `FilterEnd` operator that\n * adapts from a `FilterOperator` `FilterOutput` to a normal `Operator` `Input`.\n * `FilterOperator`'s do not have `fetch` instead they have a\n * `filter(node: Node): boolean` method.\n * They also have `push` which is just like normal `Operator` push.\n * Not having a `fetch` means these `FilterOperator`'s cannot modify\n * `Node` `row`s or `relationship`s, but they shouldn't, they should just\n * filter.\n *\n * This `FilterOperator` abstraction enables much more efficient processing of\n * `fetch` for `where` clauses containing OR conditions.\n *\n * See https://github.com/rocicorp/mono/pull/4339\n */\n\nexport interface FilterInput extends InputBase {\n  /** Tell the input where to send its output. */\n  setFilterOutput(output: FilterOutput): void;\n}\n\nexport interface FilterOutput extends Output {\n  // Lets the operator know that we're in a loop of filtering\n  // nodes. E.g., so the operator can cache results for the\n  // duration of the loop.\n  beginFilter(): void;\n  filter(node: Node): Generator<'yield', boolean>;\n  endFilter(): void;\n}\n\nexport interface FilterOperator extends FilterInput, FilterOutput {}\n\n/**\n * An implementation of FilterOutput that throws if push or filter is called.\n * It is used as the initial value for for an operator's output before it is\n * set.\n */\nexport const throwFilterOutput: FilterOutput = {\n  *push(_change: Change): Stream<'yield'> {\n    throw new Error('Output not set');\n  },\n\n  *filter(_node: Node): Generator<'yield', boolean> {\n    throw new Error('Output not set');\n  },\n\n  beginFilter() {},\n  endFilter() {},\n};\n\nexport class FilterStart implements FilterInput, Output {\n  readonly #input: Input;\n  #output: FilterOutput = throwFilterOutput;\n\n  constructor(input: Input) {\n    this.#input = input;\n    input.setOutput(this);\n  }\n\n  setFilterOutput(output: FilterOutput) {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change) {\n    yield* this.#output.push(change, this);\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    this.#output.beginFilter();\n    try {\n      for (const node of this.#input.fetch(req)) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        if (yield* this.#output.filter(node)) {\n          yield node;\n        }\n      }\n    } finally {\n      // finally is important if an exception is thrown or\n      // if the stream is not fully consumed.\n      this.#output.endFilter();\n    }\n  }\n}\n\nexport class FilterEnd implements Input, FilterOutput {\n  readonly #start: FilterStart;\n  readonly #input: FilterInput;\n\n  #output: Output = throwFilterOutput;\n\n  constructor(start: FilterStart, input: FilterInput) {\n    this.#start = start;\n    this.#input = input;\n    input.setFilterOutput(this);\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    for (const node of this.#start.fetch(req)) {\n      yield node;\n    }\n  }\n\n  beginFilter() {}\n  endFilter() {}\n\n  *filter(_node: Node) {\n    return true;\n  }\n\n  setOutput(output: Output) {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change) {\n    yield* this.#output.push(change, this);\n  }\n}\n\nexport function buildFilterPipeline(\n  input: Input,\n  delegate: BuilderDelegate,\n  pipeline: (filterInput: FilterInput) => FilterInput,\n): Input {\n  const filterStart = new FilterStart(input);\n  delegate.addEdge(input, filterStart);\n  const middle = pipeline(filterStart);\n  delegate.addEdge(filterStart, middle);\n  const filterEnd = new FilterEnd(filterStart, middle);\n  delegate.addEdge(middle, filterEnd);\n  return filterEnd;\n}\n"],"mappings":";;;;;;;AA+CA,IAAa,oBAAkC;CAC7C,CAAC,KAAK,SAAkC;AACtC,QAAM,IAAI,MAAM,iBAAiB;;CAGnC,CAAC,OAAO,OAA0C;AAChD,QAAM,IAAI,MAAM,iBAAiB;;CAGnC,cAAc;CACd,YAAY;CACb;AAED,IAAa,cAAb,MAAwD;CACtD;CACA,UAAwB;CAExB,YAAY,OAAc;AACxB,QAAA,QAAc;AACd,QAAM,UAAU,KAAK;;CAGvB,gBAAgB,QAAsB;AACpC,QAAA,SAAe;;CAGjB,UAAgB;AACd,QAAA,MAAY,SAAS;;CAGvB,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,CAAC,KAAK,QAAgB;AACpB,SAAO,MAAA,OAAa,KAAK,QAAQ,KAAK;;CAGxC,CAAC,MAAM,KAA2C;AAChD,QAAA,OAAa,aAAa;AAC1B,MAAI;AACF,QAAK,MAAM,QAAQ,MAAA,MAAY,MAAM,IAAI,EAAE;AACzC,QAAI,SAAS,SAAS;AACpB,WAAM;AACN;;AAEF,QAAI,OAAO,MAAA,OAAa,OAAO,KAAK,CAClC,OAAM;;YAGF;AAGR,SAAA,OAAa,WAAW;;;;AAK9B,IAAa,YAAb,MAAsD;CACpD;CACA;CAEA,UAAkB;CAElB,YAAY,OAAoB,OAAoB;AAClD,QAAA,QAAc;AACd,QAAA,QAAc;AACd,QAAM,gBAAgB,KAAK;;CAG7B,CAAC,MAAM,KAA2C;AAChD,OAAK,MAAM,QAAQ,MAAA,MAAY,MAAM,IAAI,CACvC,OAAM;;CAIV,cAAc;CACd,YAAY;CAEZ,CAAC,OAAO,OAAa;AACnB,SAAO;;CAGT,UAAU,QAAgB;AACxB,QAAA,SAAe;;CAGjB,UAAgB;AACd,QAAA,MAAY,SAAS;;CAGvB,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,CAAC,KAAK,QAAgB;AACpB,SAAO,MAAA,OAAa,KAAK,QAAQ,KAAK;;;AAI1C,SAAgB,oBACd,OACA,UACA,UACO;CACP,MAAM,cAAc,IAAI,YAAY,MAAM;AAC1C,UAAS,QAAQ,OAAO,YAAY;CACpC,MAAM,SAAS,SAAS,YAAY;AACpC,UAAS,QAAQ,aAAa,OAAO;CACrC,MAAM,YAAY,IAAI,UAAU,aAAa,OAAO;AACpD,UAAS,QAAQ,QAAQ,UAAU;AACnC,QAAO"}

package/out/zql/src/ivm/filter-push.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter-push.js","names":[],"sources":["../../../../../zql/src/ivm/filter-push.ts"],"sourcesContent":["import {unreachable} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport type {InputBase, Output} from './operator.ts';\nimport type {Stream} from './stream.ts';\n\nexport function* filterPush(\n  change: Change,\n  output: Output,\n  pusher: InputBase,\n  predicate?: (row: Row) => boolean,\n): Stream<'yield'> {\n  if (!predicate) {\n    yield* output.push(change, pusher);\n    return;\n  }\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n    case ChangeType.REMOVE:\n      if (predicate(change[ChangeIndex.NODE].row)) {\n        yield* output.push(change, pusher);\n      }\n      break;\n    case ChangeType.CHILD:\n      if (predicate(change[ChangeIndex.NODE].row)) {\n        yield* output.push(change, pusher);\n      }\n      break;\n    case ChangeType.EDIT:\n      yield* maybeSplitAndPushEditChange(change, predicate, output, pusher);\n      break;\n    default:\n      unreachable(change);\n  }\n}\n"],"mappings":";;;AASA,UAAiB,WACf,QACA,QACA,QACA,WACiB;AACjB,KAAI,CAAC,WAAW;AACd,SAAO,OAAO,KAAK,QAAQ,OAAO;AAClC;;AAEF,SAAQ,OAAO,IAAf;EACE,KAAK;EACL,KAAK;AACH,OAAI,UAAU,OAAO,GAAkB,IAAI,CACzC,QAAO,OAAO,KAAK,QAAQ,OAAO;AAEpC;EACF,KAAK;AACH,OAAI,UAAU,OAAO,GAAkB,IAAI,CACzC,QAAO,OAAO,KAAK,QAAQ,OAAO;AAEpC;EACF,KAAK;AACH,UAAO,4BAA4B,QAAQ,WAAW,QAAQ,OAAO;AACrE;EACF,QACE,aAAY,OAAO"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"filter.js","names":["#input","#predicate","#output"],"sources":["../../../../../zql/src/ivm/filter.ts"],"sourcesContent":["import type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {Change} from './change.ts';\nimport {type Node} from './data.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport {filterPush} from './filter-push.ts';\nimport type {SourceSchema} from './schema.ts';\n\n/**\n * The Filter operator filters data through a predicate. It is stateless.\n *\n * The predicate must be pure.\n */\nexport class Filter implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #predicate: (row: Row) => boolean;\n\n  #output: FilterOutput = throwFilterOutput;\n\n  constructor(input: FilterInput, predicate: (row: Row) => boolean) {\n    this.#input = input;\n    this.#predicate = predicate;\n    input.setFilterOutput(this);\n  }\n\n  beginFilter(): void {\n    this.#output.beginFilter();\n  }\n\n  endFilter(): void {\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    return this.#predicate(node.row) && (yield* this.#output.filter(node));\n  }\n\n  setFilterOutput(output: FilterOutput) {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change) {\n    yield* filterPush(change, this.#output, this, this.#predicate);\n  }\n}\n"],"mappings":";;;;;;;;;AAiBA,IAAa,SAAb,MAA8C;CAC5C;CACA;CAEA,UAAwB;CAExB,YAAY,OAAoB,WAAkC;AAChE,QAAA,QAAc;AACd,QAAA,YAAkB;AAClB,QAAM,gBAAgB,KAAK;;CAG7B,cAAoB;AAClB,QAAA,OAAa,aAAa;;CAG5B,YAAkB;AAChB,QAAA,OAAa,WAAW;;CAG1B,CAAC,OAAO,MAAyC;AAC/C,SAAO,MAAA,UAAgB,KAAK,IAAI,KAAK,OAAO,MAAA,OAAa,OAAO,KAAK;;CAGvE,gBAAgB,QAAsB;AACpC,QAAA,SAAe;;CAGjB,UAAgB;AACd,QAAA,MAAY,SAAS;;CAGvB,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,CAAC,KAAK,QAAgB;AACpB,SAAO,WAAW,QAAQ,MAAA,QAAc,MAAM,MAAA,UAAgB"}

package/out/zql/src/ivm/flipped-join.js

@@ -1,311 +0,0 @@
-import { assert, unreachable } from "../../../shared/src/asserts.js";
-import { binarySearch } from "../../../shared/src/binary-search.js";
-import { must } from "../../../shared/src/must.js";
-import { throwOutput } from "./operator.js";
-import { makeAddChange, makeChildChange, makeEditChange, makeRemoveChange } from "./change.js";
-import { constraintsAreCompatible, keyMatchesPrimaryKey } from "./constraint.js";
-import { buildJoinConstraint, generateWithOverlayNoYield, isJoinMatch, rowEqualsForCompoundKey } from "./join-utils.js";
-import { mergeSortedStreams } from "./memory-source.js";
-//#region ../zql/src/ivm/flipped-join.ts
-/**
-* An *inner* join which fetches nodes from its child input first and then
-* fetches their related nodes from its parent input.  Output nodes are the
-* nodes from parent input (in parent input order), which have at least one
-* related child.  These output nodes have a new relationship added to them,
-* which has the name `relationshipName`. The value of the relationship is a
-* stream of related nodes from the child input (in child input order).
-*/
-var FlippedJoin = class {
-	#parent;
-	#child;
-	#parentKey;
-	#childKey;
-	#relationshipName;
-	#schema;
-	#parentKeyIsUnique;
-	#output = throwOutput;
-	#inprogressChildChange;
-	#inprogressChildChangePosition;
-	constructor({ parent, child, parentKey, childKey, relationshipName, hidden, system }) {
-		assert(parent !== child, "Parent and child must be different operators");
-		assert(parentKey.length === childKey.length, "The parentKey and childKey keys must have same length");
-		this.#parent = parent;
-		this.#child = child;
-		this.#parentKey = parentKey;
-		this.#childKey = childKey;
-		this.#relationshipName = relationshipName;
-		const parentSchema = parent.getSchema();
-		const childSchema = child.getSchema();
-		this.#parentKeyIsUnique = keyMatchesPrimaryKey(parentKey, parentSchema.primaryKey) || (parentSchema.uniqueIndexes?.some((idx) => keyMatchesPrimaryKey(parentKey, idx)) ?? false);
-		this.#schema = {
-			...parentSchema,
-			relationships: {
-				...parentSchema.relationships,
-				[relationshipName]: {
-					...childSchema,
-					isHidden: hidden,
-					system
-				}
-			}
-		};
-		parent.setOutput({ push: (change) => this.#pushParent(change) });
-		child.setOutput({ push: (change) => this.#pushChild(change) });
-	}
-	destroy() {
-		this.#child.destroy();
-		this.#parent.destroy();
-	}
-	setOutput(output) {
-		this.#output = output;
-	}
-	getSchema() {
-		return this.#schema;
-	}
-	*fetch(req) {
-		const childConstraint = {};
-		let hasChildConstraint = false;
-		if (req.constraint) for (const [key, value] of Object.entries(req.constraint)) {
-			const index = this.#parentKey.indexOf(key);
-			if (index !== -1) {
-				hasChildConstraint = true;
-				childConstraint[this.#childKey[index]] = value;
-			}
-		}
-		const childNodes = [];
-		for (const node of this.#child.fetch(hasChildConstraint ? { constraint: childConstraint } : {})) {
-			if (node === "yield") {
-				yield node;
-				continue;
-			}
-			childNodes.push(node);
-		}
-		if (this.#inprogressChildChange?.[0] === 1) {
-			const removedNode = this.#inprogressChildChange[1];
-			const compare = this.#child.getSchema().compareRows;
-			const insertPos = binarySearch(childNodes.length, (i) => compare(removedNode.row, childNodes[i].row));
-			childNodes.splice(insertPos, 0, removedNode);
-		}
-		if (this.#parentKeyIsUnique) yield* this.#fetchQuicksort(req, childNodes);
-		else yield* this.#fetchMergeSort(req, childNodes);
-	}
-	*#fetchQuicksort(req, childNodes) {
-		const pairs = [];
-		for (const childNode of childNodes) {
-			const constraintFromChild = buildJoinConstraint(childNode.row, this.#childKey, this.#parentKey);
-			if (!constraintFromChild || req.constraint && !constraintsAreCompatible(constraintFromChild, req.constraint)) continue;
-			const stream = this.#parent.fetch({
-				...req,
-				constraint: {
-					...req.constraint,
-					...constraintFromChild
-				}
-			});
-			for (const node of stream) {
-				if (node === "yield") {
-					yield "yield";
-					continue;
-				}
-				pairs.push({
-					childNode,
-					parentNode: node
-				});
-			}
-		}
-		const compareRows = this.#schema.compareRows;
-		const dir = req.reverse ? -1 : 1;
-		pairs.sort((a, b) => compareRows(a.parentNode.row, b.parentNode.row) * dir);
-		let i = 0;
-		while (i < pairs.length) {
-			const minParentNode = pairs[i].parentNode;
-			const relatedChildNodes = [];
-			while (i < pairs.length && compareRows(pairs[i].parentNode.row, minParentNode.row) === 0) {
-				relatedChildNodes.push(pairs[i].childNode);
-				i++;
-			}
-			yield* this.#yieldParentWithOverlay(minParentNode, relatedChildNodes);
-		}
-	}
-	*#fetchMergeSort(req, childNodes) {
-		const parentKey = this.#parentKey;
-		const computedKeys = [];
-		const childIndexesByKey = /* @__PURE__ */ new Map();
-		for (let i = 0; i < childNodes.length; i++) {
-			const constraintFromChild = buildJoinConstraint(childNodes[i].row, this.#childKey, parentKey);
-			if (!constraintFromChild || req.constraint && !constraintsAreCompatible(constraintFromChild, req.constraint)) continue;
-			const key = canonicalKey(constraintFromChild, parentKey);
-			const existing = childIndexesByKey.get(key);
-			if (existing === void 0) {
-				childIndexesByKey.set(key, [i]);
-				computedKeys.push(constraintFromChild);
-			} else existing.push(i);
-		}
-		if (computedKeys.length === 0) return;
-		const compareRows = this.#schema.compareRows;
-		const compare = req.reverse ? (a, b) => compareRows(b.row, a.row) : (a, b) => compareRows(a.row, b.row);
-		const streams = computedKeys.map((c) => this.#parent.fetch({
-			...req,
-			constraint: req.constraint ? {
-				...req.constraint,
-				...c
-			} : c
-		}));
-		for (const node of mergeSortedStreams(streams, compare)) {
-			if (node === "yield") {
-				yield "yield";
-				continue;
-			}
-			const relatedChildNodes = must(childIndexesByKey.get(canonicalKey(node.row, parentKey))).map((i) => childNodes[i]);
-			yield* this.#yieldParentWithOverlay(node, relatedChildNodes);
-		}
-	}
-	*#yieldParentWithOverlay(minParentNode, relatedChildNodes) {
-		let overlaidRelatedChildNodes = relatedChildNodes;
-		if (this.#inprogressChildChange && this.#inprogressChildChangePosition && isJoinMatch(this.#inprogressChildChange[1].row, this.#childKey, minParentNode.row, this.#parentKey)) {
-			const hasInprogressChildChangeBeenPushedForMinParentNode = this.#parent.getSchema().compareRows(minParentNode.row, this.#inprogressChildChangePosition) <= 0;
-			if (this.#inprogressChildChange[0] === 1) {
-				if (hasInprogressChildChangeBeenPushedForMinParentNode) overlaidRelatedChildNodes = relatedChildNodes.filter((n) => n !== this.#inprogressChildChange?.[1]);
-			} else if (!hasInprogressChildChangeBeenPushedForMinParentNode) overlaidRelatedChildNodes = [...generateWithOverlayNoYield(relatedChildNodes, this.#inprogressChildChange, this.#child.getSchema())];
-		}
-		if (overlaidRelatedChildNodes.length > 0) yield {
-			...minParentNode,
-			relationships: {
-				...minParentNode.relationships,
-				[this.#relationshipName]: () => overlaidRelatedChildNodes
-			}
-		};
-	}
-	*#pushChild(change) {
-		switch (change[0]) {
-			case 0:
-			case 1:
-				yield* this.#pushChildChange(change);
-				break;
-			case 2:
-				assert(rowEqualsForCompoundKey(change[2].row, change[1].row, this.#childKey), `Child edit must not change relationship.`);
-				yield* this.#pushChildChange(change, true);
-				break;
-			case 3:
-				yield* this.#pushChildChange(change, true);
-				break;
-		}
-	}
-	*#pushChildChange(change, exists) {
-		this.#inprogressChildChange = change;
-		this.#inprogressChildChangePosition = void 0;
-		try {
-			const constraint = buildJoinConstraint(change[1].row, this.#childKey, this.#parentKey);
-			const parentNodeStream = constraint ? this.#parent.fetch({ constraint }) : [];
-			for (const parentNode of parentNodeStream) {
-				if (parentNode === "yield") {
-					yield "yield";
-					continue;
-				}
-				this.#inprogressChildChange = change;
-				this.#inprogressChildChangePosition = parentNode.row;
-				const childNodeStream = () => {
-					const constraint = buildJoinConstraint(parentNode.row, this.#parentKey, this.#childKey);
-					return constraint ? this.#child.fetch({ constraint }) : [];
-				};
-				if (!exists) for (const childNode of childNodeStream()) {
-					if (childNode === "yield") {
-						yield "yield";
-						continue;
-					}
-					if (this.#child.getSchema().compareRows(childNode.row, change[1].row) !== 0) {
-						exists = true;
-						break;
-					}
-				}
-				if (exists) yield* this.#output.push(makeChildChange({
-					...parentNode,
-					relationships: {
-						...parentNode.relationships,
-						[this.#relationshipName]: childNodeStream
-					}
-				}, {
-					relationshipName: this.#relationshipName,
-					change
-				}), this);
-				else {
-					const newNode = {
-						...parentNode,
-						relationships: {
-							...parentNode.relationships,
-							[this.#relationshipName]: () => [change[1]]
-						}
-					};
-					yield* this.#output.push(change[0] === 0 ? makeAddChange(newNode) : makeRemoveChange(newNode), this);
-				}
-			}
-		} finally {
-			this.#inprogressChildChange = void 0;
-		}
-	}
-	*#pushParent(change) {
-		const childNodeStream = (node) => () => {
-			const constraint = buildJoinConstraint(node.row, this.#parentKey, this.#childKey);
-			return constraint ? this.#child.fetch({ constraint }) : [];
-		};
-		const flip = (node) => ({
-			...node,
-			relationships: {
-				...node.relationships,
-				[this.#relationshipName]: childNodeStream(node)
-			}
-		});
-		let hasRelatedChild = false;
-		for (const node of childNodeStream(change[1])()) if (node === "yield") {
-			yield "yield";
-			continue;
-		} else {
-			hasRelatedChild = true;
-			break;
-		}
-		if (!hasRelatedChild) return;
-		switch (change[0]) {
-			case 0:
-				yield* this.#output.push(makeAddChange(flip(change[1])), this);
-				break;
-			case 1:
-				yield* this.#output.push(makeRemoveChange(flip(change[1])), this);
-				break;
-			case 3:
-				yield* this.#output.push(makeChildChange(flip(change[1]), change[2]), this);
-				break;
-			case 2:
-				assert(rowEqualsForCompoundKey(change[2].row, change[1].row, this.#parentKey), `Parent edit must not change relationship.`);
-				yield* this.#output.push(makeEditChange(flip(change[1]), flip(change[2])), this);
-				break;
-			default: unreachable(change);
-		}
-	}
-};
-/**
-* Canonical string key over `keys` of `record`, used by `#fetchMergeSort`
-* both to dedupe per-child fetches and to map each returned parent row
-* back to the children that referenced its parent-key tuple.
-*
-* Exported for testing.
-*/
-function canonicalKey(record, keys) {
-	if (keys.length === 1) return canonicalValue(record[keys[0]]);
-	let s = "";
-	for (let i = 0; i < keys.length; i++) {
-		if (i > 0) s += "\0";
-		s += canonicalValue(record[keys[i]]);
-	}
-	return s;
-}
-function canonicalValue(v) {
-	if (v === null || v === void 0) return "n";
-	const t = typeof v;
-	if (t === "string") return "s" + v;
-	if (t === "number") return "d" + v;
-	if (t === "bigint") return "b" + v.toString();
-	if (t === "boolean") return v ? "t" : "f";
-	return "j" + JSON.stringify(v);
-}
-//#endregion
-export { FlippedJoin };
-
-//# sourceMappingURL=flipped-join.js.map

package/out/zql/src/ivm/flipped-join.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flipped-join.js","names":["#parent","#child","#parentKey","#childKey","#relationshipName","#schema","#parentKeyIsUnique","#pushParent","#pushChild","#output","#inprogressChildChange","#fetchQuicksort","#fetchMergeSort","#yieldParentWithOverlay","#inprogressChildChangePosition","#pushChildChange"],"sources":["../../../../../zql/src/ivm/flipped-join.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {binarySearch} from '../../../shared/src/binary-search.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {CompoundKey, System} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport {\n  constraintsAreCompatible,\n  keyMatchesPrimaryKey,\n  type Constraint,\n} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport {\n  buildJoinConstraint,\n  generateWithOverlayNoYield,\n  isJoinMatch,\n  rowEqualsForCompoundKey,\n} from './join-utils.ts';\nimport {mergeSortedStreams} from './memory-source.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\ntype Args = {\n  parent: Input;\n  child: Input;\n  // The nth key in childKey corresponds to the nth key in parentKey.\n  parentKey: CompoundKey;\n  childKey: CompoundKey;\n\n  relationshipName: string;\n  hidden: boolean;\n  system: System;\n};\n\n/**\n * An *inner* join which fetches nodes from its child input first and then\n * fetches their related nodes from its parent input.  Output nodes are the\n * nodes from parent input (in parent input order), which have at least one\n * related child.  These output nodes have a new relationship added to them,\n * which has the name `relationshipName`. The value of the relationship is a\n * stream of related nodes from the child input (in child input order).\n */\nexport class FlippedJoin implements Input {\n  readonly #parent: Input;\n  readonly #child: Input;\n  readonly #parentKey: CompoundKey;\n  readonly #childKey: CompoundKey;\n  readonly #relationshipName: string;\n  readonly #schema: SourceSchema;\n  readonly #parentKeyIsUnique: boolean;\n\n  #output: Output = throwOutput;\n\n  #inprogressChildChange: Change | undefined;\n  #inprogressChildChangePosition: Row | undefined;\n\n  constructor({\n    parent,\n    child,\n    parentKey,\n    childKey,\n    relationshipName,\n    hidden,\n    system,\n  }: Args) {\n    assert(parent !== child, 'Parent and child must be different operators');\n    assert(\n      parentKey.length === childKey.length,\n      'The parentKey and childKey keys must have same length',\n    );\n    this.#parent = parent;\n    this.#child = child;\n    this.#parentKey = parentKey;\n    this.#childKey = childKey;\n    this.#relationshipName = relationshipName;\n\n    const parentSchema = parent.getSchema();\n    const childSchema = child.getSchema();\n    this.#parentKeyIsUnique =\n      keyMatchesPrimaryKey(parentKey, parentSchema.primaryKey) ||\n      (parentSchema.uniqueIndexes?.some(idx =>\n        keyMatchesPrimaryKey(parentKey, idx),\n      ) ??\n        false);\n    this.#schema = {\n      ...parentSchema,\n      relationships: {\n        ...parentSchema.relationships,\n        [relationshipName]: {\n          ...childSchema,\n          isHidden: hidden,\n          system,\n        },\n      },\n    };\n\n    parent.setOutput({\n      push: (change: Change) => this.#pushParent(change),\n    });\n    child.setOutput({\n      push: (change: Change) => this.#pushChild(change),\n    });\n  }\n\n  destroy(): void {\n    this.#child.destroy();\n    this.#parent.destroy();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    // Translate constraints for the parent on parts of the join key to\n    // constraints for the child.\n    const childConstraint: Record<string, Value> = {};\n    let hasChildConstraint = false;\n    if (req.constraint) {\n      for (const [key, value] of Object.entries(req.constraint)) {\n        const index = this.#parentKey.indexOf(key);\n        if (index !== -1) {\n          hasChildConstraint = true;\n          childConstraint[this.#childKey[index]] = value;\n        }\n      }\n    }\n\n    const childNodes: Node[] = [];\n    for (const node of this.#child.fetch(\n      hasChildConstraint ? {constraint: childConstraint} : {},\n    )) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      childNodes.push(node);\n    }\n\n    // FlippedJoin's split-push change overlay logic is largely\n    // the same as Join's with the exception of remove.  For remove,\n    // the change is undone here, and then re-applied to parents with order\n    // less than or equal to change.position below.  This is necessary\n    // because if the removed node was the last related child, the\n    // related parents with position greater than change.position\n    // (which should not yet have the node removed), would not even\n    // be fetched here, and would be absent from the output all together.\n    if (this.#inprogressChildChange?.[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const removedNode = this.#inprogressChildChange[ChangeIndex.NODE];\n      const compare = this.#child.getSchema().compareRows;\n      const insertPos = binarySearch(childNodes.length, i =>\n        compare(removedNode.row, childNodes[i].row),\n      );\n      childNodes.splice(insertPos, 0, removedNode);\n    }\n\n    if (this.#parentKeyIsUnique) {\n      yield* this.#fetchQuicksort(req, childNodes);\n    } else {\n      yield* this.#fetchMergeSort(req, childNodes);\n    }\n  }\n\n  // When parentKey matches a unique index on the parent (primary or\n  // otherwise) each child -> parent fetch returns at most one row, so the\n  // merge-sort degenerates to N simultaneous prepared-statement iterators\n  // each holding a single-row cursor.  Instead, fetch sequentially (letting\n  // the statement cache reuse a single prepared statement) and sort the\n  // resulting parents into order.\n  *#fetchQuicksort(\n    req: FetchRequest,\n    childNodes: Node[],\n  ): Stream<Node | 'yield'> {\n    const pairs: {childNode: Node; parentNode: Node}[] = [];\n    for (const childNode of childNodes) {\n      const constraintFromChild = buildJoinConstraint(\n        childNode.row,\n        this.#childKey,\n        this.#parentKey,\n      );\n      if (\n        !constraintFromChild ||\n        (req.constraint &&\n          !constraintsAreCompatible(constraintFromChild, req.constraint))\n      ) {\n        continue;\n      }\n      const stream = this.#parent.fetch({\n        ...req,\n        constraint: {\n          ...req.constraint,\n          ...constraintFromChild,\n        },\n      });\n      // parentKey matches a unique index, so this fetch returns at most\n      // one row under the Source contract.  Iterate to completion rather\n      // than breaking to preserve yield propagation and to avoid silently\n      // changing behavior if a source ever returns more.\n      for (const node of stream) {\n        if (node === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        pairs.push({childNode, parentNode: node});\n      }\n    }\n\n    const compareRows = this.#schema.compareRows;\n    const dir = req.reverse ? -1 : 1;\n    pairs.sort((a, b) => compareRows(a.parentNode.row, b.parentNode.row) * dir);\n\n    // Group consecutive pairs with equal parent rows.  Array.sort is stable,\n    // and childNodes was already in child order, so children within each\n    // group retain child order.\n    let i = 0;\n    while (i < pairs.length) {\n      const minParentNode = pairs[i].parentNode;\n      const relatedChildNodes: Node[] = [];\n      while (\n        i < pairs.length &&\n        compareRows(pairs[i].parentNode.row, minParentNode.row) === 0\n      ) {\n        relatedChildNodes.push(pairs[i].childNode);\n        i++;\n      }\n      yield* this.#yieldParentWithOverlay(minParentNode, relatedChildNodes);\n    }\n  }\n\n  *#fetchMergeSort(\n    req: FetchRequest,\n    childNodes: Node[],\n  ): Stream<Node | 'yield'> {\n    // Group children by parent-key value so children sharing a value\n    // share one fetch (and one cursor). Without this, two children with\n    // the same parent-key value would each open their own iterator that\n    // re-fetches the same parent rows — wasted IO.\n    const parentKey = this.#parentKey;\n    const computedKeys: Constraint[] = [];\n    const childIndexesByKey = new Map<string, number[]>();\n    for (let i = 0; i < childNodes.length; i++) {\n      const constraintFromChild = buildJoinConstraint(\n        childNodes[i].row,\n        this.#childKey,\n        parentKey,\n      );\n      if (\n        !constraintFromChild ||\n        (req.constraint &&\n          !constraintsAreCompatible(constraintFromChild, req.constraint))\n      ) {\n        continue;\n      }\n      const key = canonicalKey(constraintFromChild, parentKey);\n      const existing = childIndexesByKey.get(key);\n      if (existing === undefined) {\n        childIndexesByKey.set(key, [i]);\n        computedKeys.push(constraintFromChild);\n      } else {\n        existing.push(i);\n      }\n    }\n\n    if (computedKeys.length === 0) {\n      return;\n    }\n\n    const compareRows = this.#schema.compareRows;\n    const compare: (a: Node, b: Node) => number = req.reverse\n      ? (a, b) => compareRows(b.row, a.row)\n      : (a, b) => compareRows(a.row, b.row);\n\n    // One stream per unique parent-key value. Each stream returns its\n    // matching parent rows in compareRows order; the heap merges them\n    // into a globally ordered stream. Distinct rows can't compare equal\n    // (compareRows includes the primary key), so no tie handling needed\n    // — every emit maps back to exactly one entry in childIndexesByKey.\n    const streams: Stream<Node | 'yield'>[] = computedKeys.map(c =>\n      this.#parent.fetch({\n        ...req,\n        constraint: req.constraint ? {...req.constraint, ...c} : c,\n      }),\n    );\n\n    for (const node of mergeSortedStreams(streams, compare)) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      // Every fetched parent row matches the constraint for one entry\n      // in `computedKeys`, whose canonical key was inserted into the\n      // map — so the lookup is guaranteed to hit. Children retain\n      // their original input order within the group because we\n      // appended to the indexes array in iteration order.\n      const idxs = must(\n        childIndexesByKey.get(canonicalKey(node.row, parentKey)),\n      );\n      const relatedChildNodes: Node[] = idxs.map(i => childNodes[i]);\n      yield* this.#yieldParentWithOverlay(node, relatedChildNodes);\n    }\n  }\n\n  *#yieldParentWithOverlay(\n    minParentNode: Node,\n    relatedChildNodes: Node[],\n  ): Stream<Node> {\n    let overlaidRelatedChildNodes = relatedChildNodes;\n    if (\n      this.#inprogressChildChange &&\n      this.#inprogressChildChangePosition &&\n      isJoinMatch(\n        this.#inprogressChildChange[ChangeIndex.NODE].row,\n        this.#childKey,\n        minParentNode.row,\n        this.#parentKey,\n      )\n    ) {\n      const hasInprogressChildChangeBeenPushedForMinParentNode =\n        this.#parent\n          .getSchema()\n          .compareRows(\n            minParentNode.row,\n            this.#inprogressChildChangePosition,\n          ) <= 0;\n      if (this.#inprogressChildChange[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n        if (hasInprogressChildChangeBeenPushedForMinParentNode) {\n          // Remove from relatedChildNodes since the removed child\n          // was inserted into childNodes above.\n          overlaidRelatedChildNodes = relatedChildNodes.filter(\n            n => n !== this.#inprogressChildChange?.[ChangeIndex.NODE],\n          );\n        }\n      } else if (!hasInprogressChildChangeBeenPushedForMinParentNode) {\n        overlaidRelatedChildNodes = [\n          ...generateWithOverlayNoYield(\n            relatedChildNodes,\n            this.#inprogressChildChange,\n            this.#child.getSchema(),\n          ),\n        ];\n      }\n    }\n\n    // yield node if after the overlay it still has relationship nodes\n    if (overlaidRelatedChildNodes.length > 0) {\n      yield {\n        ...minParentNode,\n        relationships: {\n          ...minParentNode.relationships,\n          [this.#relationshipName]: () => overlaidRelatedChildNodes,\n        },\n      };\n    }\n  }\n\n  *#pushChild(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n      case ChangeType.REMOVE:\n        yield* this.#pushChildChange(change);\n        break;\n      case ChangeType.EDIT: {\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#childKey,\n          ),\n          `Child edit must not change relationship.`,\n        );\n        yield* this.#pushChildChange(change, true);\n        break;\n      }\n      case ChangeType.CHILD:\n        yield* this.#pushChildChange(change, true);\n        break;\n    }\n  }\n\n  *#pushChildChange(change: Change, exists?: boolean): Stream<'yield'> {\n    this.#inprogressChildChange = change;\n    this.#inprogressChildChangePosition = undefined;\n    try {\n      const constraint = buildJoinConstraint(\n        change[ChangeIndex.NODE].row,\n        this.#childKey,\n        this.#parentKey,\n      );\n      const parentNodeStream = constraint\n        ? this.#parent.fetch({constraint})\n        : [];\n      for (const parentNode of parentNodeStream) {\n        if (parentNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        this.#inprogressChildChange = change;\n        this.#inprogressChildChangePosition = parentNode.row;\n        const childNodeStream = () => {\n          const constraint = buildJoinConstraint(\n            parentNode.row,\n            this.#parentKey,\n            this.#childKey,\n          );\n          return constraint ? this.#child.fetch({constraint}) : [];\n        };\n        if (!exists) {\n          for (const childNode of childNodeStream()) {\n            if (childNode === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            if (\n              this.#child\n                .getSchema()\n                .compareRows(childNode.row, change[ChangeIndex.NODE].row) !== 0\n            ) {\n              exists = true;\n              break;\n            }\n          }\n        }\n        if (exists) {\n          yield* this.#output.push(\n            makeChildChange(\n              {\n                ...parentNode,\n                relationships: {\n                  ...parentNode.relationships,\n                  [this.#relationshipName]: childNodeStream,\n                },\n              },\n              {\n                relationshipName: this.#relationshipName,\n                change,\n              },\n            ),\n            this,\n          );\n        } else {\n          const newNode = {\n            ...parentNode,\n            relationships: {\n              ...parentNode.relationships,\n              [this.#relationshipName]: () => [change[ChangeIndex.NODE]],\n            },\n          };\n          yield* this.#output.push(\n            change[ChangeIndex.TYPE] === ChangeType.ADD\n              ? makeAddChange(newNode)\n              : makeRemoveChange(newNode),\n            this,\n          );\n        }\n      }\n    } finally {\n      this.#inprogressChildChange = undefined;\n    }\n  }\n\n  *#pushParent(change: Change): Stream<'yield'> {\n    const childNodeStream = (node: Node) => () => {\n      const constraint = buildJoinConstraint(\n        node.row,\n        this.#parentKey,\n        this.#childKey,\n      );\n      return constraint ? this.#child.fetch({constraint}) : [];\n    };\n\n    const flip = (node: Node) => ({\n      ...node,\n      relationships: {\n        ...node.relationships,\n        [this.#relationshipName]: childNodeStream(node),\n      },\n    });\n\n    // If no related child don't push as this is an inner join.\n    let hasRelatedChild = false;\n    for (const node of childNodeStream(change[ChangeIndex.NODE])()) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      } else {\n        hasRelatedChild = true;\n        break;\n      }\n    }\n    if (!hasRelatedChild) {\n      return;\n    }\n\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        yield* this.#output.push(\n          makeAddChange(flip(change[ChangeIndex.NODE])),\n          this,\n        );\n        break;\n      case ChangeType.REMOVE:\n        yield* this.#output.push(\n          makeRemoveChange(flip(change[ChangeIndex.NODE])),\n          this,\n        );\n        break;\n      case ChangeType.CHILD: {\n        yield* this.#output.push(\n          makeChildChange(\n            flip(change[ChangeIndex.NODE]),\n            change[ChangeIndex.CHILD_DATA],\n          ),\n          this,\n        );\n        break;\n      }\n      case ChangeType.EDIT: {\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#parentKey,\n          ),\n          `Parent edit must not change relationship.`,\n        );\n        yield* this.#output.push(\n          makeEditChange(\n            flip(change[ChangeIndex.NODE]),\n            flip(change[ChangeIndex.OLD_NODE]),\n          ),\n          this,\n        );\n        break;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n}\n\n/**\n * Canonical string key over `keys` of `record`, used by `#fetchMergeSort`\n * both to dedupe per-child fetches and to map each returned parent row\n * back to the children that referenced its parent-key tuple.\n *\n * Exported for testing.\n */\nexport function canonicalKey(\n  record: Record<string, Value | undefined>,\n  keys: CompoundKey,\n): string {\n  if (keys.length === 1) {\n    return canonicalValue(record[keys[0]]);\n  }\n  let s = '';\n  for (let i = 0; i < keys.length; i++) {\n    if (i > 0) s += '\\x00';\n    s += canonicalValue(record[keys[i]]);\n  }\n  return s;\n}\n\nfunction canonicalValue(v: Value | bigint | undefined): string {\n  // Tag by type so we don't conflate e.g. `1` (number) with `\"1\"` (string).\n  // Bigint shows up at runtime when zqlite's safeIntegers is on, even\n  // though the static `Value` type doesn't list it.\n  if (v === null || v === undefined) return 'n';\n  const t = typeof v;\n  if (t === 'string') return 's' + (v as string);\n  if (t === 'number') return 'd' + (v as number);\n  if (t === 'bigint') return 'b' + (v as bigint).toString();\n  if (t === 'boolean') return v ? 't' : 'f';\n  return 'j' + JSON.stringify(v);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAwDA,IAAa,cAAb,MAA0C;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,UAAkB;CAElB;CACA;CAEA,YAAY,EACV,QACA,OACA,WACA,UACA,kBACA,QACA,UACO;AACP,SAAO,WAAW,OAAO,+CAA+C;AACxE,SACE,UAAU,WAAW,SAAS,QAC9B,wDACD;AACD,QAAA,SAAe;AACf,QAAA,QAAc;AACd,QAAA,YAAkB;AAClB,QAAA,WAAiB;AACjB,QAAA,mBAAyB;EAEzB,MAAM,eAAe,OAAO,WAAW;EACvC,MAAM,cAAc,MAAM,WAAW;AACrC,QAAA,oBACE,qBAAqB,WAAW,aAAa,WAAW,KACvD,aAAa,eAAe,MAAK,QAChC,qBAAqB,WAAW,IAAI,CACrC,IACC;AACJ,QAAA,SAAe;GACb,GAAG;GACH,eAAe;IACb,GAAG,aAAa;KACf,mBAAmB;KAClB,GAAG;KACH,UAAU;KACV;KACD;IACF;GACF;AAED,SAAO,UAAU,EACf,OAAO,WAAmB,MAAA,WAAiB,OAAO,EACnD,CAAC;AACF,QAAM,UAAU,EACd,OAAO,WAAmB,MAAA,UAAgB,OAAO,EAClD,CAAC;;CAGJ,UAAgB;AACd,QAAA,MAAY,SAAS;AACrB,QAAA,OAAa,SAAS;;CAGxB,UAAU,QAAsB;AAC9B,QAAA,SAAe;;CAGjB,YAA0B;AACxB,SAAO,MAAA;;CAGT,CAAC,MAAM,KAA2C;EAGhD,MAAM,kBAAyC,EAAE;EACjD,IAAI,qBAAqB;AACzB,MAAI,IAAI,WACN,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,WAAW,EAAE;GACzD,MAAM,QAAQ,MAAA,UAAgB,QAAQ,IAAI;AAC1C,OAAI,UAAU,IAAI;AAChB,yBAAqB;AACrB,oBAAgB,MAAA,SAAe,UAAU;;;EAK/C,MAAM,aAAqB,EAAE;AAC7B,OAAK,MAAM,QAAQ,MAAA,MAAY,MAC7B,qBAAqB,EAAC,YAAY,iBAAgB,GAAG,EAAE,CACxD,EAAE;AACD,OAAI,SAAS,SAAS;AACpB,UAAM;AACN;;AAEF,cAAW,KAAK,KAAK;;AAWvB,MAAI,MAAA,wBAA8B,OAAsB,GAAmB;GACzE,MAAM,cAAc,MAAA,sBAA4B;GAChD,MAAM,UAAU,MAAA,MAAY,WAAW,CAAC;GACxC,MAAM,YAAY,aAAa,WAAW,SAAQ,MAChD,QAAQ,YAAY,KAAK,WAAW,GAAG,IAAI,CAC5C;AACD,cAAW,OAAO,WAAW,GAAG,YAAY;;AAG9C,MAAI,MAAA,kBACF,QAAO,MAAA,eAAqB,KAAK,WAAW;MAE5C,QAAO,MAAA,eAAqB,KAAK,WAAW;;CAUhD,EAAA,eACE,KACA,YACwB;EACxB,MAAM,QAA+C,EAAE;AACvD,OAAK,MAAM,aAAa,YAAY;GAClC,MAAM,sBAAsB,oBAC1B,UAAU,KACV,MAAA,UACA,MAAA,UACD;AACD,OACE,CAAC,uBACA,IAAI,cACH,CAAC,yBAAyB,qBAAqB,IAAI,WAAW,CAEhE;GAEF,MAAM,SAAS,MAAA,OAAa,MAAM;IAChC,GAAG;IACH,YAAY;KACV,GAAG,IAAI;KACP,GAAG;KACJ;IACF,CAAC;AAKF,QAAK,MAAM,QAAQ,QAAQ;AACzB,QAAI,SAAS,SAAS;AACpB,WAAM;AACN;;AAEF,UAAM,KAAK;KAAC;KAAW,YAAY;KAAK,CAAC;;;EAI7C,MAAM,cAAc,MAAA,OAAa;EACjC,MAAM,MAAM,IAAI,UAAU,KAAK;AAC/B,QAAM,MAAM,GAAG,MAAM,YAAY,EAAE,WAAW,KAAK,EAAE,WAAW,IAAI,GAAG,IAAI;EAK3E,IAAI,IAAI;AACR,SAAO,IAAI,MAAM,QAAQ;GACvB,MAAM,gBAAgB,MAAM,GAAG;GAC/B,MAAM,oBAA4B,EAAE;AACpC,UACE,IAAI,MAAM,UACV,YAAY,MAAM,GAAG,WAAW,KAAK,cAAc,IAAI,KAAK,GAC5D;AACA,sBAAkB,KAAK,MAAM,GAAG,UAAU;AAC1C;;AAEF,UAAO,MAAA,uBAA6B,eAAe,kBAAkB;;;CAIzE,EAAA,eACE,KACA,YACwB;EAKxB,MAAM,YAAY,MAAA;EAClB,MAAM,eAA6B,EAAE;EACrC,MAAM,oCAAoB,IAAI,KAAuB;AACrD,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;GAC1C,MAAM,sBAAsB,oBAC1B,WAAW,GAAG,KACd,MAAA,UACA,UACD;AACD,OACE,CAAC,uBACA,IAAI,cACH,CAAC,yBAAyB,qBAAqB,IAAI,WAAW,CAEhE;GAEF,MAAM,MAAM,aAAa,qBAAqB,UAAU;GACxD,MAAM,WAAW,kBAAkB,IAAI,IAAI;AAC3C,OAAI,aAAa,KAAA,GAAW;AAC1B,sBAAkB,IAAI,KAAK,CAAC,EAAE,CAAC;AAC/B,iBAAa,KAAK,oBAAoB;SAEtC,UAAS,KAAK,EAAE;;AAIpB,MAAI,aAAa,WAAW,EAC1B;EAGF,MAAM,cAAc,MAAA,OAAa;EACjC,MAAM,UAAwC,IAAI,WAC7C,GAAG,MAAM,YAAY,EAAE,KAAK,EAAE,IAAI,IAClC,GAAG,MAAM,YAAY,EAAE,KAAK,EAAE,IAAI;EAOvC,MAAM,UAAoC,aAAa,KAAI,MACzD,MAAA,OAAa,MAAM;GACjB,GAAG;GACH,YAAY,IAAI,aAAa;IAAC,GAAG,IAAI;IAAY,GAAG;IAAE,GAAG;GAC1D,CAAC,CACH;AAED,OAAK,MAAM,QAAQ,mBAAmB,SAAS,QAAQ,EAAE;AACvD,OAAI,SAAS,SAAS;AACpB,UAAM;AACN;;GAUF,MAAM,oBAHO,KACX,kBAAkB,IAAI,aAAa,KAAK,KAAK,UAAU,CAAC,CACzD,CACsC,KAAI,MAAK,WAAW,GAAG;AAC9D,UAAO,MAAA,uBAA6B,MAAM,kBAAkB;;;CAIhE,EAAA,uBACE,eACA,mBACc;EACd,IAAI,4BAA4B;AAChC,MACE,MAAA,yBACA,MAAA,iCACA,YACE,MAAA,sBAA4B,GAAkB,KAC9C,MAAA,UACA,cAAc,KACd,MAAA,UACD,EACD;GACA,MAAM,qDACJ,MAAA,OACG,WAAW,CACX,YACC,cAAc,KACd,MAAA,8BACD,IAAI;AACT,OAAI,MAAA,sBAA4B,OAAsB;QAChD,mDAGF,6BAA4B,kBAAkB,QAC5C,MAAK,MAAM,MAAA,wBAA8B,GAC1C;cAEM,CAAC,mDACV,6BAA4B,CAC1B,GAAG,2BACD,mBACA,MAAA,uBACA,MAAA,MAAY,WAAW,CACxB,CACF;;AAKL,MAAI,0BAA0B,SAAS,EACrC,OAAM;GACJ,GAAG;GACH,eAAe;IACb,GAAG,cAAc;KAChB,MAAA,yBAA+B;IACjC;GACF;;CAIL,EAAA,UAAY,QAAiC;AAC3C,UAAQ,OAAO,IAAf;GACE,KAAK;GACL,KAAK;AACH,WAAO,MAAA,gBAAsB,OAAO;AACpC;GACF,KAAK;AACH,WACE,wBACE,OAAO,GAAsB,KAC7B,OAAO,GAAkB,KACzB,MAAA,SACD,EACD,2CACD;AACD,WAAO,MAAA,gBAAsB,QAAQ,KAAK;AAC1C;GAEF,KAAK;AACH,WAAO,MAAA,gBAAsB,QAAQ,KAAK;AAC1C;;;CAIN,EAAA,gBAAkB,QAAgB,QAAmC;AACnE,QAAA,wBAA8B;AAC9B,QAAA,gCAAsC,KAAA;AACtC,MAAI;GACF,MAAM,aAAa,oBACjB,OAAO,GAAkB,KACzB,MAAA,UACA,MAAA,UACD;GACD,MAAM,mBAAmB,aACrB,MAAA,OAAa,MAAM,EAAC,YAAW,CAAC,GAChC,EAAE;AACN,QAAK,MAAM,cAAc,kBAAkB;AACzC,QAAI,eAAe,SAAS;AAC1B,WAAM;AACN;;AAEF,UAAA,wBAA8B;AAC9B,UAAA,gCAAsC,WAAW;IACjD,MAAM,wBAAwB;KAC5B,MAAM,aAAa,oBACjB,WAAW,KACX,MAAA,WACA,MAAA,SACD;AACD,YAAO,aAAa,MAAA,MAAY,MAAM,EAAC,YAAW,CAAC,GAAG,EAAE;;AAE1D,QAAI,CAAC,OACH,MAAK,MAAM,aAAa,iBAAiB,EAAE;AACzC,SAAI,cAAc,SAAS;AACzB,YAAM;AACN;;AAEF,SACE,MAAA,MACG,WAAW,CACX,YAAY,UAAU,KAAK,OAAO,GAAkB,IAAI,KAAK,GAChE;AACA,eAAS;AACT;;;AAIN,QAAI,OACF,QAAO,MAAA,OAAa,KAClB,gBACE;KACE,GAAG;KACH,eAAe;MACb,GAAG,WAAW;OACb,MAAA,mBAAyB;MAC3B;KACF,EACD;KACE,kBAAkB,MAAA;KAClB;KACD,CACF,EACD,KACD;SACI;KACL,MAAM,UAAU;MACd,GAAG;MACH,eAAe;OACb,GAAG,WAAW;QACb,MAAA,yBAA+B,CAAC,OAAO,GAAkB;OAC3D;MACF;AACD,YAAO,MAAA,OAAa,KAClB,OAAO,OAAsB,IACzB,cAAc,QAAQ,GACtB,iBAAiB,QAAQ,EAC7B,KACD;;;YAGG;AACR,SAAA,wBAA8B,KAAA;;;CAIlC,EAAA,WAAa,QAAiC;EAC5C,MAAM,mBAAmB,eAAqB;GAC5C,MAAM,aAAa,oBACjB,KAAK,KACL,MAAA,WACA,MAAA,SACD;AACD,UAAO,aAAa,MAAA,MAAY,MAAM,EAAC,YAAW,CAAC,GAAG,EAAE;;EAG1D,MAAM,QAAQ,UAAgB;GAC5B,GAAG;GACH,eAAe;IACb,GAAG,KAAK;KACP,MAAA,mBAAyB,gBAAgB,KAAK;IAChD;GACF;EAGD,IAAI,kBAAkB;AACtB,OAAK,MAAM,QAAQ,gBAAgB,OAAO,GAAkB,EAAE,CAC5D,KAAI,SAAS,SAAS;AACpB,SAAM;AACN;SACK;AACL,qBAAkB;AAClB;;AAGJ,MAAI,CAAC,gBACH;AAGF,UAAQ,OAAO,IAAf;GACE,KAAK;AACH,WAAO,MAAA,OAAa,KAClB,cAAc,KAAK,OAAO,GAAkB,CAAC,EAC7C,KACD;AACD;GACF,KAAK;AACH,WAAO,MAAA,OAAa,KAClB,iBAAiB,KAAK,OAAO,GAAkB,CAAC,EAChD,KACD;AACD;GACF,KAAK;AACH,WAAO,MAAA,OAAa,KAClB,gBACE,KAAK,OAAO,GAAkB,EAC9B,OAAO,GACR,EACD,KACD;AACD;GAEF,KAAK;AACH,WACE,wBACE,OAAO,GAAsB,KAC7B,OAAO,GAAkB,KACzB,MAAA,UACD,EACD,4CACD;AACD,WAAO,MAAA,OAAa,KAClB,eACE,KAAK,OAAO,GAAkB,EAC9B,KAAK,OAAO,GAAsB,CACnC,EACD,KACD;AACD;GAEF,QACE,aAAY,OAAO;;;;;;;;;;;AAY3B,SAAgB,aACd,QACA,MACQ;AACR,KAAI,KAAK,WAAW,EAClB,QAAO,eAAe,OAAO,KAAK,IAAI;CAExC,IAAI,IAAI;AACR,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,MAAI,IAAI,EAAG,MAAK;AAChB,OAAK,eAAe,OAAO,KAAK,IAAI;;AAEtC,QAAO;;AAGT,SAAS,eAAe,GAAuC;AAI7D,KAAI,MAAM,QAAQ,MAAM,KAAA,EAAW,QAAO;CAC1C,MAAM,IAAI,OAAO;AACjB,KAAI,MAAM,SAAU,QAAO,MAAO;AAClC,KAAI,MAAM,SAAU,QAAO,MAAO;AAClC,KAAI,MAAM,SAAU,QAAO,MAAO,EAAa,UAAU;AACzD,KAAI,MAAM,UAAW,QAAO,IAAI,MAAM;AACtC,QAAO,MAAM,KAAK,UAAU,EAAE"}

package/out/zql/src/ivm/join-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"join-utils.js","names":[],"sources":["../../../../../zql/src/ivm/join-utils.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {compareValues, valuesEqual, type Node} from './data.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport function generateWithOverlayNoYield(\n  stream: Stream<Node>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node> {\n  return generateWithOverlay(stream, overlay, schema) as Stream<Node>;\n}\n\nexport function* generateWithOverlay(\n  stream: Stream<Node | 'yield'>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node | 'yield'> {\n  let applied = false;\n  let editOldApplied = false;\n  let editNewApplied = false;\n  for (const node of stream) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    let yieldNode = true;\n    if (!applied) {\n      switch (overlay[ChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          if (\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            applied = true;\n            yieldNode = false;\n          }\n          break;\n        }\n        case ChangeType.REMOVE: {\n          if (schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) < 0) {\n            applied = true;\n            yield overlay[ChangeIndex.NODE];\n          }\n          break;\n        }\n        case ChangeType.EDIT: {\n          if (\n            !editOldApplied &&\n            schema.compareRows(overlay[ChangeIndex.OLD_NODE].row, node.row) < 0\n          ) {\n            editOldApplied = true;\n            if (editNewApplied) {\n              applied = true;\n            }\n            yield overlay[ChangeIndex.OLD_NODE];\n          }\n          if (\n            !editNewApplied &&\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            editNewApplied = true;\n            if (editOldApplied) {\n              applied = true;\n            }\n            yieldNode = false;\n          }\n          break;\n        }\n        case ChangeType.CHILD: {\n          if (\n            schema.compareRows(overlay[ChangeIndex.NODE].row, node.row) === 0\n          ) {\n            applied = true;\n            yield {\n              row: node.row,\n              relationships: {\n                ...node.relationships,\n                [overlay[ChangeIndex.CHILD_DATA].relationshipName]: () =>\n                  generateWithOverlay(\n                    node.relationships[\n                      overlay[ChangeIndex.CHILD_DATA].relationshipName\n                    ](),\n                    overlay[ChangeIndex.CHILD_DATA].change,\n                    schema.relationships[\n                      overlay[ChangeIndex.CHILD_DATA].relationshipName\n                    ],\n                  ),\n              },\n            };\n            yieldNode = false;\n          }\n          break;\n        }\n      }\n    }\n    if (yieldNode) {\n      yield node;\n    }\n  }\n  if (!applied) {\n    if (overlay[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      applied = true;\n      yield overlay[ChangeIndex.NODE];\n    } else if (overlay[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      assert(\n        editNewApplied,\n        'edit overlay: new node must be applied before old node',\n      );\n      editOldApplied = true;\n      applied = true;\n      yield overlay[ChangeIndex.OLD_NODE];\n    }\n  }\n\n  assert(\n    applied,\n    'overlayGenerator: overlay was never applied to any fetched node',\n  );\n}\n\nexport function generateWithOverlayNoYieldUnordered(\n  stream: Stream<Node>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node> {\n  return generateWithOverlayUnordered(stream, overlay, schema) as Stream<Node>;\n}\n\nexport function* generateWithOverlayUnordered(\n  stream: Stream<Node | 'yield'>,\n  overlay: Change,\n  schema: SourceSchema,\n): Stream<Node | 'yield'> {\n  // Eager inject\n  if (overlay[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n    yield overlay[ChangeIndex.NODE];\n  } else if (overlay[ChangeIndex.TYPE] === ChangeType.EDIT) {\n    yield overlay[ChangeIndex.OLD_NODE];\n  }\n\n  // Stream with inline suppress\n  let suppressed = false;\n  for (const node of stream) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!suppressed) {\n      if (\n        overlay[ChangeIndex.TYPE] === ChangeType.ADD ||\n        overlay[ChangeIndex.TYPE] === ChangeType.EDIT\n      ) {\n        if (\n          rowEqualsForCompoundKey(\n            overlay[ChangeIndex.NODE].row,\n            node.row,\n            schema.primaryKey,\n          )\n        ) {\n          suppressed = true;\n          continue;\n        }\n      }\n      if (overlay[ChangeIndex.TYPE] === ChangeType.CHILD) {\n        if (\n          rowEqualsForCompoundKey(\n            overlay[ChangeIndex.NODE].row,\n            node.row,\n            schema.primaryKey,\n          )\n        ) {\n          suppressed = true;\n          yield {\n            row: node.row,\n            relationships: {\n              ...node.relationships,\n              [overlay[ChangeIndex.CHILD_DATA].relationshipName]: () =>\n                generateWithOverlay(\n                  node.relationships[\n                    overlay[ChangeIndex.CHILD_DATA].relationshipName\n                  ](),\n                  overlay[ChangeIndex.CHILD_DATA].change,\n                  schema.relationships[\n                    overlay[ChangeIndex.CHILD_DATA].relationshipName\n                  ],\n                ),\n            },\n          };\n          continue;\n        }\n      }\n    }\n    yield node;\n  }\n  assert(\n    suppressed || overlay[ChangeIndex.TYPE] === ChangeType.REMOVE,\n    'overlayGenerator: overlay was never applied to any fetched node',\n  );\n}\n\nexport function rowEqualsForCompoundKey(\n  a: Row,\n  b: Row,\n  key: CompoundKey,\n): boolean {\n  for (let i = 0; i < key.length; i++) {\n    if (compareValues(a[key[i]], b[key[i]]) !== 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isJoinMatch(\n  parent: Row,\n  parentKey: CompoundKey,\n  child: Row,\n  childKey: CompoundKey,\n) {\n  for (let i = 0; i < parentKey.length; i++) {\n    if (!valuesEqual(parent[parentKey[i]], child[childKey[i]])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Builds a constraint object by mapping values from `sourceRow` using `sourceKey`\n * to keys specified by `targetKey`. Returns `undefined` if any source value is `null`,\n * since null foreign keys cannot match any rows.\n */\nexport function buildJoinConstraint(\n  sourceRow: Row,\n  sourceKey: CompoundKey,\n  targetKey: CompoundKey,\n): Record<string, Value> | undefined {\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < targetKey.length; i++) {\n    const value = sourceRow[sourceKey[i]];\n    if (value === null) {\n      return undefined;\n    }\n    constraint[targetKey[i]] = value;\n  }\n  return constraint;\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"join.js","names":["#parent","#child","#parentKey","#childKey","#relationshipName","#schema","#pushParent","#pushChild","#output","#processParentNode","#pushChildChange","#inprogressChildChange","#inprogressChildChangePosition"],"sources":["../../../../../zql/src/ivm/join.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey, System} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Node} from './data.ts';\nimport {\n  buildJoinConstraint,\n  generateWithOverlay,\n  generateWithOverlayUnordered,\n  isJoinMatch,\n  rowEqualsForCompoundKey,\n} from './join-utils.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\ntype Args = {\n  parent: Input;\n  child: Input;\n  // The nth key in parentKey corresponds to the nth key in childKey.\n  parentKey: CompoundKey;\n  childKey: CompoundKey;\n  relationshipName: string;\n  hidden: boolean;\n  system: System;\n};\n\n/**\n * The Join operator joins the output from two upstream inputs. Zero's join\n * is a little different from SQL's join in that we output hierarchical data,\n * not a flat table. This makes it a lot more useful for UI programming and\n * avoids duplicating tons of data like left join would.\n *\n * The Nodes output from Join have a new relationship added to them, which has\n * the name #relationshipName. The value of the relationship is a stream of\n * child nodes which are the corresponding values from the child source.\n */\nexport class Join implements Input {\n  readonly #parent: Input;\n  readonly #child: Input;\n  readonly #parentKey: CompoundKey;\n  readonly #childKey: CompoundKey;\n  readonly #relationshipName: string;\n  readonly #schema: SourceSchema;\n\n  #output: Output = throwOutput;\n\n  #inprogressChildChange: Change | undefined;\n  #inprogressChildChangePosition: Row | undefined;\n\n  constructor({\n    parent,\n    child,\n    parentKey,\n    childKey,\n    relationshipName,\n    hidden,\n    system,\n  }: Args) {\n    assert(parent !== child, 'Parent and child must be different operators');\n    assert(\n      parentKey.length === childKey.length,\n      'The parentKey and childKey keys must have same length',\n    );\n    this.#parent = parent;\n    this.#child = child;\n    this.#parentKey = parentKey;\n    this.#childKey = childKey;\n    this.#relationshipName = relationshipName;\n\n    const parentSchema = parent.getSchema();\n    const childSchema = child.getSchema();\n    this.#schema = {\n      ...parentSchema,\n      relationships: {\n        ...parentSchema.relationships,\n        [relationshipName]: {\n          ...childSchema,\n          isHidden: hidden,\n          system,\n        },\n      },\n    };\n\n    parent.setOutput({\n      push: (change: Change) => this.#pushParent(change),\n    });\n    child.setOutput({\n      push: (change: Change) => this.#pushChild(change),\n    });\n  }\n\n  destroy(): void {\n    this.#parent.destroy();\n    this.#child.destroy();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    for (const parentNode of this.#parent.fetch(req)) {\n      if (parentNode === 'yield') {\n        yield parentNode;\n        continue;\n      }\n      yield this.#processParentNode(parentNode.row, parentNode.relationships);\n    }\n  }\n\n  *#pushParent(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        yield* this.#output.push(\n          makeAddChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      case ChangeType.REMOVE:\n        yield* this.#output.push(\n          makeRemoveChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      case ChangeType.CHILD:\n        yield* this.#output.push(\n          makeChildChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n            change[ChangeIndex.CHILD_DATA],\n          ),\n          this,\n        );\n        break;\n      case ChangeType.EDIT: {\n        // Assert the edit could not change the relationship.\n        assert(\n          rowEqualsForCompoundKey(\n            change[ChangeIndex.OLD_NODE].row,\n            change[ChangeIndex.NODE].row,\n            this.#parentKey,\n          ),\n          `Parent edit must not change relationship.`,\n        );\n        yield* this.#output.push(\n          makeEditChange(\n            this.#processParentNode(\n              change[ChangeIndex.NODE].row,\n              change[ChangeIndex.NODE].relationships,\n            ),\n            this.#processParentNode(\n              change[ChangeIndex.OLD_NODE].row,\n              change[ChangeIndex.OLD_NODE].relationships,\n            ),\n          ),\n          this,\n        );\n        break;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n\n  *#pushChild(change: Change): Stream<'yield'> {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n      case ChangeType.REMOVE:\n        yield* this.#pushChildChange(change[ChangeIndex.NODE].row, change);\n        break;\n      case ChangeType.CHILD:\n        yield* this.#pushChildChange(change[ChangeIndex.NODE].row, change);\n        break;\n      case ChangeType.EDIT: {\n        const childRow = change[ChangeIndex.NODE].row;\n        const oldChildRow = change[ChangeIndex.OLD_NODE].row;\n        // Assert the edit could not change the relationship.\n        assert(\n          rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey),\n          'Child edit must not change relationship.',\n        );\n        yield* this.#pushChildChange(childRow, change);\n        break;\n      }\n\n      default:\n        unreachable(change);\n    }\n  }\n\n  *#pushChildChange(childRow: Row, change: Change): Stream<'yield'> {\n    this.#inprogressChildChange = change;\n    this.#inprogressChildChangePosition = undefined;\n    try {\n      const constraint = buildJoinConstraint(\n        childRow,\n        this.#childKey,\n        this.#parentKey,\n      );\n      if (constraint) {\n        for (const parentNode of this.#parent.fetch({constraint})) {\n          if (parentNode === 'yield') {\n            yield parentNode;\n            continue;\n          }\n          this.#inprogressChildChangePosition = parentNode.row;\n          const childChange = makeChildChange(\n            this.#processParentNode(parentNode.row, parentNode.relationships),\n            {\n              relationshipName: this.#relationshipName,\n              change,\n            },\n          );\n          yield* this.#output.push(childChange, this);\n        }\n      }\n    } finally {\n      this.#inprogressChildChange = undefined;\n    }\n  }\n\n  #processParentNode(\n    parentNodeRow: Row,\n    parentNodeRelations: Record<string, () => Stream<Node | 'yield'>>,\n  ): Node {\n    const childStream = () => {\n      const constraint = buildJoinConstraint(\n        parentNodeRow,\n        this.#parentKey,\n        this.#childKey,\n      );\n      const stream = constraint ? this.#child.fetch({constraint}) : [];\n\n      if (\n        this.#inprogressChildChange &&\n        isJoinMatch(\n          parentNodeRow,\n          this.#parentKey,\n          this.#inprogressChildChange[ChangeIndex.NODE].row,\n          this.#childKey,\n        ) &&\n        this.#inprogressChildChangePosition &&\n        this.#schema.compareRows(\n          parentNodeRow,\n          this.#inprogressChildChangePosition,\n        ) > 0\n      ) {\n        const childSchema = this.#child.getSchema();\n        if (childSchema.sort === undefined) {\n          return generateWithOverlayUnordered(\n            stream,\n            this.#inprogressChildChange,\n            childSchema,\n          );\n        }\n        return generateWithOverlay(\n          stream,\n          this.#inprogressChildChange,\n          childSchema,\n        );\n      }\n      return stream;\n    };\n\n    return {\n      row: parentNodeRow,\n      relationships: {\n        ...parentNodeRelations,\n        [this.#relationshipName]: childStream,\n      },\n    };\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/maybe-split-and-push-edit-change.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"maybe-split-and-push-edit-change.js","names":[],"sources":["../../../../../zql/src/ivm/maybe-split-and-push-edit-change.ts"],"sourcesContent":["import type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {makeAddChange, makeRemoveChange, type EditChange} from './change.ts';\nimport type {InputBase, Output} from './operator.ts';\n\n/**\n * This takes an {@linkcode EditChange} and a predicate that determines if a row\n * should be present based on the row's data. It then splits the change and\n * pushes the appropriate changes to the output based on the predicate.\n */\nexport function* maybeSplitAndPushEditChange(\n  change: EditChange,\n  predicate: (row: Row) => boolean,\n  output: Output,\n  pusher: InputBase,\n) {\n  const oldWasPresent = predicate(change[ChangeIndex.OLD_NODE].row);\n  const newIsPresent = predicate(change[ChangeIndex.NODE].row);\n\n  if (oldWasPresent && newIsPresent) {\n    yield* output.push(change, pusher);\n  } else if (oldWasPresent && !newIsPresent) {\n    yield* output.push(makeRemoveChange(change[ChangeIndex.OLD_NODE]), pusher);\n  } else if (!oldWasPresent && newIsPresent) {\n    yield* output.push(makeAddChange(change[ChangeIndex.NODE]), pusher);\n  }\n}\n"],"mappings":";;;;;;;AAUA,UAAiB,4BACf,QACA,WACA,QACA,QACA;CACA,MAAM,gBAAgB,UAAU,OAAO,GAAsB,IAAI;CACjE,MAAM,eAAe,UAAU,OAAO,GAAkB,IAAI;AAE5D,KAAI,iBAAiB,aACnB,QAAO,OAAO,KAAK,QAAQ,OAAO;UACzB,iBAAiB,CAAC,aAC3B,QAAO,OAAO,KAAK,iBAAiB,OAAO,GAAsB,EAAE,OAAO;UACjE,CAAC,iBAAiB,aAC3B,QAAO,OAAO,KAAK,cAAc,OAAO,GAAkB,EAAE,OAAO"}