@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/zql/src/ivm/push-accumulated.js

@@ -1,280 +1,277 @@
 import { assert, unreachable } from "../../../shared/src/asserts.js";
 import { must } from "../../../shared/src/must.js";
 import { emptyArray } from "../../../shared/src/sentinels.js";
-function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChangeType, mergeRelationships2, addEmptyRelationships) {
-  if (accumulatedPushes.length === 0) {
-    return;
-  }
-  const candidatesToPush = /* @__PURE__ */ new Map();
-  for (const change of accumulatedPushes) {
-    if (fanOutChangeType === "child" && change.type !== "child") {
-      assert(
-        candidatesToPush.has(change.type) === false,
-        () => `Fan-in:child expected at most one ${change.type} when fan-out is of type child`
-      );
-    }
-    const existing = candidatesToPush.get(change.type);
-    let mergedChange = change;
-    if (existing) {
-      mergedChange = mergeRelationships2(existing, change);
-    }
-    candidatesToPush.set(change.type, mergedChange);
-  }
-  accumulatedPushes.length = 0;
-  const types = [...candidatesToPush.keys()];
-  switch (fanOutChangeType) {
-    case "remove":
-      assert(
-        types.length === 1 && types[0] === "remove",
-        "Fan-in:remove expected all removes"
-      );
-      yield* output.push(
-        addEmptyRelationships(must(candidatesToPush.get("remove"))),
-        pusher
-      );
-      return;
-    case "add":
-      assert(
-        types.length === 1 && types[0] === "add",
-        "Fan-in:add expected all adds"
-      );
-      yield* output.push(
-        addEmptyRelationships(must(candidatesToPush.get("add"))),
-        pusher
-      );
-      return;
-    case "edit": {
-      assert(
-        types.every(
-          (type) => type === "add" || type === "remove" || type === "edit"
-        ),
-        "Fan-in:edit expected all adds, removes, or edits"
-      );
-      const addChange = candidatesToPush.get("add");
-      const removeChange = candidatesToPush.get("remove");
-      let editChange = candidatesToPush.get("edit");
-      if (editChange) {
-        if (addChange) {
-          editChange = mergeRelationships2(editChange, addChange);
-        }
-        if (removeChange) {
-          editChange = mergeRelationships2(editChange, removeChange);
-        }
-        yield* output.push(addEmptyRelationships(editChange), pusher);
-        return;
-      }
-      if (addChange && removeChange) {
-        yield* output.push(
-          addEmptyRelationships({
-            type: "edit",
-            node: addChange.node,
-            oldNode: removeChange.node
-          }),
-          pusher
-        );
-        return;
-      }
-      yield* output.push(
-        addEmptyRelationships(must(addChange ?? removeChange)),
-        pusher
-      );
-      return;
-    }
-    case "child": {
-      assert(
-        types.every(
-          (type) => type === "add" || // exists can change child to add or remove
-          type === "remove" || // exists can change child to add or remove
-          type === "child"
-          // other operators may preserve the child change
-        ),
-        "Fan-in:child expected all adds, removes, or children"
-      );
-      assert(
-        types.length <= 2,
-        "Fan-in:child expected at most 2 types on a child change from fan-out"
-      );
-      const childChange = candidatesToPush.get("child");
-      if (childChange) {
-        yield* output.push(childChange, pusher);
-        return;
-      }
-      const addChange = candidatesToPush.get("add");
-      const removeChange = candidatesToPush.get("remove");
-      assert(
-        addChange === void 0 || removeChange === void 0,
-        "Fan-in:child expected either add or remove, not both"
-      );
-      yield* output.push(
-        addEmptyRelationships(must(addChange ?? removeChange)),
-        pusher
-      );
-      return;
-    }
-  }
+//#region ../zql/src/ivm/push-accumulated.ts
+/**
+* # pushAccumulatedChanges
+*
+* Pushes the changes that were accumulated by
+* [fan-out, fan-in] or [ufo, ufi] sub-graphs.
+*
+* This function is called at the end of the sub-graph.
+*
+* The sub-graphs represents `OR`s.
+*
+* Changes that can enter the subgraphs:
+* 1. child (due to exist joins being above the sub-graph)
+* 2. add
+* 3. remove
+* 4. edit
+*
+* # Changes that can exit into `pushAccumulatedChanges`:
+*
+* ## Child
+* If a `child` change enters a sub-graph, it will flow to all branches.
+* Each branch will either:
+* - preserve the `child` change
+* - stop the `child` change (e.g., filter)
+* - convert it to an `add` or `remove` (e.g., exists filter)
+*
+* ## Add
+* If an `add` change enters a sub-graph, it will flow to all branches.
+* Each branch will either:
+* - preserve the `add` change
+* - hide the change (e.g., filter)
+*
+* ## Remove
+* If a `remove` change enters a sub-graph, it will flow to all branches.
+* Each branch will either:
+* - preserve the `remove` change
+* - hide the change (e.g., filter)
+*
+* ## Edit
+* If an `edit` change enters a sub-graph, it will flow to all branches.
+* Each branch will either:
+* - preserve the `edit` change
+* - convert it to an `add` (e.g., filter where old didn't match but new does)
+* - convert it to a `remove` (e.g., filter where old matched but new doesn't)
+*
+* This results in some invariants:
+* - an add coming in will only create adds coming out
+* - a remove coming in will only create removes coming out
+* - an edit coming in can create adds, removes, and edits coming out
+* - a child coming in can create adds, removes, and children coming out
+*
+* # Return of `pushAccumulatedChanges`
+*
+* This function will only push a single change.
+* Given the above invariants, how is this possible?
+*
+* An add that becomes many `adds` results in a single add
+* as the `add` is the same row across all adds. Branches do not change the row.
+*
+* A remove that becomes many `removes` results in a single remove
+* for the same reason.
+*
+* If a child enters and exits, it takes precedence over all other changes.
+* If a child enters and is converted only to add and remove it exits as an edit.
+* If a child enters and is converted to only add or only remove, it exits as that change.
+*
+* If an edit enters and is converted to add and remove it exits as an edit.
+* If an edit enters and is converted to only add or only remove, it exits as that change.
+* If an edit enters and exits as edits only, it exits as a single edit.
+*/
+function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChangeType, mergeRelationships, addEmptyRelationships) {
+	if (accumulatedPushes.length === 0) return;
+	const candidatesToPush = /* @__PURE__ */ new Map();
+	for (const change of accumulatedPushes) {
+		if (fanOutChangeType === "child" && change.type !== "child") assert(candidatesToPush.has(change.type) === false, () => `Fan-in:child expected at most one ${change.type} when fan-out is of type child`);
+		const existing = candidatesToPush.get(change.type);
+		let mergedChange = change;
+		if (existing) mergedChange = mergeRelationships(existing, change);
+		candidatesToPush.set(change.type, mergedChange);
+	}
+	accumulatedPushes.length = 0;
+	const types = [...candidatesToPush.keys()];
+	/**
+	* Based on the received `fanOutChangeType` only certain output types are valid.
+	*
+	* - remove must result in all removes
+	* - add must result in all adds
+	* - edit must result in add or removes or edits
+	* - child must result in a single add or single remove or many child changes
+	*    - Single add or remove because the relationship will be unique to one exist check within the fan-out,fan-in sub-graph
+	*    - Many child changes because other operators may preserve the child change
+	*/
+	switch (fanOutChangeType) {
+		case "remove":
+			assert(types.length === 1 && types[0] === "remove", "Fan-in:remove expected all removes");
+			yield* output.push(addEmptyRelationships(must(candidatesToPush.get("remove"))), pusher);
+			return;
+		case "add":
+			assert(types.length === 1 && types[0] === "add", "Fan-in:add expected all adds");
+			yield* output.push(addEmptyRelationships(must(candidatesToPush.get("add"))), pusher);
+			return;
+		case "edit": {
+			assert(types.every((type) => type === "add" || type === "remove" || type === "edit"), "Fan-in:edit expected all adds, removes, or edits");
+			const addChange = candidatesToPush.get("add");
+			const removeChange = candidatesToPush.get("remove");
+			let editChange = candidatesToPush.get("edit");
+			if (editChange) {
+				if (addChange) editChange = mergeRelationships(editChange, addChange);
+				if (removeChange) editChange = mergeRelationships(editChange, removeChange);
+				yield* output.push(addEmptyRelationships(editChange), pusher);
+				return;
+			}
+			if (addChange && removeChange) {
+				yield* output.push(addEmptyRelationships({
+					type: "edit",
+					node: addChange.node,
+					oldNode: removeChange.node
+				}), pusher);
+				return;
+			}
+			yield* output.push(addEmptyRelationships(must(addChange ?? removeChange)), pusher);
+			return;
+		}
+		case "child": {
+			assert(types.every((type) => type === "add" || type === "remove" || type === "child"), "Fan-in:child expected all adds, removes, or children");
+			assert(types.length <= 2, "Fan-in:child expected at most 2 types on a child change from fan-out");
+			const childChange = candidatesToPush.get("child");
+			if (childChange) {
+				yield* output.push(childChange, pusher);
+				return;
+			}
+			const addChange = candidatesToPush.get("add");
+			const removeChange = candidatesToPush.get("remove");
+			assert(addChange === void 0 || removeChange === void 0, "Fan-in:child expected either add or remove, not both");
+			yield* output.push(addEmptyRelationships(must(addChange ?? removeChange)), pusher);
+			return;
+		}
+		default:
+	}
 }
+/**
+* Puts relationships from `right` into `left` if they don't already exist in `left`.
+*/
 function mergeRelationships(left, right) {
-  if (left.type === right.type) {
-    switch (left.type) {
-      case "add": {
-        return {
-          type: "add",
-          node: {
-            row: left.node.row,
-            relationships: {
-              ...right.node.relationships,
-              ...left.node.relationships
-            }
-          }
-        };
-      }
-      case "remove": {
-        return {
-          type: "remove",
-          node: {
-            row: left.node.row,
-            relationships: {
-              ...right.node.relationships,
-              ...left.node.relationships
-            }
-          }
-        };
-      }
-      case "edit": {
-        assert(
-          right.type === "edit",
-          () => `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right.type}`
-        );
-        return {
-          type: "edit",
-          node: {
-            row: left.node.row,
-            relationships: {
-              ...right.node.relationships,
-              ...left.node.relationships
-            }
-          },
-          oldNode: {
-            row: left.oldNode.row,
-            relationships: {
-              ...right.oldNode.relationships,
-              ...left.oldNode.relationships
-            }
-          }
-        };
-      }
-      case "child": {
-        assert(
-          right.type === "child",
-          () => `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right.type}`
-        );
-        return {
-          type: "child",
-          node: {
-            row: left.node.row,
-            relationships: {
-              ...right.node.relationships,
-              ...left.node.relationships
-            }
-          },
-          child: left.child
-        };
-      }
-    }
-  }
-  assert(
-    left.type === "edit",
-    () => `mergeRelationships: when types differ, left.type must be edit, got left.type=${left.type}, right.type=${right.type}`
-  );
-  switch (right.type) {
-    case "add": {
-      return {
-        type: "edit",
-        node: {
-          ...left.node,
-          relationships: {
-            ...right.node.relationships,
-            ...left.node.relationships
-          }
-        },
-        oldNode: left.oldNode
-      };
-    }
-    case "remove": {
-      return {
-        type: "edit",
-        node: left.node,
-        oldNode: {
-          ...left.oldNode,
-          relationships: {
-            ...right.node.relationships,
-            ...left.oldNode.relationships
-          }
-        }
-      };
-    }
-  }
-  unreachable();
+	if (left.type === right.type) switch (left.type) {
+		case "add": return {
+			type: "add",
+			node: {
+				row: left.node.row,
+				relationships: {
+					...right.node.relationships,
+					...left.node.relationships
+				}
+			}
+		};
+		case "remove": return {
+			type: "remove",
+			node: {
+				row: left.node.row,
+				relationships: {
+					...right.node.relationships,
+					...left.node.relationships
+				}
+			}
+		};
+		case "edit":
+			assert(right.type === "edit", () => `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right.type}`);
+			return {
+				type: "edit",
+				node: {
+					row: left.node.row,
+					relationships: {
+						...right.node.relationships,
+						...left.node.relationships
+					}
+				},
+				oldNode: {
+					row: left.oldNode.row,
+					relationships: {
+						...right.oldNode.relationships,
+						...left.oldNode.relationships
+					}
+				}
+			};
+		case "child":
+			assert(right.type === "child", () => `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right.type}`);
+			return {
+				type: "child",
+				node: {
+					row: left.node.row,
+					relationships: {
+						...right.node.relationships,
+						...left.node.relationships
+					}
+				},
+				child: left.child
+			};
+	}
+	assert(left.type === "edit", () => `mergeRelationships: when types differ, left.type must be edit, got left.type=${left.type}, right.type=${right.type}`);
+	switch (right.type) {
+		case "add": return {
+			type: "edit",
+			node: {
+				...left.node,
+				relationships: {
+					...right.node.relationships,
+					...left.node.relationships
+				}
+			},
+			oldNode: left.oldNode
+		};
+		case "remove": return {
+			type: "edit",
+			node: left.node,
+			oldNode: {
+				...left.oldNode,
+				relationships: {
+					...right.node.relationships,
+					...left.oldNode.relationships
+				}
+			}
+		};
+	}
+	unreachable();
 }
 function makeAddEmptyRelationships(schema) {
-  return (change) => {
-    if (Object.keys(schema.relationships).length === 0) {
-      return change;
-    }
-    switch (change.type) {
-      case "add":
-      case "remove": {
-        const ret = {
-          ...change,
-          node: {
-            ...change.node,
-            relationships: {
-              ...change.node.relationships
-            }
-          }
-        };
-        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));
-        return ret;
-      }
-      case "edit": {
-        const ret = {
-          ...change,
-          node: {
-            ...change.node,
-            relationships: {
-              ...change.node.relationships
-            }
-          },
-          oldNode: {
-            ...change.oldNode,
-            relationships: {
-              ...change.oldNode.relationships
-            }
-          }
-        };
-        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));
-        mergeEmpty(
-          ret.oldNode.relationships,
-          Object.keys(schema.relationships)
-        );
-        return ret;
-      }
-      case "child":
-        return change;
-    }
-  };
+	return (change) => {
+		if (Object.keys(schema.relationships).length === 0) return change;
+		switch (change.type) {
+			case "add":
+			case "remove": {
+				const ret = {
+					...change,
+					node: {
+						...change.node,
+						relationships: { ...change.node.relationships }
+					}
+				};
+				mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));
+				return ret;
+			}
+			case "edit": {
+				const ret = {
+					...change,
+					node: {
+						...change.node,
+						relationships: { ...change.node.relationships }
+					},
+					oldNode: {
+						...change.oldNode,
+						relationships: { ...change.oldNode.relationships }
+					}
+				};
+				mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));
+				mergeEmpty(ret.oldNode.relationships, Object.keys(schema.relationships));
+				return ret;
+			}
+			case "child": return change;
+		}
+	};
 }
+/**
+* For each relationship in `schema` that does not exist
+* in `relationships`, add it with an empty stream.
+*
+* This modifies the `relationships` object in place.
+*/
 function mergeEmpty(relationships, relationshipNames) {
-  for (const relName of relationshipNames) {
-    if (relationships[relName] === void 0) {
-      relationships[relName] = () => emptyArray;
-    }
-  }
+	for (const relName of relationshipNames) if (relationships[relName] === void 0) relationships[relName] = () => emptyArray;
 }
-export {
-  makeAddEmptyRelationships,
-  mergeEmpty,
-  mergeRelationships,
-  pushAccumulatedChanges
-};
-//# sourceMappingURL=push-accumulated.js.map
+//#endregion
+export { makeAddEmptyRelationships, mergeRelationships, pushAccumulatedChanges };
+
+//# sourceMappingURL=push-accumulated.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"push-accumulated.js","sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {Change} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {InputBase, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * # pushAccumulatedChanges\n *\n * Pushes the changes that were accumulated by\n * [fan-out, fan-in] or [ufo, ufi] sub-graphs.\n *\n * This function is called at the end of the sub-graph.\n *\n * The sub-graphs represents `OR`s.\n *\n * Changes that can enter the subgraphs:\n * 1. child (due to exist joins being above the sub-graph)\n * 2. add\n * 3. remove\n * 4. edit\n *\n * # Changes that can exit into `pushAccumulatedChanges`:\n *\n * ## Child\n * If a `child` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `child` change\n * - stop the `child` change (e.g., filter)\n * - convert it to an `add` or `remove` (e.g., exists filter)\n *\n * ## Add\n * If an `add` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `add` change\n * - hide the change (e.g., filter)\n *\n * ## Remove\n * If a `remove` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `remove` change\n * - hide the change (e.g., filter)\n *\n * ## Edit\n * If an `edit` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `edit` change\n * - convert it to an `add` (e.g., filter where old didn't match but new does)\n * - convert it to a `remove` (e.g., filter where old matched but new doesn't)\n *\n * This results in some invariants:\n * - an add coming in will only create adds coming out\n * - a remove coming in will only create removes coming out\n * - an edit coming in can create adds, removes, and edits coming out\n * - a child coming in can create adds, removes, and children coming out\n *\n * # Return of `pushAccumulatedChanges`\n *\n * This function will only push a single change.\n * Given the above invariants, how is this possible?\n *\n * An add that becomes many `adds` results in a single add\n * as the `add` is the same row across all adds. Branches do not change the row.\n *\n * A remove that becomes many `removes` results in a single remove\n * for the same reason.\n *\n * If a child enters and exits, it takes precedence over all other changes.\n * If a child enters and is converted only to add and remove it exits as an edit.\n * If a child enters and is converted to only add or only remove, it exits as that change.\n *\n * If an edit enters and is converted to add and remove it exits as an edit.\n * If an edit enters and is converted to only add or only remove, it exits as that change.\n * If an edit enters and exits as edits only, it exits as a single edit.\n */\nexport function* pushAccumulatedChanges(\n  accumulatedPushes: Change[],\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: Change['type'],\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n): Stream<'yield'> {\n  if (accumulatedPushes.length === 0) {\n    // It is possible for no forks to pass along the push.\n    // E.g., if no filters match in any fork.\n    return;\n  }\n\n  // collapse down to a single change per type\n  const candidatesToPush = new Map<Change['type'], Change>();\n  for (const change of accumulatedPushes) {\n    if (fanOutChangeType === 'child' && change.type !== 'child') {\n      assert(\n        candidatesToPush.has(change.type) === false,\n        () =>\n          `Fan-in:child expected at most one ${change.type} when fan-out is of type child`,\n      );\n    }\n\n    const existing = candidatesToPush.get(change.type);\n    let mergedChange = change;\n    if (existing) {\n      // merge in relationships\n      mergedChange = mergeRelationships(existing, change);\n    }\n    candidatesToPush.set(change.type, mergedChange);\n  }\n\n  accumulatedPushes.length = 0;\n\n  const types = [...candidatesToPush.keys()];\n  /**\n   * Based on the received `fanOutChangeType` only certain output types are valid.\n   *\n   * - remove must result in all removes\n   * - add must result in all adds\n   * - edit must result in add or removes or edits\n   * - child must result in a single add or single remove or many child changes\n   *    - Single add or remove because the relationship will be unique to one exist check within the fan-out,fan-in sub-graph\n   *    - Many child changes because other operators may preserve the child change\n   */\n  switch (fanOutChangeType) {\n    case 'remove':\n      assert(\n        types.length === 1 && types[0] === 'remove',\n        'Fan-in:remove expected all removes',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get('remove'))),\n        pusher,\n      );\n      return;\n    case 'add':\n      assert(\n        types.length === 1 && types[0] === 'add',\n        'Fan-in:add expected all adds',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get('add'))),\n        pusher,\n      );\n      return;\n    case 'edit': {\n      assert(\n        types.every(\n          type => type === 'add' || type === 'remove' || type === 'edit',\n        ),\n        'Fan-in:edit expected all adds, removes, or edits',\n      );\n      const addChange = candidatesToPush.get('add');\n      const removeChange = candidatesToPush.get('remove');\n      let editChange = candidatesToPush.get('edit');\n\n      // If an `edit` is present, it supersedes `add` and `remove`\n      // as it semantically represents both.\n      if (editChange) {\n        if (addChange) {\n          editChange = mergeRelationships(editChange, addChange);\n        }\n        if (removeChange) {\n          editChange = mergeRelationships(editChange, removeChange);\n        }\n        yield* output.push(addEmptyRelationships(editChange), pusher);\n        return;\n      }\n\n      // If `edit` didn't make it through but both `add` and `remove` did,\n      // convert back to an edit.\n      //\n      // When can this happen?\n      //\n      //  EDIT old: a=1, new: a=2\n      //            |\n      //          FanOut\n      //          /    \\\n      //         a=1   a=2\n      //          |     |\n      //        remove  add\n      //          \\     /\n      //           FanIn\n      //\n      // The left filter converts the edit into a remove.\n      // The right filter converts the edit into an add.\n      if (addChange && removeChange) {\n        yield* output.push(\n          addEmptyRelationships({\n            type: 'edit',\n            node: addChange.node,\n            oldNode: removeChange.node,\n          } as const),\n          pusher,\n        );\n        return;\n      }\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    case 'child': {\n      assert(\n        types.every(\n          type =>\n            type === 'add' || // exists can change child to add or remove\n            type === 'remove' || // exists can change child to add or remove\n            type === 'child', // other operators may preserve the child change\n        ),\n        'Fan-in:child expected all adds, removes, or children',\n      );\n      assert(\n        types.length <= 2,\n        'Fan-in:child expected at most 2 types on a child change from fan-out',\n      );\n\n      // If any branch preserved the original child change, that takes precedence over all other changes.\n      const childChange = candidatesToPush.get('child');\n      if (childChange) {\n        yield* output.push(childChange, pusher);\n        return;\n      }\n\n      const addChange = candidatesToPush.get('add');\n      const removeChange = candidatesToPush.get('remove');\n\n      assert(\n        addChange === undefined || removeChange === undefined,\n        'Fan-in:child expected either add or remove, not both',\n      );\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    default:\n      fanOutChangeType satisfies never;\n  }\n}\n\n/**\n * Puts relationships from `right` into `left` if they don't already exist in `left`.\n */\nexport function mergeRelationships(left: Change, right: Change): Change {\n  // change types will always match\n  // unless we have an edit on the left\n  // then the right could be edit, add, or remove\n  if (left.type === right.type) {\n    switch (left.type) {\n      case 'add': {\n        return {\n          type: 'add',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n        };\n      }\n      case 'remove': {\n        return {\n          type: 'remove',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n        };\n      }\n      case 'edit': {\n        assert(\n          right.type === 'edit',\n          () =>\n            `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right.type}`,\n        );\n        // merge edits into a single edit\n        return {\n          type: 'edit',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n          oldNode: {\n            row: left.oldNode.row,\n            relationships: {\n              ...right.oldNode.relationships,\n              ...left.oldNode.relationships,\n            },\n          },\n        };\n      }\n      case 'child': {\n        // Multiple branches may preserve the same child change, each adding\n        // different relationships. Merge the relationships, keeping the child\n        // (which should be identical across branches).\n        assert(\n          right.type === 'child',\n          () =>\n            `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right.type}`,\n        );\n        return {\n          type: 'child',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n          child: left.child,\n        };\n      }\n    }\n  }\n\n  // left is always an edit here\n  assert(\n    left.type === 'edit',\n    () =>\n      `mergeRelationships: when types differ, left.type must be edit, got left.type=${left.type}, right.type=${right.type}`,\n  );\n  switch (right.type) {\n    case 'add': {\n      return {\n        type: 'edit',\n        node: {\n          ...left.node,\n          relationships: {\n            ...right.node.relationships,\n            ...left.node.relationships,\n          },\n        },\n        oldNode: left.oldNode,\n      };\n    }\n    case 'remove': {\n      return {\n        type: 'edit',\n        node: left.node,\n        oldNode: {\n          ...left.oldNode,\n          relationships: {\n            ...right.node.relationships,\n            ...left.oldNode.relationships,\n          },\n        },\n      };\n    }\n  }\n\n  unreachable();\n}\n\nexport function makeAddEmptyRelationships(\n  schema: SourceSchema,\n): (change: Change) => Change {\n  return (change: Change): Change => {\n    if (Object.keys(schema.relationships).length === 0) {\n      return change;\n    }\n\n    switch (change.type) {\n      case 'add':\n      case 'remove': {\n        const ret = {\n          ...change,\n          node: {\n            ...change.node,\n            relationships: {\n              ...change.node.relationships,\n            },\n          },\n        };\n\n        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));\n\n        return ret;\n      }\n      case 'edit': {\n        const ret = {\n          ...change,\n          node: {\n            ...change.node,\n            relationships: {\n              ...change.node.relationships,\n            },\n          },\n          oldNode: {\n            ...change.oldNode,\n            relationships: {\n              ...change.oldNode.relationships,\n            },\n          },\n        };\n\n        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));\n        mergeEmpty(\n          ret.oldNode.relationships,\n          Object.keys(schema.relationships),\n        );\n\n        return ret;\n      }\n      case 'child':\n        return change; // children only have relationships along the path to the change\n    }\n  };\n}\n\n/**\n * For each relationship in `schema` that does not exist\n * in `relationships`, add it with an empty stream.\n *\n * This modifies the `relationships` object in place.\n */\nexport function mergeEmpty(\n  relationships: Record<string, () => Stream<Node | 'yield'>>,\n  relationshipNames: string[],\n) {\n  for (const relName of relationshipNames) {\n    if (relationships[relName] === undefined) {\n      relationships[relName] = () => emptyArray;\n    }\n  }\n}\n"],"names":["mergeRelationships"],"mappings":"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"}
+{"version":3,"file":"push-accumulated.js","names":[],"sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {Change} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {InputBase, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * # pushAccumulatedChanges\n *\n * Pushes the changes that were accumulated by\n * [fan-out, fan-in] or [ufo, ufi] sub-graphs.\n *\n * This function is called at the end of the sub-graph.\n *\n * The sub-graphs represents `OR`s.\n *\n * Changes that can enter the subgraphs:\n * 1. child (due to exist joins being above the sub-graph)\n * 2. add\n * 3. remove\n * 4. edit\n *\n * # Changes that can exit into `pushAccumulatedChanges`:\n *\n * ## Child\n * If a `child` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `child` change\n * - stop the `child` change (e.g., filter)\n * - convert it to an `add` or `remove` (e.g., exists filter)\n *\n * ## Add\n * If an `add` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `add` change\n * - hide the change (e.g., filter)\n *\n * ## Remove\n * If a `remove` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `remove` change\n * - hide the change (e.g., filter)\n *\n * ## Edit\n * If an `edit` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `edit` change\n * - convert it to an `add` (e.g., filter where old didn't match but new does)\n * - convert it to a `remove` (e.g., filter where old matched but new doesn't)\n *\n * This results in some invariants:\n * - an add coming in will only create adds coming out\n * - a remove coming in will only create removes coming out\n * - an edit coming in can create adds, removes, and edits coming out\n * - a child coming in can create adds, removes, and children coming out\n *\n * # Return of `pushAccumulatedChanges`\n *\n * This function will only push a single change.\n * Given the above invariants, how is this possible?\n *\n * An add that becomes many `adds` results in a single add\n * as the `add` is the same row across all adds. Branches do not change the row.\n *\n * A remove that becomes many `removes` results in a single remove\n * for the same reason.\n *\n * If a child enters and exits, it takes precedence over all other changes.\n * If a child enters and is converted only to add and remove it exits as an edit.\n * If a child enters and is converted to only add or only remove, it exits as that change.\n *\n * If an edit enters and is converted to add and remove it exits as an edit.\n * If an edit enters and is converted to only add or only remove, it exits as that change.\n * If an edit enters and exits as edits only, it exits as a single edit.\n */\nexport function* pushAccumulatedChanges(\n  accumulatedPushes: Change[],\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: Change['type'],\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n): Stream<'yield'> {\n  if (accumulatedPushes.length === 0) {\n    // It is possible for no forks to pass along the push.\n    // E.g., if no filters match in any fork.\n    return;\n  }\n\n  // collapse down to a single change per type\n  const candidatesToPush = new Map<Change['type'], Change>();\n  for (const change of accumulatedPushes) {\n    if (fanOutChangeType === 'child' && change.type !== 'child') {\n      assert(\n        candidatesToPush.has(change.type) === false,\n        () =>\n          `Fan-in:child expected at most one ${change.type} when fan-out is of type child`,\n      );\n    }\n\n    const existing = candidatesToPush.get(change.type);\n    let mergedChange = change;\n    if (existing) {\n      // merge in relationships\n      mergedChange = mergeRelationships(existing, change);\n    }\n    candidatesToPush.set(change.type, mergedChange);\n  }\n\n  accumulatedPushes.length = 0;\n\n  const types = [...candidatesToPush.keys()];\n  /**\n   * Based on the received `fanOutChangeType` only certain output types are valid.\n   *\n   * - remove must result in all removes\n   * - add must result in all adds\n   * - edit must result in add or removes or edits\n   * - child must result in a single add or single remove or many child changes\n   *    - Single add or remove because the relationship will be unique to one exist check within the fan-out,fan-in sub-graph\n   *    - Many child changes because other operators may preserve the child change\n   */\n  switch (fanOutChangeType) {\n    case 'remove':\n      assert(\n        types.length === 1 && types[0] === 'remove',\n        'Fan-in:remove expected all removes',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get('remove'))),\n        pusher,\n      );\n      return;\n    case 'add':\n      assert(\n        types.length === 1 && types[0] === 'add',\n        'Fan-in:add expected all adds',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get('add'))),\n        pusher,\n      );\n      return;\n    case 'edit': {\n      assert(\n        types.every(\n          type => type === 'add' || type === 'remove' || type === 'edit',\n        ),\n        'Fan-in:edit expected all adds, removes, or edits',\n      );\n      const addChange = candidatesToPush.get('add');\n      const removeChange = candidatesToPush.get('remove');\n      let editChange = candidatesToPush.get('edit');\n\n      // If an `edit` is present, it supersedes `add` and `remove`\n      // as it semantically represents both.\n      if (editChange) {\n        if (addChange) {\n          editChange = mergeRelationships(editChange, addChange);\n        }\n        if (removeChange) {\n          editChange = mergeRelationships(editChange, removeChange);\n        }\n        yield* output.push(addEmptyRelationships(editChange), pusher);\n        return;\n      }\n\n      // If `edit` didn't make it through but both `add` and `remove` did,\n      // convert back to an edit.\n      //\n      // When can this happen?\n      //\n      //  EDIT old: a=1, new: a=2\n      //            |\n      //          FanOut\n      //          /    \\\n      //         a=1   a=2\n      //          |     |\n      //        remove  add\n      //          \\     /\n      //           FanIn\n      //\n      // The left filter converts the edit into a remove.\n      // The right filter converts the edit into an add.\n      if (addChange && removeChange) {\n        yield* output.push(\n          addEmptyRelationships({\n            type: 'edit',\n            node: addChange.node,\n            oldNode: removeChange.node,\n          } as const),\n          pusher,\n        );\n        return;\n      }\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    case 'child': {\n      assert(\n        types.every(\n          type =>\n            type === 'add' || // exists can change child to add or remove\n            type === 'remove' || // exists can change child to add or remove\n            type === 'child', // other operators may preserve the child change\n        ),\n        'Fan-in:child expected all adds, removes, or children',\n      );\n      assert(\n        types.length <= 2,\n        'Fan-in:child expected at most 2 types on a child change from fan-out',\n      );\n\n      // If any branch preserved the original child change, that takes precedence over all other changes.\n      const childChange = candidatesToPush.get('child');\n      if (childChange) {\n        yield* output.push(childChange, pusher);\n        return;\n      }\n\n      const addChange = candidatesToPush.get('add');\n      const removeChange = candidatesToPush.get('remove');\n\n      assert(\n        addChange === undefined || removeChange === undefined,\n        'Fan-in:child expected either add or remove, not both',\n      );\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    default:\n      fanOutChangeType satisfies never;\n  }\n}\n\n/**\n * Puts relationships from `right` into `left` if they don't already exist in `left`.\n */\nexport function mergeRelationships(left: Change, right: Change): Change {\n  // change types will always match\n  // unless we have an edit on the left\n  // then the right could be edit, add, or remove\n  if (left.type === right.type) {\n    switch (left.type) {\n      case 'add': {\n        return {\n          type: 'add',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n        };\n      }\n      case 'remove': {\n        return {\n          type: 'remove',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n        };\n      }\n      case 'edit': {\n        assert(\n          right.type === 'edit',\n          () =>\n            `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right.type}`,\n        );\n        // merge edits into a single edit\n        return {\n          type: 'edit',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n          oldNode: {\n            row: left.oldNode.row,\n            relationships: {\n              ...right.oldNode.relationships,\n              ...left.oldNode.relationships,\n            },\n          },\n        };\n      }\n      case 'child': {\n        // Multiple branches may preserve the same child change, each adding\n        // different relationships. Merge the relationships, keeping the child\n        // (which should be identical across branches).\n        assert(\n          right.type === 'child',\n          () =>\n            `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right.type}`,\n        );\n        return {\n          type: 'child',\n          node: {\n            row: left.node.row,\n            relationships: {\n              ...right.node.relationships,\n              ...left.node.relationships,\n            },\n          },\n          child: left.child,\n        };\n      }\n    }\n  }\n\n  // left is always an edit here\n  assert(\n    left.type === 'edit',\n    () =>\n      `mergeRelationships: when types differ, left.type must be edit, got left.type=${left.type}, right.type=${right.type}`,\n  );\n  switch (right.type) {\n    case 'add': {\n      return {\n        type: 'edit',\n        node: {\n          ...left.node,\n          relationships: {\n            ...right.node.relationships,\n            ...left.node.relationships,\n          },\n        },\n        oldNode: left.oldNode,\n      };\n    }\n    case 'remove': {\n      return {\n        type: 'edit',\n        node: left.node,\n        oldNode: {\n          ...left.oldNode,\n          relationships: {\n            ...right.node.relationships,\n            ...left.oldNode.relationships,\n          },\n        },\n      };\n    }\n  }\n\n  unreachable();\n}\n\nexport function makeAddEmptyRelationships(\n  schema: SourceSchema,\n): (change: Change) => Change {\n  return (change: Change): Change => {\n    if (Object.keys(schema.relationships).length === 0) {\n      return change;\n    }\n\n    switch (change.type) {\n      case 'add':\n      case 'remove': {\n        const ret = {\n          ...change,\n          node: {\n            ...change.node,\n            relationships: {\n              ...change.node.relationships,\n            },\n          },\n        };\n\n        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));\n\n        return ret;\n      }\n      case 'edit': {\n        const ret = {\n          ...change,\n          node: {\n            ...change.node,\n            relationships: {\n              ...change.node.relationships,\n            },\n          },\n          oldNode: {\n            ...change.oldNode,\n            relationships: {\n              ...change.oldNode.relationships,\n            },\n          },\n        };\n\n        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));\n        mergeEmpty(\n          ret.oldNode.relationships,\n          Object.keys(schema.relationships),\n        );\n\n        return ret;\n      }\n      case 'child':\n        return change; // children only have relationships along the path to the change\n    }\n  };\n}\n\n/**\n * For each relationship in `schema` that does not exist\n * in `relationships`, add it with an empty stream.\n *\n * This modifies the `relationships` object in place.\n */\nexport function mergeEmpty(\n  relationships: Record<string, () => Stream<Node | 'yield'>>,\n  relationshipNames: string[],\n) {\n  for (const relName of relationshipNames) {\n    if (relationships[relName] === undefined) {\n      relationships[relName] = () => emptyArray;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,UAAiB,uBACf,mBACA,QACA,QACA,kBACA,oBACA,uBACiB;AACjB,KAAI,kBAAkB,WAAW,EAG/B;CAIF,MAAM,mCAAmB,IAAI,KAA6B;AAC1D,MAAK,MAAM,UAAU,mBAAmB;AACtC,MAAI,qBAAqB,WAAW,OAAO,SAAS,QAClD,QACE,iBAAiB,IAAI,OAAO,KAAK,KAAK,aAEpC,qCAAqC,OAAO,KAAK,gCACpD;EAGH,MAAM,WAAW,iBAAiB,IAAI,OAAO,KAAK;EAClD,IAAI,eAAe;AACnB,MAAI,SAEF,gBAAe,mBAAmB,UAAU,OAAO;AAErD,mBAAiB,IAAI,OAAO,MAAM,aAAa;;AAGjD,mBAAkB,SAAS;CAE3B,MAAM,QAAQ,CAAC,GAAG,iBAAiB,MAAM,CAAC;;;;;;;;;;;AAW1C,SAAQ,kBAAR;EACE,KAAK;AACH,UACE,MAAM,WAAW,KAAK,MAAM,OAAO,UACnC,qCACD;AACD,UAAO,OAAO,KACZ,sBAAsB,KAAK,iBAAiB,IAAI,SAAS,CAAC,CAAC,EAC3D,OACD;AACD;EACF,KAAK;AACH,UACE,MAAM,WAAW,KAAK,MAAM,OAAO,OACnC,+BACD;AACD,UAAO,OAAO,KACZ,sBAAsB,KAAK,iBAAiB,IAAI,MAAM,CAAC,CAAC,EACxD,OACD;AACD;EACF,KAAK,QAAQ;AACX,UACE,MAAM,OACJ,SAAQ,SAAS,SAAS,SAAS,YAAY,SAAS,OACzD,EACD,mDACD;GACD,MAAM,YAAY,iBAAiB,IAAI,MAAM;GAC7C,MAAM,eAAe,iBAAiB,IAAI,SAAS;GACnD,IAAI,aAAa,iBAAiB,IAAI,OAAO;AAI7C,OAAI,YAAY;AACd,QAAI,UACF,cAAa,mBAAmB,YAAY,UAAU;AAExD,QAAI,aACF,cAAa,mBAAmB,YAAY,aAAa;AAE3D,WAAO,OAAO,KAAK,sBAAsB,WAAW,EAAE,OAAO;AAC7D;;AAoBF,OAAI,aAAa,cAAc;AAC7B,WAAO,OAAO,KACZ,sBAAsB;KACpB,MAAM;KACN,MAAM,UAAU;KAChB,SAAS,aAAa;KACvB,CAAU,EACX,OACD;AACD;;AAGF,UAAO,OAAO,KACZ,sBAAsB,KAAK,aAAa,aAAa,CAAC,EACtD,OACD;AACD;;EAEF,KAAK,SAAS;AACZ,UACE,MAAM,OACJ,SACE,SAAS,SACT,SAAS,YACT,SAAS,QACZ,EACD,uDACD;AACD,UACE,MAAM,UAAU,GAChB,uEACD;GAGD,MAAM,cAAc,iBAAiB,IAAI,QAAQ;AACjD,OAAI,aAAa;AACf,WAAO,OAAO,KAAK,aAAa,OAAO;AACvC;;GAGF,MAAM,YAAY,iBAAiB,IAAI,MAAM;GAC7C,MAAM,eAAe,iBAAiB,IAAI,SAAS;AAEnD,UACE,cAAc,KAAA,KAAa,iBAAiB,KAAA,GAC5C,uDACD;AAED,UAAO,OAAO,KACZ,sBAAsB,KAAK,aAAa,aAAa,CAAC,EACtD,OACD;AACD;;EAEF;;;;;;AAQJ,SAAgB,mBAAmB,MAAc,OAAuB;AAItE,KAAI,KAAK,SAAS,MAAM,KACtB,SAAQ,KAAK,MAAb;EACE,KAAK,MACH,QAAO;GACL,MAAM;GACN,MAAM;IACJ,KAAK,KAAK,KAAK;IACf,eAAe;KACb,GAAG,MAAM,KAAK;KACd,GAAG,KAAK,KAAK;KACd;IACF;GACF;EAEH,KAAK,SACH,QAAO;GACL,MAAM;GACN,MAAM;IACJ,KAAK,KAAK,KAAK;IACf,eAAe;KACb,GAAG,MAAM,KAAK;KACd,GAAG,KAAK,KAAK;KACd;IACF;GACF;EAEH,KAAK;AACH,UACE,MAAM,SAAS,cAEb,4FAA4F,MAAM,OACrG;AAED,UAAO;IACL,MAAM;IACN,MAAM;KACJ,KAAK,KAAK,KAAK;KACf,eAAe;MACb,GAAG,MAAM,KAAK;MACd,GAAG,KAAK,KAAK;MACd;KACF;IACD,SAAS;KACP,KAAK,KAAK,QAAQ;KAClB,eAAe;MACb,GAAG,MAAM,QAAQ;MACjB,GAAG,KAAK,QAAQ;MACjB;KACF;IACF;EAEH,KAAK;AAIH,UACE,MAAM,SAAS,eAEb,8FAA8F,MAAM,OACvG;AACD,UAAO;IACL,MAAM;IACN,MAAM;KACJ,KAAK,KAAK,KAAK;KACf,eAAe;MACb,GAAG,MAAM,KAAK;MACd,GAAG,KAAK,KAAK;MACd;KACF;IACD,OAAO,KAAK;IACb;;AAMP,QACE,KAAK,SAAS,cAEZ,gFAAgF,KAAK,KAAK,eAAe,MAAM,OAClH;AACD,SAAQ,MAAM,MAAd;EACE,KAAK,MACH,QAAO;GACL,MAAM;GACN,MAAM;IACJ,GAAG,KAAK;IACR,eAAe;KACb,GAAG,MAAM,KAAK;KACd,GAAG,KAAK,KAAK;KACd;IACF;GACD,SAAS,KAAK;GACf;EAEH,KAAK,SACH,QAAO;GACL,MAAM;GACN,MAAM,KAAK;GACX,SAAS;IACP,GAAG,KAAK;IACR,eAAe;KACb,GAAG,MAAM,KAAK;KACd,GAAG,KAAK,QAAQ;KACjB;IACF;GACF;;AAIL,cAAa;;AAGf,SAAgB,0BACd,QAC4B;AAC5B,SAAQ,WAA2B;AACjC,MAAI,OAAO,KAAK,OAAO,cAAc,CAAC,WAAW,EAC/C,QAAO;AAGT,UAAQ,OAAO,MAAf;GACE,KAAK;GACL,KAAK,UAAU;IACb,MAAM,MAAM;KACV,GAAG;KACH,MAAM;MACJ,GAAG,OAAO;MACV,eAAe,EACb,GAAG,OAAO,KAAK,eAChB;MACF;KACF;AAED,eAAW,IAAI,KAAK,eAAe,OAAO,KAAK,OAAO,cAAc,CAAC;AAErE,WAAO;;GAET,KAAK,QAAQ;IACX,MAAM,MAAM;KACV,GAAG;KACH,MAAM;MACJ,GAAG,OAAO;MACV,eAAe,EACb,GAAG,OAAO,KAAK,eAChB;MACF;KACD,SAAS;MACP,GAAG,OAAO;MACV,eAAe,EACb,GAAG,OAAO,QAAQ,eACnB;MACF;KACF;AAED,eAAW,IAAI,KAAK,eAAe,OAAO,KAAK,OAAO,cAAc,CAAC;AACrE,eACE,IAAI,QAAQ,eACZ,OAAO,KAAK,OAAO,cAAc,CAClC;AAED,WAAO;;GAET,KAAK,QACH,QAAO;;;;;;;;;;AAWf,SAAgB,WACd,eACA,mBACA;AACA,MAAK,MAAM,WAAW,kBACpB,KAAI,cAAc,aAAa,KAAA,EAC7B,eAAc,iBAAiB"}