@rocicorp/zero 1.12.0-canary.1 → 1.12.0-canary.11

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  // Relationships a branch adds (a flipped join's witnesses). Only the union\n  // fan has any; the filter fan passes nothing and behaves as before.\n  isBranchRel?: (name: string) => boolean,\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  // A union nested in a branch keeps the row but reports its witness changes\n  // as child changes on its own branch relationships, around the change it\n  // pushes for the row. (A child change entering through the fan-out is on\n  // one of the fan-out's relationships, never a branch's.) Those are not\n  // candidates to collapse: pass them through around this fan-in's change,\n  // removals (old row) before and additions (new row) after, as the nested\n  // union ordered them.\n  const witnessesLeft: Change[] = [];\n  const witnessesEntered: Change[] = [];\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      isBranchRel &&\n      change[ChangeIndex.TYPE] === ChangeType.CHILD &&\n      isBranchRel(change[ChangeIndex.CHILD_DATA].relationshipName)\n    ) {\n      (change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n      ChangeType.REMOVE\n        ? witnessesLeft\n        : witnessesEntered\n      ).push(change);\n      continue;\n    }\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  assert(\n    candidatesToPush.size > 0,\n    'Fan-in: witness changes without a change for their row',\n  );\n  for (const change of witnessesLeft) {\n    yield* output.push(change, pusher);\n  }\n  yield* pushCollapsed(\n    candidatesToPush,\n    output,\n    pusher,\n    fanOutChangeType,\n    mergeRelationships,\n    addEmptyRelationships,\n    isBranchRel,\n  );\n  for (const change of witnessesEntered) {\n    yield* output.push(change, pusher);\n  }\n}\n\nfunction* pushCollapsed(\n  candidatesToPush: Map<ChangeType, Change>,\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: ChangeType,\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n  isBranchRel: ((name: string) => boolean) | undefined,\n): Stream<'yield'> {\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      // The row stays downstream (a branch kept the edit, or it moved from\n      // one branch to another). Branches it left take their witnesses with\n      // them; branches it entered bring theirs. An edit syncs one row, so\n      // those must travel as child changes around it.\n      if (isBranchRel && (editChange || (addChange && removeChange))) {\n        if (removeChange) {\n          yield* pushWitnessDeltas(\n            removeChange[ChangeIndex.NODE],\n            ChangeType.REMOVE,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        const strip = (n: Node): Node => ({\n          row: n.row,\n          relationships: Object.fromEntries(\n            Object.entries(n.relationships).filter(([k]) => !isBranchRel(k)),\n          ),\n        });\n        yield* output.push(\n          addEmptyRelationships(\n            editChange ??\n              makeEditChange(\n                strip(must(addChange)[ChangeIndex.NODE]),\n                strip(must(removeChange)[ChangeIndex.NODE]),\n              ),\n          ),\n          pusher,\n        );\n        if (addChange) {\n          yield* pushWitnessDeltas(\n            addChange[ChangeIndex.NODE],\n            ChangeType.ADD,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        return;\n      }\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        const left = candidatesToPush.get(ChangeType.REMOVE);\n        const entered = candidatesToPush.get(ChangeType.ADD);\n        if (isBranchRel && left) {\n          yield* pushWitnessDeltas(\n            left[ChangeIndex.NODE],\n            ChangeType.REMOVE,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        yield* output.push(childChange, pusher);\n        if (isBranchRel && entered) {\n          yield* pushWitnessDeltas(\n            entered[ChangeIndex.NODE],\n            ChangeType.ADD,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\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 * The row stays downstream, but it gained (`ADD`) or lost (`REMOVE`) every\n * witness in `node`'s branch relationships. One child change per witness.\n */\nexport function* pushWitnessDeltas(\n  node: Node,\n  type: ChangeType.ADD | ChangeType.REMOVE,\n  isBranchRel: (name: string) => boolean,\n  output: Output,\n  pusher: InputBase,\n): Stream<'yield'> {\n  for (const [relationshipName, children] of Object.entries(\n    node.relationships,\n  )) {\n    if (!isBranchRel(relationshipName)) {\n      continue;\n    }\n    for (const child of children()) {\n      if (child === 'yield') {\n        yield child;\n        continue;\n      }\n      yield* output.push(\n        makeChildChange(node, {\n          relationshipName,\n          change:\n            type === ChangeType.ADD\n              ? makeAddChange(child)\n              : makeRemoveChange(child),\n        }),\n        pusher,\n      );\n    }\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 {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  // Relationships a branch adds (a flipped join's witnesses). Only the union\n  // fan has any; the filter fan passes nothing and behaves as before.\n  isBranchRel?: (name: string) => boolean,\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  // A union nested in a branch keeps the row but reports its witness changes\n  // as child changes on its own branch relationships, around the change it\n  // pushes for the row. (A child change entering through the fan-out is on\n  // one of the fan-out's relationships, never a branch's.) Those are not\n  // candidates to collapse: pass them through around this fan-in's change,\n  // removals (old row) before and additions (new row) after, as the nested\n  // union ordered them.\n  const witnessesLeft: Change[] = [];\n  const witnessesEntered: Change[] = [];\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      isBranchRel &&\n      change[ChangeIndex.TYPE] === ChangeType.CHILD &&\n      isBranchRel(change[ChangeIndex.CHILD_DATA].relationshipName)\n    ) {\n      (change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n      ChangeType.REMOVE\n        ? witnessesLeft\n        : witnessesEntered\n      ).push(change);\n      continue;\n    }\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  assert(\n    candidatesToPush.size > 0,\n    'Fan-in: witness changes without a change for their row',\n  );\n  for (const change of witnessesLeft) {\n    yield* output.push(change, pusher);\n  }\n  yield* pushCollapsed(\n    candidatesToPush,\n    output,\n    pusher,\n    fanOutChangeType,\n    mergeRelationships,\n    addEmptyRelationships,\n    isBranchRel,\n  );\n  for (const change of witnessesEntered) {\n    yield* output.push(change, pusher);\n  }\n}\n\nfunction* pushCollapsed(\n  candidatesToPush: Map<ChangeType, Change>,\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: ChangeType,\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n  isBranchRel: ((name: string) => boolean) | undefined,\n): Stream<'yield'> {\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      // The row stays downstream (a branch kept the edit, or it moved from\n      // one branch to another). Branches it left take their witnesses with\n      // them; branches it entered bring theirs. An edit syncs one row, so\n      // those must travel as child changes around it.\n      if (isBranchRel && (editChange || (addChange && removeChange))) {\n        if (removeChange) {\n          yield* pushWitnessDeltas(\n            removeChange[ChangeIndex.NODE],\n            ChangeType.REMOVE,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        const strip = (n: Node): Node => ({\n          row: n.row,\n          relationships: Object.fromEntries(\n            Object.entries(n.relationships).filter(([k]) => !isBranchRel(k)),\n          ),\n        });\n        yield* output.push(\n          addEmptyRelationships(\n            editChange ??\n              makeEditChange(\n                strip(must(addChange)[ChangeIndex.NODE]),\n                strip(must(removeChange)[ChangeIndex.NODE]),\n              ),\n          ),\n          pusher,\n        );\n        if (addChange) {\n          yield* pushWitnessDeltas(\n            addChange[ChangeIndex.NODE],\n            ChangeType.ADD,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        return;\n      }\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        const left = candidatesToPush.get(ChangeType.REMOVE);\n        const entered = candidatesToPush.get(ChangeType.ADD);\n        if (isBranchRel && left) {\n          yield* pushWitnessDeltas(\n            left[ChangeIndex.NODE],\n            ChangeType.REMOVE,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        yield* output.push(childChange, pusher);\n        if (isBranchRel && entered) {\n          yield* pushWitnessDeltas(\n            entered[ChangeIndex.NODE],\n            ChangeType.ADD,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\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 * The row stays downstream, but it gained (`ADD`) or lost (`REMOVE`) every\n * witness in `node`'s branch relationships. One child change per witness.\n */\nexport function* pushWitnessDeltas(\n  node: Node,\n  type: ChangeType.ADD | ChangeType.REMOVE,\n  isBranchRel: (name: string) => boolean,\n  output: Output,\n  pusher: InputBase,\n): Stream<'yield'> {\n  for (const [relationshipName, children] of Object.entries(\n    node.relationships,\n  )) {\n    if (!isBranchRel(relationshipName)) {\n      continue;\n    }\n    for (const child of children()) {\n      if (child === 'yield') {\n        yield child;\n        continue;\n      }\n      yield* output.push(\n        makeChildChange(node, {\n          relationshipName,\n          change:\n            type === ChangeType.ADD\n              ? makeAddChange(child)\n              : makeRemoveChange(child),\n        }),\n        pusher,\n      );\n    }\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,UAAiB,uBACf,mBACA,QACA,QACA,kBACA,oBACA,uBAGA,aACiB;CACjB,IAAI,kBAAkB,WAAW,GAG/B;CAUF,MAAM,gBAA0B,CAAC;CACjC,MAAM,mBAA6B,CAAC;CAGpC,MAAM,mCAAmB,IAAI,IAAwB;CACrD,KAAK,MAAM,UAAU,mBAAmB;EACtC,IACE,eACA,OAAO,OAAsB,KAC7B,YAAY,OAAO,EAAuB,CAAC,gBAAgB,GAC3D;GACA,CAAC,OAAO,EAAuB,CAAC,OAAO,OACvC,IACI,gBACA,iBAAA,CACF,KAAK,MAAM;GACb;EACF;EACA,IACE,qBAAqB,KACrB,OAAO,OAAsB,GAE7B,OACE,iBAAiB,IAAI,OAAO,EAAiB,MAAM,aAEjD,qCAAqC,OAAO,GAAkB,+BAClE;EAGF,MAAM,WAAW,iBAAiB,IAAI,OAAO,EAAiB;EAC9D,IAAI,eAAe;EACnB,IAAI,UAEF,eAAe,mBAAmB,UAAU,MAAM;EAEpD,iBAAiB,IAAI,OAAO,IAAmB,YAAY;CAC7D;CAEA,kBAAkB,SAAS;CAE3B,OACE,iBAAiB,OAAO,GACxB,wDACF;CACA,KAAK,MAAM,UAAU,eACnB,OAAO,OAAO,KAAK,QAAQ,MAAM;CAEnC,OAAO,cACL,kBACA,QACA,QACA,kBACA,oBACA,uBACA,WACF;CACA,KAAK,MAAM,UAAU,kBACnB,OAAO,OAAO,KAAK,QAAQ,MAAM;AAErC;AAEA,UAAU,cACR,kBACA,QACA,QACA,kBACA,oBACA,uBACA,aACiB;CACjB,MAAM,QAAQ,CAAC,GAAG,iBAAiB,KAAK,CAAC;;;;;;;;;;;CAWzC,QAAQ,kBAAR;EACE,KAAK;GACH,OACE,MAAM,WAAW,KAAK,MAAM,OAAO,GACnC,oCACF;GACA,OAAO,OAAO,KACZ,sBAAsB,KAAK,iBAAiB,IAAI,CAAiB,CAAC,CAAC,GACnE,MACF;GACA;EACF,KAAK;GACH,OACE,MAAM,WAAW,KAAK,MAAM,OAAO,GACnC,8BACF;GACA,OAAO,OAAO,KACZ,sBAAsB,KAAK,iBAAiB,IAAI,CAAc,CAAC,CAAC,GAChE,MACF;GACA;EACF,KAAK,GAAiB;GACpB,OACE,MAAM,OACJ,SACE,SAAS,KACT,SAAS,KACT,SAAS,CACb,GACA,kDACF;GACA,MAAM,YAAY,iBAAiB,IAAI,CAAc;GACrD,MAAM,eAAe,iBAAiB,IAAI,CAAiB;GAC3D,IAAI,aAAa,iBAAiB,IAAI,CAAe;GAMrD,IAAI,gBAAgB,cAAe,aAAa,eAAgB;IAC9D,IAAI,cACF,OAAO,kBACL,aAAa,IACb,GACA,aACA,QACA,MACF;IAEF,MAAM,SAAS,OAAmB;KAChC,KAAK,EAAE;KACP,eAAe,OAAO,YACpB,OAAO,QAAQ,EAAE,aAAa,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CACjE;IACF;IACA,OAAO,OAAO,KACZ,sBACE,cACE,eACE,MAAM,KAAK,SAAS,CAAC,CAAC,EAAiB,GACvC,MAAM,KAAK,YAAY,CAAC,CAAC,EAAiB,CAC5C,CACJ,GACA,MACF;IACA,IAAI,WACF,OAAO,kBACL,UAAU,IACV,GACA,aACA,QACA,MACF;IAEF;GACF;GAIA,IAAI,YAAY;IACd,IAAI,WACF,aAAa,mBAAmB,YAAY,SAAS;IAEvD,IAAI,cACF,aAAa,mBAAmB,YAAY,YAAY;IAE1D,OAAO,OAAO,KAAK,sBAAsB,UAAU,GAAG,MAAM;IAC5D;GACF;GAmBA,IAAI,aAAa,cAAc;IAC7B,OAAO,OAAO,KACZ,sBACE,eACE,UAAU,IACV,aAAa,EACf,CACF,GACA,MACF;IACA;GACF;GAEA,OAAO,OAAO,KACZ,sBAAsB,KAAK,aAAa,YAAY,CAAC,GACrD,MACF;GACA;EACF;EACA,KAAK,GAAkB;GACrB,OACE,MAAM,OACJ,SACE,SAAS,KACT,SAAS,KACT,SAAS,CACb,GACA,sDACF;GACA,OACE,MAAM,UAAU,GAChB,sEACF;GAGA,MAAM,cAAc,iBAAiB,IAAI,CAAgB;GACzD,IAAI,aAAa;IACf,MAAM,OAAO,iBAAiB,IAAI,CAAiB;IACnD,MAAM,UAAU,iBAAiB,IAAI,CAAc;IACnD,IAAI,eAAe,MACjB,OAAO,kBACL,KAAK,IACL,GACA,aACA,QACA,MACF;IAEF,OAAO,OAAO,KAAK,aAAa,MAAM;IACtC,IAAI,eAAe,SACjB,OAAO,kBACL,QAAQ,IACR,GACA,aACA,QACA,MACF;IAEF;GACF;GAEA,MAAM,YAAY,iBAAiB,IAAI,CAAc;GACrD,MAAM,eAAe,iBAAiB,IAAI,CAAiB;GAE3D,OACE,cAAc,KAAA,KAAa,iBAAiB,KAAA,GAC5C,sDACF;GAEA,OAAO,OAAO,KACZ,sBAAsB,KAAK,aAAa,YAAY,CAAC,GACrD,MACF;GACA;EACF;CAGF;AACF;;;;;AAMA,UAAiB,kBACf,MACA,MACA,aACA,QACA,QACiB;CACjB,KAAK,MAAM,CAAC,kBAAkB,aAAa,OAAO,QAChD,KAAK,aACP,GAAG;EACD,IAAI,CAAC,YAAY,gBAAgB,GAC/B;EAEF,KAAK,MAAM,SAAS,SAAS,GAAG;GAC9B,IAAI,UAAU,SAAS;IACrB,MAAM;IACN;GACF;GACA,OAAO,OAAO,KACZ,gBAAgB,MAAM;IACpB;IACA,QACE,SAAS,IACL,cAAc,KAAK,IACnB,iBAAiB,KAAK;GAC9B,CAAC,GACD,MACF;EACF;CACF;AACF;;;;AAKA,SAAgB,mBAAmB,MAAc,OAAuB;CAItE,IAAI,KAAK,OAAsB,MAAM,IACnC,QAAQ,KAAK,IAAb;EACE,KAAK,GACH,OAAO,cAAc;GACnB,KAAK,KAAK,EAAiB,CAAC;GAC5B,eAAe;IACb,GAAG,MAAM,EAAiB,CAAC;IAC3B,GAAG,KAAK,EAAiB,CAAC;GAC5B;EACF,CAAC;EAEH,KAAK,GACH,OAAO,iBAAiB;GACtB,KAAK,KAAK,EAAiB,CAAC;GAC5B,eAAe;IACb,GAAG,MAAM,EAAiB,CAAC;IAC3B,GAAG,KAAK,EAAiB,CAAC;GAC5B;EACF,CAAC;EAEH,KAAK;GACH,OACE,MAAM,OAAsB,SAE1B,4FAA4F,MAAM,IACtG;GAEA,OAAO,eACL;IACE,KAAK,KAAK,EAAiB,CAAC;IAC5B,eAAe;KACb,GAAG,MAAM,EAAiB,CAAC;KAC3B,GAAG,KAAK,EAAiB,CAAC;IAC5B;GACF,GACA;IACE,KAAK,KAAK,EAAqB,CAAC;IAChC,eAAe;KACb,GAAG,MAAM,EAAqB,CAAC;KAC/B,GAAG,KAAK,EAAqB,CAAC;IAChC;GACF,CACF;EAEF,KAAK;GAIH,OACE,MAAM,OAAsB,SAE1B,8FAA8F,MAAM,IACxG;GACA,OAAO,gBACL;IACE,KAAK,KAAK,EAAiB,CAAC;IAC5B,eAAe;KACb,GAAG,MAAM,EAAiB,CAAC;KAC3B,GAAG,KAAK,EAAiB,CAAC;IAC5B;GACF,GACA,KAAK,EACP;CAEJ;CAIF,OACE,KAAK,OAAsB,SAEzB,gFAAgF,KAAK,GAAkB,eAAe,MAAM,IAChI;CACA,QAAQ,MAAM,IAAd;EACE,KAAK,GACH,OAAO,eACL;GACE,GAAG,KAAK;GACR,eAAe;IACb,GAAG,MAAM,EAAiB,CAAC;IAC3B,GAAG,KAAK,EAAiB,CAAC;GAC5B;EACF,GACA,KAAK,EACP;EAEF,KAAK,GACH,OAAO,eAAe,KAAK,IAAmB;GAC5C,GAAG,KAAK;GACR,eAAe;IACb,GAAG,MAAM,EAAiB,CAAC;IAC3B,GAAG,KAAK,EAAqB,CAAC;GAChC;EACF,CAAC;CAEL;CAEA,YAAY;AACd;AAEA,SAAgB,0BACd,QAC4B;CAC5B,QAAQ,WAA2B;EACjC,IAAI,OAAO,KAAK,OAAO,aAAa,CAAC,CAAC,WAAW,GAC/C,OAAO;EAGT,QAAQ,OAAO,IAAf;GACE,KAAK,GAAgB;IACnB,MAAM,gBAAgB,EAAC,GAAG,OAAO,EAAiB,CAAC,cAAa;IAChE,WAAW,eAAe,OAAO,KAAK,OAAO,aAAa,CAAC;IAC3D,OAAO,cAAc;KACnB,KAAK,OAAO,EAAiB,CAAC;KAC9B;IACF,CAAC;GACH;GACA,KAAK,GAAmB;IACtB,MAAM,gBAAgB,EAAC,GAAG,OAAO,EAAiB,CAAC,cAAa;IAChE,WAAW,eAAe,OAAO,KAAK,OAAO,aAAa,CAAC;IAC3D,OAAO,iBAAiB;KACtB,KAAK,OAAO,EAAiB,CAAC;KAC9B;IACF,CAAC;GACH;GACA,KAAK,GAAiB;IACpB,MAAM,oBAAoB,EAAC,GAAG,OAAO,EAAiB,CAAC,cAAa;IACpE,MAAM,uBAAuB,EAC3B,GAAG,OAAO,EAAqB,CAAC,cAClC;IACA,WAAW,mBAAmB,OAAO,KAAK,OAAO,aAAa,CAAC;IAC/D,WAAW,sBAAsB,OAAO,KAAK,OAAO,aAAa,CAAC;IAClE,OAAO,eACL;KAAC,KAAK,OAAO,EAAiB,CAAC;KAAK,eAAe;IAAiB,GACpE;KACE,KAAK,OAAO,EAAqB,CAAC;KAClC,eAAe;IACjB,CACF;GACF;GACA,KAAK,GACH,OAAO;EACX;CACF;AACF;;;;;;;AAQA,SAAgB,WACd,eACA,mBACA;CACA,KAAK,MAAM,WAAW,mBACpB,IAAI,cAAc,aAAa,KAAA,GAC7B,cAAc,iBAAiB;AAGrC"}

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

@@ -16,5 +16,6 @@ export type SourceSchema = {
     readonly system: System;
     readonly compareRows: Comparator;
     readonly sort?: Ordering | undefined;
+    readonly isAggregate?: boolean | undefined;
 };
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAC,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAC1E,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;KAAC,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAQ3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACtC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAC,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAC1E,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;KAAC,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAQ3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAMrC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC5C,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"skip-yields.js","names":["#stream","#it"],"sources":["../../../../../zql/src/ivm/skip-yields.ts"],"sourcesContent":["import type {Node} from './data.ts';\nimport type {Stream} from './stream.ts';\n\n// Implemented as a custom IterableIterator rather than a generator function to\n// reduce allocations. A generator creates a new state-machine object each time\n// it is called. By returning `this` from [Symbol.iterator](), the same object\n// acts as both the Iterable and the Iterator, so iterating the stream incurs\n// only one allocation (the SkipYieldsStream instance itself) instead of two.\n// Additionally, the IteratorResult objects ({value, done}) from the inner\n// iterator are returned directly rather than being recreated, avoiding further\n// per-item allocations.\nclass SkipYieldsStream implements IterableIterator<Node> {\n  readonly #stream: Stream<Node | 'yield'>;\n  #it: Iterator<Node | 'yield'> | undefined = undefined;\n\n  constructor(stream: Stream<Node | 'yield'>) {\n    this.#stream = stream;\n  }\n\n  [Symbol.iterator](): IterableIterator<Node> {\n    this.#it = this.#stream[Symbol.iterator]();\n    return this;\n  }\n\n  next(): IteratorResult<Node> {\n    // #it is always set before next() is called, as [Symbol.iterator]() must\n    // be called first (e.g. by a for-of loop).\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const it = this.#it!;\n    for (;;) {\n      const r = it.next();\n      if (r.done || r.value !== 'yield') {\n        return r as IteratorResult<Node>;\n      }\n    }\n  }\n\n  return(value?: undefined): IteratorResult<Node> {\n    this.#it?.return?.(value);\n    return {done: true, value: undefined};\n  }\n}\n\nexport function skipYields(stream: Stream<Node | 'yield'>): Stream<Node> {\n  return new SkipYieldsStream(stream);\n}\n"],"mappings":";AAWA,IAAM,mBAAN,MAAyD;CACvD;CACA,MAA4C,KAAA;CAE5C,YAAY,QAAgC;EAC1C,KAAKA,UAAU;CACjB;CAEA,CAAC,OAAO,YAAoC;EAC1C,KAAKC,MAAM,KAAKD,QAAQ,OAAO,UAAU;EACzC,OAAO;CACT;CAEA,OAA6B;EAI3B,MAAM,KAAK,KAAKC;EAChB,SAAS;GACP,MAAM,IAAI,GAAG,KAAK;GAClB,IAAI,EAAE,QAAQ,EAAE,UAAU,SACxB,OAAO;EAEX;CACF;CAEA,OAAO,OAAyC;EAC9C,KAAKA,KAAK,SAAS,KAAK;EACxB,OAAO;GAAC,MAAM;GAAM,OAAO,KAAA;EAAS;CACtC;AACF;AAEA,SAAgB,WAAW,QAA8C;CACvE,OAAO,IAAI,iBAAiB,MAAM;AACpC"}
+{"version":3,"file":"skip-yields.js","names":[],"sources":["../../../../../zql/src/ivm/skip-yields.ts"],"sourcesContent":["import type {Node} from './data.ts';\nimport type {Stream} from './stream.ts';\n\n// Implemented as a custom IterableIterator rather than a generator function to\n// reduce allocations. A generator creates a new state-machine object each time\n// it is called. By returning `this` from [Symbol.iterator](), the same object\n// acts as both the Iterable and the Iterator, so iterating the stream incurs\n// only one allocation (the SkipYieldsStream instance itself) instead of two.\n// Additionally, the IteratorResult objects ({value, done}) from the inner\n// iterator are returned directly rather than being recreated, avoiding further\n// per-item allocations.\nclass SkipYieldsStream implements IterableIterator<Node> {\n  readonly #stream: Stream<Node | 'yield'>;\n  #it: Iterator<Node | 'yield'> | undefined = undefined;\n\n  constructor(stream: Stream<Node | 'yield'>) {\n    this.#stream = stream;\n  }\n\n  [Symbol.iterator](): IterableIterator<Node> {\n    this.#it = this.#stream[Symbol.iterator]();\n    return this;\n  }\n\n  next(): IteratorResult<Node> {\n    // #it is always set before next() is called, as [Symbol.iterator]() must\n    // be called first (e.g. by a for-of loop).\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const it = this.#it!;\n    for (;;) {\n      const r = it.next();\n      if (r.done || r.value !== 'yield') {\n        return r as IteratorResult<Node>;\n      }\n    }\n  }\n\n  return(value?: undefined): IteratorResult<Node> {\n    this.#it?.return?.(value);\n    return {done: true, value: undefined};\n  }\n}\n\nexport function skipYields(stream: Stream<Node | 'yield'>): Stream<Node> {\n  return new SkipYieldsStream(stream);\n}\n"],"mappings":";AAWA,IAAM,mBAAN,MAAyD;CACvD;CACA,MAA4C,KAAA;CAE5C,YAAY,QAAgC;EAC1C,KAAK,UAAU;CACjB;CAEA,CAAC,OAAO,YAAoC;EAC1C,KAAK,MAAM,KAAK,QAAQ,OAAO,SAAS,CAAC;EACzC,OAAO;CACT;CAEA,OAA6B;EAI3B,MAAM,KAAK,KAAK;EAChB,SAAS;GACP,MAAM,IAAI,GAAG,KAAK;GAClB,IAAI,EAAE,QAAQ,EAAE,UAAU,SACxB,OAAO;EAEX;CACF;CAEA,OAAO,OAAyC;EAC9C,KAAK,KAAK,SAAS,KAAK;EACxB,OAAO;GAAC,MAAM;GAAM,OAAO,KAAA;EAAS;CACtC;AACF;AAEA,SAAgB,WAAW,QAA8C;CACvE,OAAO,IAAI,iBAAiB,MAAM;AACpC"}

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 InputBase,\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  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(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":";;;;;;;;AAiCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,UAAU;EAC/B,OAAO,SAAS,KAAA,GAAW,4BAA4B;EACvD,KAAKA,SAAS;EACd,KAAKC,SAAS;EACd,KAAKC,cAAc,MAAM,UAAU,EAAE;EACrC,MAAM,UAAU,IAAI;CACtB;CAEA,YAA0B;EACxB,OAAO,KAAKF,OAAO,UAAU;CAC/B;CAEA,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,KAAKG,UAAU,GAAG;EAChC,IAAI,UAAU,SACZ;EAEF,MAAM,QAAQ,KAAKH,OAAO,MAAM;GAAC,GAAG;GAAK;EAAK,CAAC;EAC/C,IAAI,CAAC,IAAI,SAAS;GAChB,OAAO;GACP;EACF;EACA,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,CAAC,KAAKI,iBAAiB,KAAK,GAAG,GACjC;GAEF,MAAM;EACR;CACF;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;CACjB;CAEA,UAAgB;EACd,KAAKL,OAAO,QAAQ;CACtB;CAEA,iBAAiB,KAAmB;EAClC,MAAM,MAAM,KAAKE,YAAY,KAAKD,OAAO,KAAK,GAAG;EACjD,OAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,KAAKA,OAAO;CAC/C;CAEA,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,KAAKG,iBAAiB,GAAG;EAC/D,IAAI,OAAO,OAAsB,GAAiB;GAChD,OAAO,4BACL,QACA,iBACA,KAAKC,SACL,IACF;GACA;EACF;EAIA,IAAI,gBAAgB,OAAO,GAAkB,GAAG,GAC9C,OAAO,KAAKA,QAAQ,KAAK,QAAQ,IAAI;CAEzC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAKA,QAAQ,WACf,OAAO,KAAKA,QAAQ,UAAU,IAAI;CAEtC;CAEA,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,KAAKJ,OAAO;GACjB,OAAO,KAAKA,OAAO,YAAY,UAAU;EAC3C;EAEA,IAAI,CAAC,IAAI,OAAO;GACd,IAAI,IAAI,SACN;GAEF,OAAO;EACT;EAEA,MAAM,MAAM,KAAKC,YAAY,KAAKD,OAAO,KAAK,IAAI,MAAM,GAAG;EAE3D,IAAI,CAAC,IAAI,SAAS;GAIhB,IAAI,MAAM,GACR,OAAO;GAKT,IAAI,QAAQ,GAAG;IACb,IAAI,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,SAC/C,OAAO;KACL,KAAK,KAAKA,OAAO;KACjB,OAAO;IACT;IAEF,OAAO;GACT;GAEA,OAAO,IAAI;EACb;EAEA,IAAI;EAIJ,IAAI,MAAM,GACR,OAAO;EAGT,IAAI,QAAQ,GAAG;GAGb,IAAI,CAAC,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,MAChD,OAAO;GAIT,OAAO;EACT;EAGA,OAAO,IAAI;CACb;AACF"}
+{"version":3,"file":"skip.js","names":[],"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 InputBase,\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  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(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":";;;;;;;;AAiCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,UAAU;EAC/B,OAAO,SAAS,KAAA,GAAW,4BAA4B;EACvD,KAAK,SAAS;EACd,KAAK,SAAS;EACd,KAAK,cAAc,MAAM,UAAU,CAAC,CAAC;EACrC,MAAM,UAAU,IAAI;CACtB;CAEA,YAA0B;EACxB,OAAO,KAAK,OAAO,UAAU;CAC/B;CAEA,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,KAAK,UAAU,GAAG;EAChC,IAAI,UAAU,SACZ;EAEF,MAAM,QAAQ,KAAK,OAAO,MAAM;GAAC,GAAG;GAAK;EAAK,CAAC;EAC/C,IAAI,CAAC,IAAI,SAAS;GAChB,OAAO;GACP;EACF;EACA,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,CAAC,KAAK,iBAAiB,KAAK,GAAG,GACjC;GAEF,MAAM;EACR;CACF;CAEA,UAAU,QAAsB;EAC9B,KAAK,UAAU;CACjB;CAEA,UAAgB;EACd,KAAK,OAAO,QAAQ;CACtB;CAEA,iBAAiB,KAAmB;EAClC,MAAM,MAAM,KAAK,YAAY,KAAK,OAAO,KAAK,GAAG;EACjD,OAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,KAAK,OAAO;CAC/C;CAEA,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,KAAK,iBAAiB,GAAG;EAC/D,IAAI,OAAO,OAAsB,GAAiB;GAChD,OAAO,4BACL,QACA,iBACA,KAAK,SACL,IACF;GACA;EACF;EAIA,IAAI,gBAAgB,OAAO,EAAiB,CAAC,GAAG,GAC9C,OAAO,KAAK,QAAQ,KAAK,QAAQ,IAAI;CAEzC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAK,QAAQ,WACf,OAAO,KAAK,QAAQ,UAAU,IAAI;CAEtC;CAEA,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,KAAK,OAAO;GACjB,OAAO,KAAK,OAAO,YAAY,UAAU;EAC3C;EAEA,IAAI,CAAC,IAAI,OAAO;GACd,IAAI,IAAI,SACN;GAEF,OAAO;EACT;EAEA,MAAM,MAAM,KAAK,YAAY,KAAK,OAAO,KAAK,IAAI,MAAM,GAAG;EAE3D,IAAI,CAAC,IAAI,SAAS;GAIhB,IAAI,MAAM,GACR,OAAO;GAKT,IAAI,QAAQ,GAAG;IACb,IAAI,KAAK,OAAO,aAAa,IAAI,MAAM,UAAU,SAC/C,OAAO;KACL,KAAK,KAAK,OAAO;KACjB,OAAO;IACT;IAEF,OAAO;GACT;GAEA,OAAO,IAAI;EACb;EAEA,IAAI;EAIJ,IAAI,MAAM,GACR,OAAO;EAGT,IAAI,QAAQ,GAAG;GAGb,IAAI,CAAC,KAAK,OAAO,aAAa,IAAI,MAAM,UAAU,MAChD,OAAO;GAIT,OAAO;EACT;EAGA,OAAO,IAAI;CACb;AACF"}

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

@@ -3,6 +3,7 @@ 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 { Constraint } from './constraint.ts';
 import type { Input } from './operator.ts';
 import type { Stream } from './stream.ts';
 export type SourceChangeAdd = [type: ChangeType.ADD, row: Row, extra: null];
@@ -75,5 +76,25 @@ export interface Source {
 }
 export interface SourceInput extends Input {
     readonly fullyAppliedFilters: boolean;
+    /**
+     * The number of rows a fetch with `constraint` would return, counted without
+     * reading them, or `undefined` when the source can't count right now (the
+     * caller then fetches and counts the rows itself). Optional: a source that
+     * can't count cheaply leaves it out.
+     */
+    count?(constraint: Constraint | undefined): number | undefined;
+    /**
+     * The distinct values of `columns` among the rows an unconstrained fetch
+     * would return, each with the number of rows that have it, in no particular
+     * order, or `undefined` when the source can't group right now (the caller
+     * then fetches the rows and groups them itself). Optional, like `count`.
+     */
+    groupCounts?(columns: readonly string[]): GroupCount[] | undefined;
 }
+/** One group of {@link SourceInput.groupCounts}. */
+export type GroupCount = {
+    /** The group's value of each of the columns, by column name. */
+    readonly row: Row;
+    readonly count: number;
+};
 //# sourceMappingURL=source.d.ts.map

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,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,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;IAEtC;;;;;OAKG;IACH,KAAK,CAAC,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IAE/D;;;;;OAKG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,EAAE,GAAG,SAAS,CAAC;CACpE;AAED,oDAAoD;AACpD,MAAM,MAAM,UAAU,GAAG;IACvB,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"source.js","names":[],"sources":["../../../../../zql/src/ivm/source.ts"],"sourcesContent":["import type {Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {TableSchema} from '../../../zero-types/src/schema.ts';\nimport type {DebugDelegate} from '../builder/debug-delegate.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Input} from './operator.ts';\nimport type {Stream} from './stream.ts';\n\nexport type SourceChangeAdd = [type: ChangeType.ADD, row: Row, extra: null];\nexport type SourceChangeRemove = [\n  type: ChangeType.REMOVE,\n  row: Row,\n  extra: null,\n];\nexport type SourceChangeEdit = [type: ChangeType.EDIT, row: Row, oldRow: Row];\n\nexport type SourceChange =\n  | SourceChangeAdd\n  | SourceChangeRemove\n  | SourceChangeEdit;\n\nexport function makeSourceChangeAdd(row: Row): SourceChangeAdd {\n  return [ChangeType.ADD, row, null];\n}\n\nexport function makeSourceChangeRemove(row: Row): SourceChangeRemove {\n  return [ChangeType.REMOVE, row, null];\n}\n\nexport function makeSourceChangeEdit(row: Row, oldRow: Row): SourceChangeEdit {\n  return [ChangeType.EDIT, row, oldRow];\n}\n\n/**\n * A source is an input that serves as the root data source of the pipeline.\n * Sources have multiple outputs. To add an output, call `connect()`, then\n * hook yourself up to the returned Connector, like:\n *\n * ```ts\n * class MyOperator implements Output {\n *   constructor(input: Input) {\n *     input.setOutput(this);\n *   }\n *\n *   push(change: Change): void {\n *     // Handle change\n *   }\n * }\n *\n * const connection = source.connect(ordering);\n * const myOperator = new MyOperator(connection);\n * ```\n */\nexport interface Source {\n  get tableSchema(): TableSchema;\n  /**\n   * Creates an input that an operator can connect to. To free resources used\n   * by connection, downstream operators call `destroy()` on the returned\n   * input.\n   *\n   * @param sort The ordering of the rows. Source must return rows in this\n   * order.  Must include all primary keys of the table.\n   * @param filters Filters to apply to the source.\n   * @param splitEditKeys If an edit change modifies the values of any of the\n   *   keys in splitEditKeys, the source should split the edit change into\n   *   a remove of the old row followed by an add of the new row.\n   */\n  connect(\n    sort: Ordering | undefined,\n    filters?: Condition,\n    splitEditKeys?: Set<string>,\n    debug?: DebugDelegate,\n  ): SourceInput;\n\n  /**\n   * Pushes a change into the source and into all connected outputs.\n   *\n   * The returned stream can yield 'yield' to yield control to the caller\n   * for purposes of responsiveness.\n   *\n   * Once the stream is exhausted, the change will have been pushed into all\n   * connected inputs and committed to the source.\n   */\n  push(change: SourceChange): Stream<'yield'>;\n\n  /**\n   * Pushes a change into the source.\n   *\n   * Iterating the returned stream will push the change into one connected input\n   * at a time, yielding `undefined` between each, and yielding `'yield'` to\n   * yield control to the caller for purposes of responsiveness.\n   *\n   * Once the stream is exhausted, the change will have been pushed\n   * into all connected inputs and committed to the source.\n   */\n  genPush(change: SourceChange): Stream<'yield' | undefined>;\n}\n\nexport interface SourceInput extends Input {\n  readonly fullyAppliedFilters: boolean;\n}\n"],"mappings":";AAqBA,SAAgB,oBAAoB,KAA2B;CAC7D,OAAO;EAAC;EAAgB;EAAK;CAAI;AACnC;AAEA,SAAgB,uBAAuB,KAA8B;CACnE,OAAO;EAAC;EAAmB;EAAK;CAAI;AACtC;AAEA,SAAgB,qBAAqB,KAAU,QAA+B;CAC5E,OAAO;EAAC;EAAiB;EAAK;CAAM;AACtC"}
+{"version":3,"file":"source.js","names":[],"sources":["../../../../../zql/src/ivm/source.ts"],"sourcesContent":["import type {Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {TableSchema} from '../../../zero-types/src/schema.ts';\nimport type {DebugDelegate} from '../builder/debug-delegate.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Input} from './operator.ts';\nimport type {Stream} from './stream.ts';\n\nexport type SourceChangeAdd = [type: ChangeType.ADD, row: Row, extra: null];\nexport type SourceChangeRemove = [\n  type: ChangeType.REMOVE,\n  row: Row,\n  extra: null,\n];\nexport type SourceChangeEdit = [type: ChangeType.EDIT, row: Row, oldRow: Row];\n\nexport type SourceChange =\n  | SourceChangeAdd\n  | SourceChangeRemove\n  | SourceChangeEdit;\n\nexport function makeSourceChangeAdd(row: Row): SourceChangeAdd {\n  return [ChangeType.ADD, row, null];\n}\n\nexport function makeSourceChangeRemove(row: Row): SourceChangeRemove {\n  return [ChangeType.REMOVE, row, null];\n}\n\nexport function makeSourceChangeEdit(row: Row, oldRow: Row): SourceChangeEdit {\n  return [ChangeType.EDIT, row, oldRow];\n}\n\n/**\n * A source is an input that serves as the root data source of the pipeline.\n * Sources have multiple outputs. To add an output, call `connect()`, then\n * hook yourself up to the returned Connector, like:\n *\n * ```ts\n * class MyOperator implements Output {\n *   constructor(input: Input) {\n *     input.setOutput(this);\n *   }\n *\n *   push(change: Change): void {\n *     // Handle change\n *   }\n * }\n *\n * const connection = source.connect(ordering);\n * const myOperator = new MyOperator(connection);\n * ```\n */\nexport interface Source {\n  get tableSchema(): TableSchema;\n  /**\n   * Creates an input that an operator can connect to. To free resources used\n   * by connection, downstream operators call `destroy()` on the returned\n   * input.\n   *\n   * @param sort The ordering of the rows. Source must return rows in this\n   * order.  Must include all primary keys of the table.\n   * @param filters Filters to apply to the source.\n   * @param splitEditKeys If an edit change modifies the values of any of the\n   *   keys in splitEditKeys, the source should split the edit change into\n   *   a remove of the old row followed by an add of the new row.\n   */\n  connect(\n    sort: Ordering | undefined,\n    filters?: Condition,\n    splitEditKeys?: Set<string>,\n    debug?: DebugDelegate,\n  ): SourceInput;\n\n  /**\n   * Pushes a change into the source and into all connected outputs.\n   *\n   * The returned stream can yield 'yield' to yield control to the caller\n   * for purposes of responsiveness.\n   *\n   * Once the stream is exhausted, the change will have been pushed into all\n   * connected inputs and committed to the source.\n   */\n  push(change: SourceChange): Stream<'yield'>;\n\n  /**\n   * Pushes a change into the source.\n   *\n   * Iterating the returned stream will push the change into one connected input\n   * at a time, yielding `undefined` between each, and yielding `'yield'` to\n   * yield control to the caller for purposes of responsiveness.\n   *\n   * Once the stream is exhausted, the change will have been pushed\n   * into all connected inputs and committed to the source.\n   */\n  genPush(change: SourceChange): Stream<'yield' | undefined>;\n}\n\nexport interface SourceInput extends Input {\n  readonly fullyAppliedFilters: boolean;\n\n  /**\n   * The number of rows a fetch with `constraint` would return, counted without\n   * reading them, or `undefined` when the source can't count right now (the\n   * caller then fetches and counts the rows itself). Optional: a source that\n   * can't count cheaply leaves it out.\n   */\n  count?(constraint: Constraint | undefined): number | undefined;\n\n  /**\n   * The distinct values of `columns` among the rows an unconstrained fetch\n   * would return, each with the number of rows that have it, in no particular\n   * order, or `undefined` when the source can't group right now (the caller\n   * then fetches the rows and groups them itself). Optional, like `count`.\n   */\n  groupCounts?(columns: readonly string[]): GroupCount[] | undefined;\n}\n\n/** One group of {@link SourceInput.groupCounts}. */\nexport type GroupCount = {\n  /** The group's value of each of the columns, by column name. */\n  readonly row: Row;\n  readonly count: number;\n};\n"],"mappings":";AAsBA,SAAgB,oBAAoB,KAA2B;CAC7D,OAAO;EAAC;EAAgB;EAAK;CAAI;AACnC;AAEA,SAAgB,uBAAuB,KAA8B;CACnE,OAAO;EAAC;EAAmB;EAAK;CAAI;AACtC;AAEA,SAAgB,qBAAqB,KAAU,QAA+B;CAC5E,OAAO;EAAC;EAAiB;EAAK;CAAM;AACtC"}

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

@@ -8,5 +8,4 @@
 export type Stream<T> = Iterable<T>;
 export declare function take<T>(stream: Stream<T>, limit: number): Stream<T>;
 export declare function consume<T>(stream: Stream<T>): void;
-export declare function drainGenerator<Yield, Return>(gen: Generator<Yield, Return, unknown>): Return;
 //# sourceMappingURL=stream.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/stream.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEpC,wBAAiB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAWpE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAGlD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAC1C,GAAG,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,CAMR"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/stream.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEpC,wBAAiB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAWpE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAGlD"}

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

@@ -1 +1 @@
-{"version":3,"file":"stream.js","names":[],"sources":["../../../../../zql/src/ivm/stream.ts"],"sourcesContent":["/**\n * streams are lazy forward-only iterables.\n * Once a stream reaches the end it can't be restarted.\n * They are iterable, not iterator, so that they can be used in for-each,\n * and so that we know when consumer has stopped iterating the stream. This allows us\n * to clean up resources like sql statements.\n */\nexport type Stream<T> = Iterable<T>;\n\nexport function* take<T>(stream: Stream<T>, limit: number): Stream<T> {\n  if (limit < 1) {\n    return;\n  }\n  let count = 0;\n  for (const v of stream) {\n    yield v;\n    if (++count === limit) {\n      break;\n    }\n  }\n}\n\nexport function consume<T>(stream: Stream<T>): void {\n  // Required to prevent some minifiers (e.g. Terser) from removing this empty loop\n  for (const _ of stream);\n}\n\nexport function drainGenerator<Yield, Return>(\n  gen: Generator<Yield, Return, unknown>,\n): Return {\n  let result = gen.next();\n  while (!result.done) {\n    result = gen.next();\n  }\n  return result.value;\n}\n"],"mappings":";AAsBA,SAAgB,QAAW,QAAyB;CAElD,KAAK,MAAM,KAAK;AAClB"}
+{"version":3,"file":"stream.js","names":[],"sources":["../../../../../zql/src/ivm/stream.ts"],"sourcesContent":["/**\n * streams are lazy forward-only iterables.\n * Once a stream reaches the end it can't be restarted.\n * They are iterable, not iterator, so that they can be used in for-each,\n * and so that we know when consumer has stopped iterating the stream. This allows us\n * to clean up resources like sql statements.\n */\nexport type Stream<T> = Iterable<T>;\n\nexport function* take<T>(stream: Stream<T>, limit: number): Stream<T> {\n  if (limit < 1) {\n    return;\n  }\n  let count = 0;\n  for (const v of stream) {\n    yield v;\n    if (++count === limit) {\n      break;\n    }\n  }\n}\n\nexport function consume<T>(stream: Stream<T>): void {\n  // Required to prevent some minifiers (e.g. Terser) from removing this empty loop\n  for (const _ of stream);\n}\n"],"mappings":";AAsBA,SAAgB,QAAW,QAAyB;CAElD,KAAK,MAAM,KAAK;AAClB"}

package/out/zql/src/ivm/take-gate.js.map

@@ -1 +1 @@
-{"version":3,"file":"take-gate.js","names":["#input","#comparator","#openDepth","#boundProvider","#output"],"sources":["../../../../../zql/src/ivm/take-gate.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {Change} from './change.ts';\nimport {constraintMatchesRow, type Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport interface TakeBoundProvider {\n  getBound(constraint?: Constraint): Row | undefined;\n}\n\n/**\n * The bound that a TakeGate caps one parent fetch of a join's child push at.\n * `undefined` means the fetch is not capped.\n */\nexport type ParentFetchBound = {\n  readonly constraint: Constraint;\n  readonly bound: Row | undefined;\n};\n\n/**\n * Reads the bounds for the parent fetches of a child push before the join\n * starts them. TakeGate reads its bound once, when a fetch starts, so the set\n * of parents that get the push stays fixed even when Take moves its bound\n * during the push. Split-push overlays must use these bounds, not the bound\n * Take reports later in the push.\n */\nexport function readParentFetchBounds(\n  boundProvider: TakeBoundProvider,\n  constraints: readonly Constraint[],\n): ParentFetchBound[] {\n  return constraints.map(constraint => ({\n    constraint,\n    bound: boundProvider.getBound(constraint),\n  }));\n}\n\n/**\n * Returns true if one of the parent fetches of the push yields `row`: `row`\n * matches the fetch's constraint and is not after the fetch's bound.\n */\nexport function isInParentFetch(\n  bounds: readonly ParentFetchBound[],\n  row: Row,\n  compareRows: Comparator,\n): boolean {\n  for (const {constraint, bound} of bounds) {\n    if (constraintMatchesRow(constraint, row)) {\n      return bound === undefined || compareRows(row, bound) <= 0;\n    }\n  }\n  return false;\n}\n\n/**\n * TakeGate bounds upstream parent fetches using the active bound from a\n * downstream Take operator.\n *\n * When a child table changes, joins fetch matching parent rows. Without\n * TakeGate, this fetch scans all matching parent rows (which may be thousands)\n * even if downstream Take only needs a few. TakeGate intercepts this fetch and\n * stops the upstream stream once rows exceed Take's bound.\n */\nexport class TakeGate implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #comparator: Comparator;\n  #boundProvider: TakeBoundProvider | undefined;\n  #output: Output = throwOutput;\n  #openDepth = 0;\n\n  constructor(input: Input) {\n    const {sort, compareRows} = input.getSchema();\n    assert(sort !== undefined, 'TakeGate requires sorted input');\n    this.#input = input;\n    this.#comparator = compareRows;\n    input.setOutput(this);\n  }\n\n  open(): void {\n    this.#openDepth++;\n  }\n\n  close(): void {\n    assert(this.#openDepth > 0, 'TakeGate.close called without matching open');\n    this.#openDepth--;\n  }\n\n  isOpen(): boolean {\n    return this.#openDepth > 0;\n  }\n\n  setBoundProvider(provider: TakeBoundProvider): void {\n    this.#boundProvider = provider;\n  }\n\n  getBoundProvider(): TakeBoundProvider | undefined {\n    return this.#boundProvider;\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (this.#openDepth > 0) {\n      return undefined;\n    }\n    return this.#boundProvider?.getBound(constraint);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *push(change: Change, _pusher: InputBase): Stream<'yield'> {\n    yield* this.#output.push(change, this);\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (this.#openDepth > 0 || req.reverse) {\n      yield* this.#input.fetch(req);\n      return;\n    }\n\n    const bound = this.#boundProvider?.getBound(req.constraint);\n    if (!bound) {\n      yield* this.#input.fetch(req);\n      return;\n    }\n\n    for (const node of this.#input.fetch(req)) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      if (this.#comparator(node.row, bound) > 0) {\n        return;\n      }\n      yield node;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAoCA,SAAgB,sBACd,eACA,aACoB;CACpB,OAAO,YAAY,KAAI,gBAAe;EACpC;EACA,OAAO,cAAc,SAAS,UAAU;CAC1C,EAAE;AACJ;;;;;AAMA,SAAgB,gBACd,QACA,KACA,aACS;CACT,KAAK,MAAM,EAAC,YAAY,WAAU,QAChC,IAAI,qBAAqB,YAAY,GAAG,GACtC,OAAO,UAAU,KAAA,KAAa,YAAY,KAAK,KAAK,KAAK;CAG7D,OAAO;AACT;;;;;;;;;;AAWA,IAAa,WAAb,MAA6D;CAC3D;CACA;CACA;CACA,UAAkB;CAClB,aAAa;CAEb,YAAY,OAAc;EACxB,MAAM,EAAC,MAAM,gBAAe,MAAM,UAAU;EAC5C,OAAO,SAAS,KAAA,GAAW,gCAAgC;EAC3D,KAAKA,SAAS;EACd,KAAKC,cAAc;EACnB,MAAM,UAAU,IAAI;CACtB;CAEA,OAAa;EACX,KAAKC;CACP;CAEA,QAAc;EACZ,OAAO,KAAKA,aAAa,GAAG,6CAA6C;EACzE,KAAKA;CACP;CAEA,SAAkB;EAChB,OAAO,KAAKA,aAAa;CAC3B;CAEA,iBAAiB,UAAmC;EAClD,KAAKC,iBAAiB;CACxB;CAEA,mBAAkD;EAChD,OAAO,KAAKA;CACd;CAEA,SAAS,YAA0C;EACjD,IAAI,KAAKD,aAAa,GACpB;EAEF,OAAO,KAAKC,gBAAgB,SAAS,UAAU;CACjD;CAEA,YAA0B;EACxB,OAAO,KAAKH,OAAO,UAAU;CAC/B;CAEA,UAAU,QAAsB;EAC9B,KAAKI,UAAU;CACjB;CAEA,UAAgB;EACd,KAAKJ,OAAO,QAAQ;CACtB;CAEA,CAAC,KAAK,QAAgB,SAAqC;EACzD,OAAO,KAAKI,QAAQ,KAAK,QAAQ,IAAI;CACvC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAKA,QAAQ,WACf,OAAO,KAAKA,QAAQ,UAAU,IAAI;CAEtC;CAEA,CAAC,MAAM,KAA2C;EAChD,IAAI,KAAKF,aAAa,KAAK,IAAI,SAAS;GACtC,OAAO,KAAKF,OAAO,MAAM,GAAG;GAC5B;EACF;EAEA,MAAM,QAAQ,KAAKG,gBAAgB,SAAS,IAAI,UAAU;EAC1D,IAAI,CAAC,OAAO;GACV,OAAO,KAAKH,OAAO,MAAM,GAAG;GAC5B;EACF;EAEA,KAAK,MAAM,QAAQ,KAAKA,OAAO,MAAM,GAAG,GAAG;GACzC,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,KAAKC,YAAY,KAAK,KAAK,KAAK,IAAI,GACtC;GAEF,MAAM;EACR;CACF;AACF"}
+{"version":3,"file":"take-gate.js","names":[],"sources":["../../../../../zql/src/ivm/take-gate.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {Change} from './change.ts';\nimport {constraintMatchesRow, type Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport interface TakeBoundProvider {\n  getBound(constraint?: Constraint): Row | undefined;\n}\n\n/**\n * The bound that a TakeGate caps one parent fetch of a join's child push at.\n * `undefined` means the fetch is not capped.\n */\nexport type ParentFetchBound = {\n  readonly constraint: Constraint;\n  readonly bound: Row | undefined;\n};\n\n/**\n * Reads the bounds for the parent fetches of a child push before the join\n * starts them. TakeGate reads its bound once, when a fetch starts, so the set\n * of parents that get the push stays fixed even when Take moves its bound\n * during the push. Split-push overlays must use these bounds, not the bound\n * Take reports later in the push.\n */\nexport function readParentFetchBounds(\n  boundProvider: TakeBoundProvider,\n  constraints: readonly Constraint[],\n): ParentFetchBound[] {\n  return constraints.map(constraint => ({\n    constraint,\n    bound: boundProvider.getBound(constraint),\n  }));\n}\n\n/**\n * Returns true if one of the parent fetches of the push yields `row`: `row`\n * matches the fetch's constraint and is not after the fetch's bound.\n */\nexport function isInParentFetch(\n  bounds: readonly ParentFetchBound[],\n  row: Row,\n  compareRows: Comparator,\n): boolean {\n  for (const {constraint, bound} of bounds) {\n    if (constraintMatchesRow(constraint, row)) {\n      return bound === undefined || compareRows(row, bound) <= 0;\n    }\n  }\n  return false;\n}\n\n/**\n * TakeGate bounds upstream parent fetches using the active bound from a\n * downstream Take operator.\n *\n * When a child table changes, joins fetch matching parent rows. Without\n * TakeGate, this fetch scans all matching parent rows (which may be thousands)\n * even if downstream Take only needs a few. TakeGate intercepts this fetch and\n * stops the upstream stream once rows exceed Take's bound.\n */\nexport class TakeGate implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #comparator: Comparator;\n  #boundProvider: TakeBoundProvider | undefined;\n  #output: Output = throwOutput;\n  #openDepth = 0;\n\n  constructor(input: Input) {\n    const {sort, compareRows} = input.getSchema();\n    assert(sort !== undefined, 'TakeGate requires sorted input');\n    this.#input = input;\n    this.#comparator = compareRows;\n    input.setOutput(this);\n  }\n\n  open(): void {\n    this.#openDepth++;\n  }\n\n  close(): void {\n    assert(this.#openDepth > 0, 'TakeGate.close called without matching open');\n    this.#openDepth--;\n  }\n\n  isOpen(): boolean {\n    return this.#openDepth > 0;\n  }\n\n  setBoundProvider(provider: TakeBoundProvider): void {\n    this.#boundProvider = provider;\n  }\n\n  getBoundProvider(): TakeBoundProvider | undefined {\n    return this.#boundProvider;\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (this.#openDepth > 0) {\n      return undefined;\n    }\n    return this.#boundProvider?.getBound(constraint);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *push(change: Change, _pusher: InputBase): Stream<'yield'> {\n    yield* this.#output.push(change, this);\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (this.#openDepth > 0 || req.reverse) {\n      yield* this.#input.fetch(req);\n      return;\n    }\n\n    const bound = this.#boundProvider?.getBound(req.constraint);\n    if (!bound) {\n      yield* this.#input.fetch(req);\n      return;\n    }\n\n    for (const node of this.#input.fetch(req)) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      if (this.#comparator(node.row, bound) > 0) {\n        return;\n      }\n      yield node;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAoCA,SAAgB,sBACd,eACA,aACoB;CACpB,OAAO,YAAY,KAAI,gBAAe;EACpC;EACA,OAAO,cAAc,SAAS,UAAU;CAC1C,EAAE;AACJ;;;;;AAMA,SAAgB,gBACd,QACA,KACA,aACS;CACT,KAAK,MAAM,EAAC,YAAY,WAAU,QAChC,IAAI,qBAAqB,YAAY,GAAG,GACtC,OAAO,UAAU,KAAA,KAAa,YAAY,KAAK,KAAK,KAAK;CAG7D,OAAO;AACT;;;;;;;;;;AAWA,IAAa,WAAb,MAA6D;CAC3D;CACA;CACA;CACA,UAAkB;CAClB,aAAa;CAEb,YAAY,OAAc;EACxB,MAAM,EAAC,MAAM,gBAAe,MAAM,UAAU;EAC5C,OAAO,SAAS,KAAA,GAAW,gCAAgC;EAC3D,KAAK,SAAS;EACd,KAAK,cAAc;EACnB,MAAM,UAAU,IAAI;CACtB;CAEA,OAAa;EACX,KAAK;CACP;CAEA,QAAc;EACZ,OAAO,KAAK,aAAa,GAAG,6CAA6C;EACzE,KAAK;CACP;CAEA,SAAkB;EAChB,OAAO,KAAK,aAAa;CAC3B;CAEA,iBAAiB,UAAmC;EAClD,KAAK,iBAAiB;CACxB;CAEA,mBAAkD;EAChD,OAAO,KAAK;CACd;CAEA,SAAS,YAA0C;EACjD,IAAI,KAAK,aAAa,GACpB;EAEF,OAAO,KAAK,gBAAgB,SAAS,UAAU;CACjD;CAEA,YAA0B;EACxB,OAAO,KAAK,OAAO,UAAU;CAC/B;CAEA,UAAU,QAAsB;EAC9B,KAAK,UAAU;CACjB;CAEA,UAAgB;EACd,KAAK,OAAO,QAAQ;CACtB;CAEA,CAAC,KAAK,QAAgB,SAAqC;EACzD,OAAO,KAAK,QAAQ,KAAK,QAAQ,IAAI;CACvC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAK,QAAQ,WACf,OAAO,KAAK,QAAQ,UAAU,IAAI;CAEtC;CAEA,CAAC,MAAM,KAA2C;EAChD,IAAI,KAAK,aAAa,KAAK,IAAI,SAAS;GACtC,OAAO,KAAK,OAAO,MAAM,GAAG;GAC5B;EACF;EAEA,MAAM,QAAQ,KAAK,gBAAgB,SAAS,IAAI,UAAU;EAC1D,IAAI,CAAC,OAAO;GACV,OAAO,KAAK,OAAO,MAAM,GAAG;GAC5B;EACF;EAEA,KAAK,MAAM,QAAQ,KAAK,OAAO,MAAM,GAAG,GAAG;GACzC,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,KAAK,YAAY,KAAK,KAAK,KAAK,IAAI,GACtC;GAEF,MAAM;EACR;CACF;AACF"}

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":"AAEA,OAAO,KAAK,EAAC,GAAG,EAAQ,MAAM,oCAAoC,CAAC;AACnE,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,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,iBAAiB,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAchE,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAgBtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ,EAAE,iBAAiB;;IAoBtD,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAEhC;IAED,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAa5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAED,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAmBjD;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CA2ChD;IAkFA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAsKrC;IA4PD,OAAO,IAAI,IAAI,CAGd;IAEA,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAqD/C;CACF;AAmBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAUT;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":"AAEA,OAAO,KAAK,EAAC,GAAG,EAAQ,MAAM,oCAAoC,CAAC;AACnE,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,EAA4B,KAAK,UAAU,EAAE,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAChF,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,iBAAiB,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAchE,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAgBtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ,EAAE,iBAAiB;;IAoBtD,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAEhC;IAED,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAa5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAED,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAmBjD;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CA2ChD;IAkFA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAsKrC;IA4PD,OAAO,IAAI,IAAI,CAGd;IAEA,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAqD/C;CACF;AAsBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAUT;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,GACzB,UAAU,CAUZ"}

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

@@ -1,9 +1,9 @@
 import { assert, unreachable } from "../../../shared/src/asserts.js";
 import { hasOwn } from "../../../shared/src/has-own.js";
-import { throwOutput } from "./operator.js";
 import { makeAddChange, makeRemoveChange } from "./change.js";
+import { compareValues, valueToKey } from "./data.js";
+import { throwOutput } from "./operator.js";
 import { assertOrderingIncludesPK } from "../query/complete-ordering.js";
-import { compareValues } from "./data.js";
 //#region ../zql/src/ivm/take.ts
 /**
 * The Take operator is for implementing limit queries. It takes the first n
@@ -27,8 +27,8 @@ var Take = class {
 	/**
 	* Partitions that incurred removals in Phase 1 and require deficit refills in
 	* Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching
-	* `#storage` keys: `'["take"]'` when unpartitioned, or `'["take", ...partitionValues]'`
-	* when partitioned.
+	* `#storage` keys: `'["take"]'` when unpartitioned, `'take:' + valueToKey(value)` for one
+	* partition column, or `'["take", ...partitionValues]'` for more.
 	*/
 	#dirtyPartitions = /* @__PURE__ */ new Map();
 	#output = throwOutput;
@@ -67,7 +67,7 @@ var Take = class {
 		const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
 		const takeState = this.#storage.get(takeStateKey);
 		if (!takeState) {
-			if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) yield* this.#initialFetch(req);
+			if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) yield* this.#initialFetch(req, takeStateKey);
 			return;
 		}
 		if (takeState.bound === void 0) return;
@@ -84,13 +84,11 @@ var Take = class {
 			if (count >= this.#limit) return;
 		}
 	}
-	*#initialFetch(req) {
+	*#initialFetch(req, takeStateKey) {
 		assert(req.start === void 0, "Start should be undefined");
 		assert(!req.reverse, "Reverse should be false");
 		if (this.#limit === 0) return;
 		assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey), "Constraint should match partition key");
-		const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
-		assert(this.#storage.get(takeStateKey) === void 0, "Take state should be undefined");
 		let size = 0;
 		let bound;
 		let downstreamEarlyReturn = true;
@@ -416,6 +414,7 @@ var Take = class {
 	}
 };
 function getTakeStateKey(partitionKey, rowOrConstraint) {
+	if (partitionKey?.length === 1 && rowOrConstraint) return "take:" + valueToKey(rowOrConstraint[partitionKey[0]]);
 	const partitionValues = [];
 	if (partitionKey && rowOrConstraint) for (const key of partitionKey) partitionValues.push(rowOrConstraint[key]);
 	return JSON.stringify(["take", ...partitionValues]);
@@ -441,6 +440,6 @@ function makePartitionKeyComparator(partitionKey) {
 	};
 }
 //#endregion
-export { Take, constraintMatchesPartitionKey, makePartitionKeyComparator };
+export { Take, constraintContainsPartitionKey, constraintMatchesPartitionKey, makePartitionKeyComparator };
 
 //# sourceMappingURL=take.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"take.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#dirtyPartitions","#takeGate","#output","#initialFetch","#rowHiddenFromFetch","#setTakeState","#pushEditChange","#getStateAndConstraint","#pushWithRowHiddenFromFetch"],"sources":["../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, type Comparator, type Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport type {TakeBoundProvider, TakeGate} from './take-gate.ts';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: string): TakeState | undefined;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\ntype DirtyPartitionState = {\n  constraint: Constraint | undefined;\n  /**\n   * The bound to report to upstream TakeGate via getBound() until Phase 2\n   * reconciliation completes.\n   *\n   * When removals reduce partition size below limit in Phase 1, normal getBound()\n   * would return undefined (unbounded), which would cause upstream TakeGate to open\n   * and allow unbounded parent pushes through. Preserving gateBound keeps TakeGate\n   * capped at the pre-removal boundary until Phase 2 refills the deficit.\n   */\n  gateBound: Row | undefined;\n};\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #takeGate: TakeGate | undefined;\n  /**\n   * Partitions that incurred removals in Phase 1 and require deficit refills in\n   * Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching\n   * `#storage` keys: `'[\"take\"]'` when unpartitioned, or `'[\"take\", ...partitionValues]'`\n   * when partitioned.\n   */\n  readonly #dirtyPartitions = new Map<string, DirtyPartitionState>();\n\n  #output: Output = throwOutput;\n\n  setTakeGate(gate: TakeGate): void {\n    this.#takeGate = gate;\n  }\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (\n      this.#partitionKey &&\n      !constraintContainsPartitionKey(constraint, this.#partitionKey)\n    ) {\n      return undefined;\n    }\n    const takeStateKey = getTakeStateKey(this.#partitionKey, constraint);\n    const dirty = this.#dirtyPartitions.get(takeStateKey);\n    if (dirty) {\n      // While dirty in Phase 1, return gateBound (the bound prior to removals) so\n      // upstream operators (e.g. TakeGate) remain capped rather than unbounding during push.\n      return dirty.gateBound;\n    }\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState || takeState.size < this.#limit) {\n      return undefined;\n    }\n    return takeState.bound;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintContainsPartitionKey(req.constraint, this.#partitionKey)),\n      'Partitioned take does not allow unpartitioned fetches',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState) {\n      if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {\n        yield* this.#initialFetch(req);\n      }\n      return;\n    }\n    if (takeState.bound === undefined) {\n      return;\n    }\n    let count = 0;\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n        return;\n      }\n      if (\n        this.#rowHiddenFromFetch &&\n        this.getSchema().compareRows(\n          this.#rowHiddenFromFetch,\n          inputNode.row,\n        ) === 0\n      ) {\n        continue;\n      }\n      yield inputNode;\n      count++;\n      if (count >= this.#limit) {\n        return;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(takeStateKey) === undefined,\n      'Take state should be undefined',\n    );\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(takeStateKey, size, bound);\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        if (this.#dirtyPartitions.has(takeStateKey)) {\n          // While dirty with an unresolved deficit in Phase 1, only admit rows that\n          // sort strictly before the current window boundary. We refuse to expand the\n          // bound forward during Phase 1 so that Phase 2 can backfill earlier candidate\n          // rows from storage in sort order.\n          if (\n            takeState.bound === undefined ||\n            compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n          ) {\n            return;\n          }\n        }\n        const nextSize = takeState.size + 1;\n        if (nextSize === this.#limit) {\n          this.#dirtyPartitions.delete(takeStateKey);\n        }\n        this.#setTakeState(\n          takeStateKey,\n          nextSize,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0 || (compToBound < 0 && this.#limit === 1)) {\n        // change is not in window\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      const finalBound =\n        takeState.size - 1 === 0\n          ? undefined\n          : compToBound < 0\n            ? takeState.bound\n            : beforeBoundNode?.row;\n      if (!this.#dirtyPartitions.has(takeStateKey)) {\n        // Snapshot the pre-removal bound as the gate bound on the first removal that\n        // dirties this partition. Subsequent getBound() calls throughout Phase 1 will return\n        // this bound to keep upstream TakeGate bounded until Phase 2 refills deficits.\n        this.#dirtyPartitions.set(takeStateKey, {\n          constraint,\n          gateBound: takeState.bound,\n        });\n      }\n      this.#setTakeState(takeStateKey, takeState.size - 1, finalBound);\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const replaceBoundAndForwardChange = () => {\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n      );\n      return this.#output.push(change, this);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row);\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          newBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          afterBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row);\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(takeStateKey: string, size: number, bound: Row | undefined) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher?: InputBase): Stream<'yield'> {\n    if (this.#dirtyPartitions.size > 0) {\n      const dirty = [...this.#dirtyPartitions.entries()];\n      this.#dirtyPartitions.clear();\n\n      for (const [takeStateKey, {constraint}] of dirty) {\n        const takeState = this.#storage.get(takeStateKey);\n        assert(\n          takeState !== undefined,\n          'Take: dirty partition must exist in storage',\n        );\n        const deficit = this.#limit - takeState.size;\n        assert(deficit > 0, 'Take: dirty partition must have a deficit');\n\n        const toPush: Node[] = [];\n        this.#takeGate?.open();\n        try {\n          const stream = this.#input.fetch({\n            start: takeState.bound\n              ? {\n                  row: takeState.bound,\n                  basis: 'after',\n                }\n              : undefined,\n            constraint,\n          });\n\n          for (const node of stream) {\n            if (node === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            toPush.push(node);\n            if (toPush.length === deficit) {\n              break;\n            }\n          }\n        } finally {\n          this.#takeGate?.close();\n        }\n\n        let currentSize = takeState.size;\n        for (const node of toPush) {\n          currentSize++;\n          this.#setTakeState(takeStateKey, currentSize, node.row);\n          yield* this.#output.push(makeAddChange(node), this);\n        }\n      }\n    }\n\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintContainsPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"take.js","names":[],"sources":["../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, valueToKey, type Comparator, type Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport type {TakeBoundProvider, TakeGate} from './take-gate.ts';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: string): TakeState | undefined;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\ntype DirtyPartitionState = {\n  constraint: Constraint | undefined;\n  /**\n   * The bound to report to upstream TakeGate via getBound() until Phase 2\n   * reconciliation completes.\n   *\n   * When removals reduce partition size below limit in Phase 1, normal getBound()\n   * would return undefined (unbounded), which would cause upstream TakeGate to open\n   * and allow unbounded parent pushes through. Preserving gateBound keeps TakeGate\n   * capped at the pre-removal boundary until Phase 2 refills the deficit.\n   */\n  gateBound: Row | undefined;\n};\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator, TakeBoundProvider {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #takeGate: TakeGate | undefined;\n  /**\n   * Partitions that incurred removals in Phase 1 and require deficit refills in\n   * Phase 2 (reconcile). Keyed by `takeStateKey` (see `getTakeStateKey`), matching\n   * `#storage` keys: `'[\"take\"]'` when unpartitioned, `'take:' + valueToKey(value)` for one\n   * partition column, or `'[\"take\", ...partitionValues]'` for more.\n   */\n  readonly #dirtyPartitions = new Map<string, DirtyPartitionState>();\n\n  #output: Output = throwOutput;\n\n  setTakeGate(gate: TakeGate): void {\n    this.#takeGate = gate;\n  }\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  getBound(constraint?: Constraint): Row | undefined {\n    if (\n      this.#partitionKey &&\n      !constraintContainsPartitionKey(constraint, this.#partitionKey)\n    ) {\n      return undefined;\n    }\n    const takeStateKey = getTakeStateKey(this.#partitionKey, constraint);\n    const dirty = this.#dirtyPartitions.get(takeStateKey);\n    if (dirty) {\n      // While dirty in Phase 1, return gateBound (the bound prior to removals) so\n      // upstream operators (e.g. TakeGate) remain capped rather than unbounding during push.\n      return dirty.gateBound;\n    }\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState || takeState.size < this.#limit) {\n      return undefined;\n    }\n    return takeState.bound;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintContainsPartitionKey(req.constraint, this.#partitionKey)),\n      'Partitioned take does not allow unpartitioned fetches',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    const takeState = this.#storage.get(takeStateKey);\n    if (!takeState) {\n      if (constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {\n        yield* this.#initialFetch(req, takeStateKey);\n      }\n      return;\n    }\n    if (takeState.bound === undefined) {\n      return;\n    }\n    let count = 0;\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n        return;\n      }\n      if (\n        this.#rowHiddenFromFetch &&\n        this.getSchema().compareRows(\n          this.#rowHiddenFromFetch,\n          inputNode.row,\n        ) === 0\n      ) {\n        continue;\n      }\n      yield inputNode;\n      count++;\n      if (count >= this.#limit) {\n        return;\n      }\n    }\n  }\n\n  *#initialFetch(\n    req: FetchRequest,\n    takeStateKey: string,\n  ): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    // The caller (fetch) has already checked that there is no state for\n    // takeStateKey.\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(takeStateKey, size, bound);\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        if (this.#dirtyPartitions.has(takeStateKey)) {\n          // While dirty with an unresolved deficit in Phase 1, only admit rows that\n          // sort strictly before the current window boundary. We refuse to expand the\n          // bound forward during Phase 1 so that Phase 2 can backfill earlier candidate\n          // rows from storage in sort order.\n          if (\n            takeState.bound === undefined ||\n            compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n          ) {\n            return;\n          }\n        }\n        const nextSize = takeState.size + 1;\n        if (nextSize === this.#limit) {\n          this.#dirtyPartitions.delete(takeStateKey);\n        }\n        this.#setTakeState(\n          takeStateKey,\n          nextSize,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0 || (compToBound < 0 && this.#limit === 1)) {\n        // change is not in window\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      const finalBound =\n        takeState.size - 1 === 0\n          ? undefined\n          : compToBound < 0\n            ? takeState.bound\n            : beforeBoundNode?.row;\n      if (!this.#dirtyPartitions.has(takeStateKey)) {\n        // Snapshot the pre-removal bound as the gate bound on the first removal that\n        // dirties this partition. Subsequent getBound() calls throughout Phase 1 will return\n        // this bound to keep upstream TakeGate bounded until Phase 2 refills deficits.\n        this.#dirtyPartitions.set(takeStateKey, {\n          constraint,\n          gateBound: takeState.bound,\n        });\n      }\n      this.#setTakeState(takeStateKey, takeState.size - 1, finalBound);\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, constraint} = this.#getStateAndConstraint(\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const replaceBoundAndForwardChange = () => {\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n      );\n      return this.#output.push(change, this);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(takeStateKey, takeState.size, beforeBoundNode.row);\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          newBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(takeStateKey, takeState.size, newBoundNode.row);\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      this.#takeGate?.open();\n      try {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          afterBoundNode = node;\n          break;\n        }\n      } finally {\n        this.#takeGate?.close();\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(takeStateKey, takeState.size, afterBoundNode.row);\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(takeStateKey: string, size: number, bound: Row | undefined) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher?: InputBase): Stream<'yield'> {\n    if (this.#dirtyPartitions.size > 0) {\n      const dirty = [...this.#dirtyPartitions.entries()];\n      this.#dirtyPartitions.clear();\n\n      for (const [takeStateKey, {constraint}] of dirty) {\n        const takeState = this.#storage.get(takeStateKey);\n        assert(\n          takeState !== undefined,\n          'Take: dirty partition must exist in storage',\n        );\n        const deficit = this.#limit - takeState.size;\n        assert(deficit > 0, 'Take: dirty partition must have a deficit');\n\n        const toPush: Node[] = [];\n        this.#takeGate?.open();\n        try {\n          const stream = this.#input.fetch({\n            start: takeState.bound\n              ? {\n                  row: takeState.bound,\n                  basis: 'after',\n                }\n              : undefined,\n            constraint,\n          });\n\n          for (const node of stream) {\n            if (node === 'yield') {\n              yield 'yield';\n              continue;\n            }\n            toPush.push(node);\n            if (toPush.length === deficit) {\n              break;\n            }\n          }\n        } finally {\n          this.#takeGate?.close();\n        }\n\n        let currentSize = takeState.size;\n        for (const node of toPush) {\n          currentSize++;\n          this.#setTakeState(takeStateKey, currentSize, node.row);\n          yield* this.#output.push(makeAddChange(node), this);\n        }\n      }\n    }\n\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  if (partitionKey?.length === 1 && rowOrConstraint) {\n    return 'take:' + valueToKey(rowOrConstraint[partitionKey[0]]);\n  }\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintContainsPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/union-fan-in.d.ts

@@ -19,5 +19,4 @@ export declare class UnionFanIn implements Operator {
     setOutput(output: Output): void;
     reconcile(_pusher: InputBase): Stream<'yield'>;
 }
-export declare function mergeFetches(fetches: Iterable<Node | 'yield'>[], comparator: (l: Node, r: Node) => number): IterableIterator<Node | 'yield'>;
 //# sourceMappingURL=union-fan-in.d.ts.map

package/out/zql/src/ivm/union-fan-in.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"union-fan-in.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/union-fan-in.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEpD,qBAAa,UAAW,YAAW,QAAQ;;IASzC,YAAY,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,EAgE/C;IAED,OAAO,IAAI,IAAI,CAId;IAED,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAY/C;IAED,SAAS,IAAI,YAAY,CAExB;IAED,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAMvD;IAwFD,oBAAoB,SAMnB;IAED,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAyB/D;IAED,wBAAwB,SAMvB;IAEA,qBAAqB,IAAI,MAAM,CAAC,OAAO,CAAC,CAYxC;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAO9C;CACF;AAWD,wBAAiB,YAAY,CAC3B,OAAO,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC,EAAE,EACnC,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,KAAK,MAAM,GACvC,gBAAgB,CAAC,IAAI,GAAG,OAAO,CAAC,CA0FlC"}
+{"version":3,"file":"union-fan-in.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/union-fan-in.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEpD,qBAAa,UAAW,YAAW,QAAQ;;IASzC,YAAY,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,EAgE/C;IAED,OAAO,IAAI,IAAI,CAId;IAED,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAY/C;IAED,SAAS,IAAI,YAAY,CAExB;IAED,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAMvD;IAwFD,oBAAoB,SAMnB;IAED,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAyB/D;IAED,wBAAwB,SAMvB;IAEA,qBAAqB,IAAI,MAAM,CAAC,OAAO,CAAC,CAYxC;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAO9C;CACF"}

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

@@ -1,6 +1,6 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { emptyArray } from "../../../shared/src/sentinels.js";
 import { throwOutput } from "./operator.js";
+import { emptyArray } from "../../../shared/src/sentinels.js";
 import { makeAddEmptyRelationships, mergeEmpty, mergeRelationships, pushAccumulatedChanges, pushWitnessDeltas } from "./push-accumulated.js";
 //#region ../zql/src/ivm/union-fan-in.ts
 var UnionFanIn = class {