@rocicorp/zero 1.3.0-canary.3 → 1.3.1-canary.1

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

@@ -1,7 +1,6 @@
 import { assert, unreachable } from "../../../shared/src/asserts.js";
 import { must } from "../../../shared/src/must.js";
 import { emptyArray } from "../../../shared/src/sentinels.js";
-import { makeAddChange, makeChildChange, makeEditChange, makeRemoveChange } from "./change.js";
 //#region ../zql/src/ivm/push-accumulated.ts
 /**
 * # pushAccumulatedChanges
@@ -76,11 +75,11 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 	if (accumulatedPushes.length === 0) return;
 	const candidatesToPush = /* @__PURE__ */ new Map();
 	for (const change of accumulatedPushes) {
-		if (fanOutChangeType === 3 && change[0] !== 3) assert(candidatesToPush.has(change[0]) === false, () => `Fan-in:child expected at most one ${change[0]} when fan-out is of type child`);
-		const existing = candidatesToPush.get(change[0]);
+		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[0], mergedChange);
+		candidatesToPush.set(change.type, mergedChange);
 	}
 	accumulatedPushes.length = 0;
 	const types = [...candidatesToPush.keys()];
@@ -95,19 +94,19 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 	*    - Many child changes because other operators may preserve the child change
 	*/
 	switch (fanOutChangeType) {
-		case 1:
-			assert(types.length === 1 && types[0] === 1, "Fan-in:remove expected all removes");
-			yield* output.push(addEmptyRelationships(must(candidatesToPush.get(1))), pusher);
+		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 0:
-			assert(types.length === 1 && types[0] === 0, "Fan-in:add expected all adds");
-			yield* output.push(addEmptyRelationships(must(candidatesToPush.get(0))), pusher);
+		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 2: {
-			assert(types.every((type) => type === 0 || type === 1 || type === 2), "Fan-in:edit expected all adds, removes, or edits");
-			const addChange = candidatesToPush.get(0);
-			const removeChange = candidatesToPush.get(1);
-			let editChange = candidatesToPush.get(2);
+		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);
@@ -115,22 +114,26 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 				return;
 			}
 			if (addChange && removeChange) {
-				yield* output.push(addEmptyRelationships(makeEditChange(addChange[1], removeChange[1])), pusher);
+				yield* output.push(addEmptyRelationships({
+					type: "edit",
+					node: addChange.node,
+					oldNode: removeChange.node
+				}), pusher);
 				return;
 			}
 			yield* output.push(addEmptyRelationships(must(addChange ?? removeChange)), pusher);
 			return;
 		}
-		case 3: {
-			assert(types.every((type) => type === 0 || type === 1 || type === 3), "Fan-in:child expected all adds, removes, or children");
+		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(3);
+			const childChange = candidatesToPush.get("child");
 			if (childChange) {
 				yield* output.push(childChange, pusher);
 				return;
 			}
-			const addChange = candidatesToPush.get(0);
-			const removeChange = candidatesToPush.get(1);
+			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;
@@ -142,99 +145,120 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 * Puts relationships from `right` into `left` if they don't already exist in `left`.
 */
 function mergeRelationships(left, right) {
-	if (left[0] === right[0]) switch (left[0]) {
-		case 0: return makeAddChange({
-			row: left[1].row,
-			relationships: {
-				...right[1].relationships,
-				...left[1].relationships
-			}
-		});
-		case 1: return makeRemoveChange({
-			row: left[1].row,
-			relationships: {
-				...right[1].relationships,
-				...left[1].relationships
+	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 2:
-			assert(right[0] === 2, () => `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right[0]}`);
-			return makeEditChange({
-				row: left[1].row,
+		};
+		case "remove": return {
+			type: "remove",
+			node: {
+				row: left.node.row,
 				relationships: {
-					...right[1].relationships,
-					...left[1].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
+					}
 				}
-			}, {
-				row: left[2].row,
+			};
+		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[2].relationships,
-					...left[2].relationships
+					...right.node.relationships,
+					...left.node.relationships
 				}
-			});
-		case 3:
-			assert(right[0] === 3, () => `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right[0]}`);
-			return makeChildChange({
-				row: left[1].row,
+			},
+			oldNode: left.oldNode
+		};
+		case "remove": return {
+			type: "edit",
+			node: left.node,
+			oldNode: {
+				...left.oldNode,
 				relationships: {
-					...right[1].relationships,
-					...left[1].relationships
+					...right.node.relationships,
+					...left.oldNode.relationships
 				}
-			}, left[2]);
-	}
-	assert(left[0] === 2, () => `mergeRelationships: when types differ, left.type must be edit, got left.type=${left[0]}, right.type=${right[0]}`);
-	switch (right[0]) {
-		case 0: return makeEditChange({
-			...left[1],
-			relationships: {
-				...right[1].relationships,
-				...left[1].relationships
 			}
-		}, left[2]);
-		case 1: return makeEditChange(left[1], {
-			...left[2],
-			relationships: {
-				...right[1].relationships,
-				...left[2].relationships
-			}
-		});
+		};
 	}
 	unreachable();
 }
 function makeAddEmptyRelationships(schema) {
 	return (change) => {
 		if (Object.keys(schema.relationships).length === 0) return change;
-		switch (change[0]) {
-			case 0: {
-				const relationships = { ...change[1].relationships };
-				mergeEmpty(relationships, Object.keys(schema.relationships));
-				return makeAddChange({
-					row: change[1].row,
-					relationships
-				});
-			}
-			case 1: {
-				const relationships = { ...change[1].relationships };
-				mergeEmpty(relationships, Object.keys(schema.relationships));
-				return makeRemoveChange({
-					row: change[1].row,
-					relationships
-				});
+		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 2: {
-				const nodeRelationships = { ...change[1].relationships };
-				const oldNodeRelationships = { ...change[2].relationships };
-				mergeEmpty(nodeRelationships, Object.keys(schema.relationships));
-				mergeEmpty(oldNodeRelationships, Object.keys(schema.relationships));
-				return makeEditChange({
-					row: change[1].row,
-					relationships: nodeRelationships
-				}, {
-					row: change[2].row,
-					relationships: oldNodeRelationships
-				});
+			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 3: return change;
+			case "child": return change;
 		}
 	};
 }

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

@@ -1 +1 @@
-{"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 {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 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: ChangeType,\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<ChangeType, Change>();\n  for (const change of accumulatedPushes) {\n    if (\n      fanOutChangeType === ChangeType.CHILD &&\n      change[ChangeIndex.TYPE] !== ChangeType.CHILD\n    ) {\n      assert(\n        candidatesToPush.has(change[ChangeIndex.TYPE]) === false,\n        () =>\n          `Fan-in:child expected at most one ${change[ChangeIndex.TYPE]} when fan-out is of type child`,\n      );\n    }\n\n    const existing = candidatesToPush.get(change[ChangeIndex.TYPE]);\n    let mergedChange = change;\n    if (existing) {\n      // merge in relationships\n      mergedChange = mergeRelationships(existing, change);\n    }\n    candidatesToPush.set(change[ChangeIndex.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 ChangeType.REMOVE:\n      assert(\n        types.length === 1 && types[0] === ChangeType.REMOVE,\n        'Fan-in:remove expected all removes',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.REMOVE))),\n        pusher,\n      );\n      return;\n    case ChangeType.ADD:\n      assert(\n        types.length === 1 && types[0] === ChangeType.ADD,\n        'Fan-in:add expected all adds',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.ADD))),\n        pusher,\n      );\n      return;\n    case ChangeType.EDIT: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD ||\n            type === ChangeType.REMOVE ||\n            type === ChangeType.EDIT,\n        ),\n        'Fan-in:edit expected all adds, removes, or edits',\n      );\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n      let editChange = candidatesToPush.get(ChangeType.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            makeEditChange(\n              addChange[ChangeIndex.NODE],\n              removeChange[ChangeIndex.NODE],\n            ),\n          ),\n          pusher,\n        );\n        return;\n      }\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    case ChangeType.CHILD: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD || // exists can change child to add or remove\n            type === ChangeType.REMOVE || // exists can change child to add or remove\n            type === ChangeType.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(ChangeType.CHILD);\n      if (childChange) {\n        yield* output.push(childChange, pusher);\n        return;\n      }\n\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.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[ChangeIndex.TYPE] === right[ChangeIndex.TYPE]) {\n    switch (left[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        return makeAddChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.REMOVE: {\n        return makeRemoveChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.EDIT: {\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.EDIT,\n          () =>\n            `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right[ChangeIndex.TYPE]}`,\n        );\n        // merge edits into a single edit\n        return makeEditChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          {\n            row: left[ChangeIndex.OLD_NODE].row,\n            relationships: {\n              ...right[ChangeIndex.OLD_NODE].relationships,\n              ...left[ChangeIndex.OLD_NODE].relationships,\n            },\n          },\n        );\n      }\n      case ChangeType.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[ChangeIndex.TYPE] === ChangeType.CHILD,\n          () =>\n            `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right[ChangeIndex.TYPE]}`,\n        );\n        return makeChildChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          left[ChangeIndex.CHILD_DATA],\n        );\n      }\n    }\n  }\n\n  // left is always an edit here\n  assert(\n    left[ChangeIndex.TYPE] === ChangeType.EDIT,\n    () =>\n      `mergeRelationships: when types differ, left.type must be edit, got left.type=${left[ChangeIndex.TYPE]}, right.type=${right[ChangeIndex.TYPE]}`,\n  );\n  switch (right[ChangeIndex.TYPE]) {\n    case ChangeType.ADD: {\n      return makeEditChange(\n        {\n          ...left[ChangeIndex.NODE],\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        },\n        left[ChangeIndex.OLD_NODE],\n      );\n    }\n    case ChangeType.REMOVE: {\n      return makeEditChange(left[ChangeIndex.NODE], {\n        ...left[ChangeIndex.OLD_NODE],\n        relationships: {\n          ...right[ChangeIndex.NODE].relationships,\n          ...left[ChangeIndex.OLD_NODE].relationships,\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[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeAddChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.REMOVE: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeRemoveChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.EDIT: {\n        const nodeRelationships = {...change[ChangeIndex.NODE].relationships};\n        const oldNodeRelationships = {\n          ...change[ChangeIndex.OLD_NODE].relationships,\n        };\n        mergeEmpty(nodeRelationships, Object.keys(schema.relationships));\n        mergeEmpty(oldNodeRelationships, Object.keys(schema.relationships));\n        return makeEditChange(\n          {row: change[ChangeIndex.NODE].row, relationships: nodeRelationships},\n          {\n            row: change[ChangeIndex.OLD_NODE].row,\n            relationships: oldNodeRelationships,\n          },\n        );\n      }\n      case ChangeType.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":"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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"}

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

@@ -1,5 +1,5 @@
 import type { Row } from '../../../zero-protocol/src/data.ts';
-import { type Change } from './change.ts';
+import type { Change } from './change.ts';
 import type { Node } from './data.ts';
 import { type FetchRequest, type Input, type Operator, type Output } from './operator.ts';
 import type { SourceSchema } from './schema.ts';

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

@@ -1 +1 @@
-{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAG5D,OAAO,EAEL,KAAK,MAAM,EAGZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAEhD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,IAAK,YAAW,QAAQ;;gBAOvB,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;IAStC,SAAS,IAAI,YAAY;IAIxB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC;IAsBjD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,OAAO,IAAI,IAAI;IASd,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;CA+EvC"}
+{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAY,MAAM,EAA4B,MAAM,aAAa,CAAC;AAC9E,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAEhD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,IAAK,YAAW,QAAQ;;gBAOvB,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;IAStC,SAAS,IAAI,YAAY;IAIxB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC;IAsBjD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,OAAO,IAAI,IAAI;IASd,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;CA+EvC"}

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

@@ -54,11 +54,11 @@ var Skip = class {
 	}
 	*push(change) {
 		const shouldBePresent = (row) => this.#shouldBePresent(row);
-		if (change[0] === 2) {
+		if (change.type === "edit") {
 			yield* maybeSplitAndPushEditChange(change, shouldBePresent, this.#output, this);
 			return;
 		}
-		if (shouldBePresent(change[1].row)) yield* this.#output.push(change, this);
+		if (shouldBePresent(change.node.row)) yield* this.#output.push(change, this);
 	}
 	#getStart(req) {
 		const boundStart = {

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

@@ -1 +1 @@
-{"version":3,"file":"skip.js","names":["#input","#bound","#comparator","#getStart","#shouldBePresent","#output"],"sources":["../../../../../zql/src/ivm/skip.ts"],"sourcesContent":["import {assert} 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 {\n  type AddChange,\n  type Change,\n  type ChildChange,\n  type RemoveChange,\n} from './change.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Bound = {\n  row: Row;\n  exclusive: boolean;\n};\n\n/**\n * Skip sets the start position for the pipeline. No rows before the bound will\n * be output.\n */\nexport class Skip implements Operator {\n  readonly #input: Input;\n  readonly #bound: Bound;\n  readonly #comparator: Comparator;\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, bound: Bound) {\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Skip requires sorted input');\n    this.#input = input;\n    this.#bound = bound;\n    this.#comparator = input.getSchema().compareRows;\n    input.setOutput(this);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const start = this.#getStart(req);\n    if (start === 'empty') {\n      return;\n    }\n    const nodes = this.#input.fetch({...req, start});\n    if (!req.reverse) {\n      yield* nodes;\n      return;\n    }\n    for (const node of nodes) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (!this.#shouldBePresent(node.row)) {\n        return;\n      }\n      yield node;\n    }\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  #shouldBePresent(row: Row): boolean {\n    const cmp = this.#comparator(this.#bound.row, row);\n    return cmp < 0 || (cmp === 0 && !this.#bound.exclusive);\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const shouldBePresent = (row: Row) => this.#shouldBePresent(row);\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* maybeSplitAndPushEditChange(\n        change,\n        shouldBePresent,\n        this.#output,\n        this,\n      );\n      return;\n    }\n\n    change satisfies AddChange | RemoveChange | ChildChange;\n\n    if (shouldBePresent(change[ChangeIndex.NODE].row)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  #getStart(req: FetchRequest): Start | undefined | 'empty' {\n    const boundStart = {\n      row: this.#bound.row,\n      basis: this.#bound.exclusive ? 'after' : 'at',\n    } as const;\n\n    if (!req.start) {\n      if (req.reverse) {\n        return undefined;\n      }\n      return boundStart;\n    }\n\n    const cmp = this.#comparator(this.#bound.row, req.start.row);\n\n    if (!req.reverse) {\n      // The skip bound is after the requested bound. The requested bound cannot\n      // be relevant because even if it was basis: 'after', the skip bound is\n      // itself after the requested bound. Return the skip bound.\n      if (cmp > 0) {\n        return boundStart;\n      }\n\n      // The skip bound and requested bound are equal. If either is exclusive,\n      // return that bound with exclusive. Otherwise, return the skip bound.\n      if (cmp === 0) {\n        if (this.#bound.exclusive || req.start.basis === 'after') {\n          return {\n            row: this.#bound.row,\n            basis: 'after',\n          };\n        }\n        return boundStart;\n      }\n\n      return req.start;\n    }\n\n    req.reverse satisfies true;\n\n    // bound is after the start, but request is for reverse so results\n    // must be empty\n    if (cmp > 0) {\n      return 'empty';\n    }\n\n    if (cmp === 0) {\n      // if both are inclusive, the result can be the single row at bound\n      // return it as start\n      if (!this.#bound.exclusive && req.start.basis === 'at') {\n        return boundStart;\n      }\n      // otherwise the results must be empty, one or both are exclusive\n      // in opposite directions\n      return 'empty';\n    }\n\n    // bound is before the start, return start\n    return req.start;\n  }\n}\n"],"mappings":";;;;;;;;AAgCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,WAAW;AAChC,SAAO,SAAS,KAAA,GAAW,6BAA6B;AACxD,QAAA,QAAc;AACd,QAAA,QAAc;AACd,QAAA,aAAmB,MAAM,WAAW,CAAC;AACrC,QAAM,UAAU,KAAK;;CAGvB,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,MAAA,SAAe,IAAI;AACjC,MAAI,UAAU,QACZ;EAEF,MAAM,QAAQ,MAAA,MAAY,MAAM;GAAC,GAAG;GAAK;GAAM,CAAC;AAChD,MAAI,CAAC,IAAI,SAAS;AAChB,UAAO;AACP;;AAEF,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,SAAS,SAAS;AACpB,UAAM;AACN;;AAEF,OAAI,CAAC,MAAA,gBAAsB,KAAK,IAAI,CAClC;AAEF,SAAM;;;CAIV,UAAU,QAAsB;AAC9B,QAAA,SAAe;;CAGjB,UAAgB;AACd,QAAA,MAAY,SAAS;;CAGvB,iBAAiB,KAAmB;EAClC,MAAM,MAAM,MAAA,WAAiB,MAAA,MAAY,KAAK,IAAI;AAClD,SAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,MAAA,MAAY;;CAG/C,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,MAAA,gBAAsB,IAAI;AAChE,MAAI,OAAO,OAAsB,GAAiB;AAChD,UAAO,4BACL,QACA,iBACA,MAAA,QACA,KACD;AACD;;AAKF,MAAI,gBAAgB,OAAO,GAAkB,IAAI,CAC/C,QAAO,MAAA,OAAa,KAAK,QAAQ,KAAK;;CAI1C,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,MAAA,MAAY;GACjB,OAAO,MAAA,MAAY,YAAY,UAAU;GAC1C;AAED,MAAI,CAAC,IAAI,OAAO;AACd,OAAI,IAAI,QACN;AAEF,UAAO;;EAGT,MAAM,MAAM,MAAA,WAAiB,MAAA,MAAY,KAAK,IAAI,MAAM,IAAI;AAE5D,MAAI,CAAC,IAAI,SAAS;AAIhB,OAAI,MAAM,EACR,QAAO;AAKT,OAAI,QAAQ,GAAG;AACb,QAAI,MAAA,MAAY,aAAa,IAAI,MAAM,UAAU,QAC/C,QAAO;KACL,KAAK,MAAA,MAAY;KACjB,OAAO;KACR;AAEH,WAAO;;AAGT,UAAO,IAAI;;AAGb,MAAI;AAIJ,MAAI,MAAM,EACR,QAAO;AAGT,MAAI,QAAQ,GAAG;AAGb,OAAI,CAAC,MAAA,MAAY,aAAa,IAAI,MAAM,UAAU,KAChD,QAAO;AAIT,UAAO;;AAIT,SAAO,IAAI"}
+{"version":3,"file":"skip.js","names":["#input","#bound","#comparator","#getStart","#shouldBePresent","#output"],"sources":["../../../../../zql/src/ivm/skip.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {AddChange, Change, ChildChange, RemoveChange} from './change.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Bound = {\n  row: Row;\n  exclusive: boolean;\n};\n\n/**\n * Skip sets the start position for the pipeline. No rows before the bound will\n * be output.\n */\nexport class Skip implements Operator {\n  readonly #input: Input;\n  readonly #bound: Bound;\n  readonly #comparator: Comparator;\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, bound: Bound) {\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Skip requires sorted input');\n    this.#input = input;\n    this.#bound = bound;\n    this.#comparator = input.getSchema().compareRows;\n    input.setOutput(this);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const start = this.#getStart(req);\n    if (start === 'empty') {\n      return;\n    }\n    const nodes = this.#input.fetch({...req, start});\n    if (!req.reverse) {\n      yield* nodes;\n      return;\n    }\n    for (const node of nodes) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (!this.#shouldBePresent(node.row)) {\n        return;\n      }\n      yield node;\n    }\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  #shouldBePresent(row: Row): boolean {\n    const cmp = this.#comparator(this.#bound.row, row);\n    return cmp < 0 || (cmp === 0 && !this.#bound.exclusive);\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const shouldBePresent = (row: Row) => this.#shouldBePresent(row);\n    if (change.type === 'edit') {\n      yield* maybeSplitAndPushEditChange(\n        change,\n        shouldBePresent,\n        this.#output,\n        this,\n      );\n      return;\n    }\n\n    change satisfies AddChange | RemoveChange | ChildChange;\n\n    if (shouldBePresent(change.node.row)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  #getStart(req: FetchRequest): Start | undefined | 'empty' {\n    const boundStart = {\n      row: this.#bound.row,\n      basis: this.#bound.exclusive ? 'after' : 'at',\n    } as const;\n\n    if (!req.start) {\n      if (req.reverse) {\n        return undefined;\n      }\n      return boundStart;\n    }\n\n    const cmp = this.#comparator(this.#bound.row, req.start.row);\n\n    if (!req.reverse) {\n      // The skip bound is after the requested bound. The requested bound cannot\n      // be relevant because even if it was basis: 'after', the skip bound is\n      // itself after the requested bound. Return the skip bound.\n      if (cmp > 0) {\n        return boundStart;\n      }\n\n      // The skip bound and requested bound are equal. If either is exclusive,\n      // return that bound with exclusive. Otherwise, return the skip bound.\n      if (cmp === 0) {\n        if (this.#bound.exclusive || req.start.basis === 'after') {\n          return {\n            row: this.#bound.row,\n            basis: 'after',\n          };\n        }\n        return boundStart;\n      }\n\n      return req.start;\n    }\n\n    req.reverse satisfies true;\n\n    // bound is after the start, but request is for reverse so results\n    // must be empty\n    if (cmp > 0) {\n      return 'empty';\n    }\n\n    if (cmp === 0) {\n      // if both are inclusive, the result can be the single row at bound\n      // return it as start\n      if (!this.#bound.exclusive && req.start.basis === 'at') {\n        return boundStart;\n      }\n      // otherwise the results must be empty, one or both are exclusive\n      // in opposite directions\n      return 'empty';\n    }\n\n    // bound is before the start, return start\n    return req.start;\n  }\n}\n"],"mappings":";;;;;;;;AAyBA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,WAAW;AAChC,SAAO,SAAS,KAAA,GAAW,6BAA6B;AACxD,QAAA,QAAc;AACd,QAAA,QAAc;AACd,QAAA,aAAmB,MAAM,WAAW,CAAC;AACrC,QAAM,UAAU,KAAK;;CAGvB,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,MAAA,SAAe,IAAI;AACjC,MAAI,UAAU,QACZ;EAEF,MAAM,QAAQ,MAAA,MAAY,MAAM;GAAC,GAAG;GAAK;GAAM,CAAC;AAChD,MAAI,CAAC,IAAI,SAAS;AAChB,UAAO;AACP;;AAEF,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,SAAS,SAAS;AACpB,UAAM;AACN;;AAEF,OAAI,CAAC,MAAA,gBAAsB,KAAK,IAAI,CAClC;AAEF,SAAM;;;CAIV,UAAU,QAAsB;AAC9B,QAAA,SAAe;;CAGjB,UAAgB;AACd,QAAA,MAAY,SAAS;;CAGvB,iBAAiB,KAAmB;EAClC,MAAM,MAAM,MAAA,WAAiB,MAAA,MAAY,KAAK,IAAI;AAClD,SAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,MAAA,MAAY;;CAG/C,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,MAAA,gBAAsB,IAAI;AAChE,MAAI,OAAO,SAAS,QAAQ;AAC1B,UAAO,4BACL,QACA,iBACA,MAAA,QACA,KACD;AACD;;AAKF,MAAI,gBAAgB,OAAO,KAAK,IAAI,CAClC,QAAO,MAAA,OAAa,KAAK,QAAQ,KAAK;;CAI1C,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,MAAA,MAAY;GACjB,OAAO,MAAA,MAAY,YAAY,UAAU;GAC1C;AAED,MAAI,CAAC,IAAI,OAAO;AACd,OAAI,IAAI,QACN;AAEF,UAAO;;EAGT,MAAM,MAAM,MAAA,WAAiB,MAAA,MAAY,KAAK,IAAI,MAAM,IAAI;AAE5D,MAAI,CAAC,IAAI,SAAS;AAIhB,OAAI,MAAM,EACR,QAAO;AAKT,OAAI,QAAQ,GAAG;AACb,QAAI,MAAA,MAAY,aAAa,IAAI,MAAM,UAAU,QAC/C,QAAO;KACL,KAAK,MAAA,MAAY;KACjB,OAAO;KACR;AAEH,WAAO;;AAGT,UAAO,IAAI;;AAGb,MAAI;AAIJ,MAAI,MAAM,EACR,QAAO;AAGT,MAAI,QAAQ,GAAG;AAGb,OAAI,CAAC,MAAA,MAAY,aAAa,IAAI,MAAM,UAAU,KAChD,QAAO;AAIT,UAAO;;AAIT,SAAO,IAAI"}

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

@@ -2,20 +2,22 @@ import type { Condition, Ordering } from '../../../zero-protocol/src/ast.ts';
 import type { Row } from '../../../zero-protocol/src/data.ts';
 import type { TableSchema } from '../../../zero-types/src/schema.ts';
 import type { DebugDelegate } from '../builder/debug-delegate.ts';
-import { ChangeType } from './change-type.ts';
 import type { Input } from './operator.ts';
 import type { Stream } from './stream.ts';
-export type SourceChangeAdd = [type: ChangeType.ADD, row: Row, extra: null];
-export type SourceChangeRemove = [
-    type: ChangeType.REMOVE,
-    row: Row,
-    extra: null
-];
-export type SourceChangeEdit = [type: ChangeType.EDIT, row: Row, oldRow: Row];
+export type SourceChangeAdd = {
+    type: 'add';
+    row: Row;
+};
+export type SourceChangeRemove = {
+    type: 'remove';
+    row: Row;
+};
+export type SourceChangeEdit = {
+    type: 'edit';
+    row: Row;
+    oldRow: Row;
+};
 export type SourceChange = SourceChangeAdd | SourceChangeRemove | SourceChangeEdit;
-export declare function makeSourceChangeAdd(row: Row): SourceChangeAdd;
-export declare function makeSourceChangeRemove(row: Row): SourceChangeRemove;
-export declare function makeSourceChangeEdit(row: Row, oldRow: Row): SourceChangeEdit;
 /**
  * A source is an input that serves as the root data source of the pipeline.
  * Sources have multiple outputs. To add an output, call `connect()`, then

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

@@ -1 +1 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,mCAAmC,CAAC;AAC3E,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,UAAU,CAAC,MAAM;IACvB,GAAG,EAAE,GAAG;IACR,KAAK,EAAE,IAAI;CACZ,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AAE9E,MAAM,MAAM,YAAY,GACpB,eAAe,GACf,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,GAAG,eAAe,CAE7D;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,kBAAkB,CAEnE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,gBAAgB,CAE5E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,MAAM;IACrB,IAAI,WAAW,IAAI,WAAW,CAAC;IAC/B;;;;;;;;;;;OAWG;IACH,OAAO,CACL,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,OAAO,CAAC,EAAE,SAAS,EACnB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC3B,KAAK,CAAC,EAAE,aAAa,GACpB,WAAW,CAAC;IAEf;;;;;;;;OAQG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAE5C;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,WAAY,SAAQ,KAAK;IACxC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC"}
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,mCAAmC,CAAC;AAC3E,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,GAAG,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,GAAG,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,MAAM,EAAE,GAAG,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,YAAY,GACpB,eAAe,GACf,kBAAkB,GAClB,gBAAgB,CAAC;AAErB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,MAAM;IACrB,IAAI,WAAW,IAAI,WAAW,CAAC;IAC/B;;;;;;;;;;;OAWG;IACH,OAAO,CACL,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,OAAO,CAAC,EAAE,SAAS,EACnB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC3B,KAAK,CAAC,EAAE,aAAa,GACpB,WAAW,CAAC;IAEf;;;;;;;;OAQG;IACH,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAE5C;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,WAAY,SAAQ,KAAK;IACxC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC"}

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

@@ -1 +1 @@
-{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAI1E,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAiBxC,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ;;gBAYjC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY;IAe7B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,SAAS,IAAI,YAAY;IAIxB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC;IA0JhD,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;IA0ctC,OAAO,IAAI,IAAI;CAGhB;AAmBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,GACzB,UAAU,CAUZ"}
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAE1E,OAAO,EAAC,KAAK,MAAM,EAAqC,MAAM,aAAa,CAAC;AAC5E,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAiBxC,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ;;gBAYjC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY;IAe7B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,SAAS,IAAI,YAAY;IAIxB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC;IA0JhD,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;IA4dtC,OAAO,IAAI,IAAI;CAGhB;AAmBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,GACzB,UAAU,CAUZ"}