@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

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

@@ -1 +1 @@
-{"version":3,"file":"push-accumulated.js","names":[],"sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {InputBase, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * # pushAccumulatedChanges\n *\n * Pushes the changes that were accumulated by\n * [fan-out, fan-in] or [ufo, ufi] sub-graphs.\n *\n * This function is called at the end of the sub-graph.\n *\n * The sub-graphs represents `OR`s.\n *\n * Changes that can enter the subgraphs:\n * 1. child (due to exist joins being above the sub-graph)\n * 2. add\n * 3. remove\n * 4. edit\n *\n * # Changes that can exit into `pushAccumulatedChanges`:\n *\n * ## Child\n * If a `child` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `child` change\n * - stop the `child` change (e.g., filter)\n * - convert it to an `add` or `remove` (e.g., exists filter)\n *\n * ## Add\n * If an `add` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `add` change\n * - hide the change (e.g., filter)\n *\n * ## Remove\n * If a `remove` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `remove` change\n * - hide the change (e.g., filter)\n *\n * ## Edit\n * If an `edit` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `edit` change\n * - convert it to an `add` (e.g., filter where old didn't match but new does)\n * - convert it to a `remove` (e.g., filter where old matched but new doesn't)\n *\n * This results in some invariants:\n * - an add coming in will only create adds coming out\n * - a remove coming in will only create removes coming out\n * - an edit coming in can create adds, removes, and edits coming out\n * - a child coming in can create adds, removes, and children coming out\n *\n * # Return of `pushAccumulatedChanges`\n *\n * This function will only push a single change.\n * Given the above invariants, how is this possible?\n *\n * An add that becomes many `adds` results in a single add\n * as the `add` is the same row across all adds. Branches do not change the row.\n *\n * A remove that becomes many `removes` results in a single remove\n * for the same reason.\n *\n * If a child enters and exits, it takes precedence over all other changes.\n * If a child enters and is converted only to add and remove it exits as an edit.\n * If a child enters and is converted to only add or only remove, it exits as that change.\n *\n * If an edit enters and is converted to add and remove it exits as an edit.\n * If an edit enters and is converted to only add or only remove, it exits as that change.\n * If an edit enters and exits as edits only, it exits as a single edit.\n */\nexport function* pushAccumulatedChanges(\n  accumulatedPushes: Change[],\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: ChangeType,\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n): Stream<'yield'> {\n  if (accumulatedPushes.length === 0) {\n    // It is possible for no forks to pass along the push.\n    // E.g., if no filters match in any fork.\n    return;\n  }\n\n  // collapse down to a single change per type\n  const candidatesToPush = new Map<ChangeType, Change>();\n  for (const change of accumulatedPushes) {\n    if (\n      fanOutChangeType === ChangeType.CHILD &&\n      change[ChangeIndex.TYPE] !== ChangeType.CHILD\n    ) {\n      assert(\n        candidatesToPush.has(change[ChangeIndex.TYPE]) === false,\n        () =>\n          `Fan-in:child expected at most one ${change[ChangeIndex.TYPE]} when fan-out is of type child`,\n      );\n    }\n\n    const existing = candidatesToPush.get(change[ChangeIndex.TYPE]);\n    let mergedChange = change;\n    if (existing) {\n      // merge in relationships\n      mergedChange = mergeRelationships(existing, change);\n    }\n    candidatesToPush.set(change[ChangeIndex.TYPE], mergedChange);\n  }\n\n  accumulatedPushes.length = 0;\n\n  const types = [...candidatesToPush.keys()];\n  /**\n   * Based on the received `fanOutChangeType` only certain output types are valid.\n   *\n   * - remove must result in all removes\n   * - add must result in all adds\n   * - edit must result in add or removes or edits\n   * - child must result in a single add or single remove or many child changes\n   *    - Single add or remove because the relationship will be unique to one exist check within the fan-out,fan-in sub-graph\n   *    - Many child changes because other operators may preserve the child change\n   */\n  switch (fanOutChangeType) {\n    case ChangeType.REMOVE:\n      assert(\n        types.length === 1 && types[0] === ChangeType.REMOVE,\n        'Fan-in:remove expected all removes',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.REMOVE))),\n        pusher,\n      );\n      return;\n    case ChangeType.ADD:\n      assert(\n        types.length === 1 && types[0] === ChangeType.ADD,\n        'Fan-in:add expected all adds',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.ADD))),\n        pusher,\n      );\n      return;\n    case ChangeType.EDIT: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD ||\n            type === ChangeType.REMOVE ||\n            type === ChangeType.EDIT,\n        ),\n        'Fan-in:edit expected all adds, removes, or edits',\n      );\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n      let editChange = candidatesToPush.get(ChangeType.EDIT);\n\n      // If an `edit` is present, it supersedes `add` and `remove`\n      // as it semantically represents both.\n      if (editChange) {\n        if (addChange) {\n          editChange = mergeRelationships(editChange, addChange);\n        }\n        if (removeChange) {\n          editChange = mergeRelationships(editChange, removeChange);\n        }\n        yield* output.push(addEmptyRelationships(editChange), pusher);\n        return;\n      }\n\n      // If `edit` didn't make it through but both `add` and `remove` did,\n      // convert back to an edit.\n      //\n      // When can this happen?\n      //\n      //  EDIT old: a=1, new: a=2\n      //            |\n      //          FanOut\n      //          /    \\\n      //         a=1   a=2\n      //          |     |\n      //        remove  add\n      //          \\     /\n      //           FanIn\n      //\n      // The left filter converts the edit into a remove.\n      // The right filter converts the edit into an add.\n      if (addChange && removeChange) {\n        yield* output.push(\n          addEmptyRelationships(\n            makeEditChange(\n              addChange[ChangeIndex.NODE],\n              removeChange[ChangeIndex.NODE],\n            ),\n          ),\n          pusher,\n        );\n        return;\n      }\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    case ChangeType.CHILD: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD || // exists can change child to add or remove\n            type === ChangeType.REMOVE || // exists can change child to add or remove\n            type === ChangeType.CHILD, // other operators may preserve the child change\n        ),\n        'Fan-in:child expected all adds, removes, or children',\n      );\n      assert(\n        types.length <= 2,\n        'Fan-in:child expected at most 2 types on a child change from fan-out',\n      );\n\n      // If any branch preserved the original child change, that takes precedence over all other changes.\n      const childChange = candidatesToPush.get(ChangeType.CHILD);\n      if (childChange) {\n        yield* output.push(childChange, pusher);\n        return;\n      }\n\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n\n      assert(\n        addChange === undefined || removeChange === undefined,\n        'Fan-in:child expected either add or remove, not both',\n      );\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    default:\n      fanOutChangeType satisfies never;\n  }\n}\n\n/**\n * Puts relationships from `right` into `left` if they don't already exist in `left`.\n */\nexport function mergeRelationships(left: Change, right: Change): Change {\n  // change types will always match\n  // unless we have an edit on the left\n  // then the right could be edit, add, or remove\n  if (left[ChangeIndex.TYPE] === right[ChangeIndex.TYPE]) {\n    switch (left[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        return makeAddChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.REMOVE: {\n        return makeRemoveChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.EDIT: {\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.EDIT,\n          () =>\n            `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right[ChangeIndex.TYPE]}`,\n        );\n        // merge edits into a single edit\n        return makeEditChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          {\n            row: left[ChangeIndex.OLD_NODE].row,\n            relationships: {\n              ...right[ChangeIndex.OLD_NODE].relationships,\n              ...left[ChangeIndex.OLD_NODE].relationships,\n            },\n          },\n        );\n      }\n      case ChangeType.CHILD: {\n        // Multiple branches may preserve the same child change, each adding\n        // different relationships. Merge the relationships, keeping the child\n        // (which should be identical across branches).\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.CHILD,\n          () =>\n            `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right[ChangeIndex.TYPE]}`,\n        );\n        return makeChildChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          left[ChangeIndex.CHILD_DATA],\n        );\n      }\n    }\n  }\n\n  // left is always an edit here\n  assert(\n    left[ChangeIndex.TYPE] === ChangeType.EDIT,\n    () =>\n      `mergeRelationships: when types differ, left.type must be edit, got left.type=${left[ChangeIndex.TYPE]}, right.type=${right[ChangeIndex.TYPE]}`,\n  );\n  switch (right[ChangeIndex.TYPE]) {\n    case ChangeType.ADD: {\n      return makeEditChange(\n        {\n          ...left[ChangeIndex.NODE],\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        },\n        left[ChangeIndex.OLD_NODE],\n      );\n    }\n    case ChangeType.REMOVE: {\n      return makeEditChange(left[ChangeIndex.NODE], {\n        ...left[ChangeIndex.OLD_NODE],\n        relationships: {\n          ...right[ChangeIndex.NODE].relationships,\n          ...left[ChangeIndex.OLD_NODE].relationships,\n        },\n      });\n    }\n  }\n\n  unreachable();\n}\n\nexport function makeAddEmptyRelationships(\n  schema: SourceSchema,\n): (change: Change) => Change {\n  return (change: Change): Change => {\n    if (Object.keys(schema.relationships).length === 0) {\n      return change;\n    }\n\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeAddChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.REMOVE: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeRemoveChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.EDIT: {\n        const nodeRelationships = {...change[ChangeIndex.NODE].relationships};\n        const oldNodeRelationships = {\n          ...change[ChangeIndex.OLD_NODE].relationships,\n        };\n        mergeEmpty(nodeRelationships, Object.keys(schema.relationships));\n        mergeEmpty(oldNodeRelationships, Object.keys(schema.relationships));\n        return makeEditChange(\n          {row: change[ChangeIndex.NODE].row, relationships: nodeRelationships},\n          {\n            row: change[ChangeIndex.OLD_NODE].row,\n            relationships: oldNodeRelationships,\n          },\n        );\n      }\n      case ChangeType.CHILD:\n        return change; // children only have relationships along the path to the change\n    }\n  };\n}\n\n/**\n * For each relationship in `schema` that does not exist\n * in `relationships`, add it with an empty stream.\n *\n * This modifies the `relationships` object in place.\n */\nexport function mergeEmpty(\n  relationships: Record<string, () => Stream<Node | 'yield'>>,\n  relationshipNames: string[],\n) {\n  for (const relName of relationshipNames) {\n    if (relationships[relName] === undefined) {\n      relationships[relName] = () => emptyArray;\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"push-accumulated.js","names":[],"sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {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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"}

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

@@ -1,7 +1,7 @@
 import type { Row } from '../../../zero-protocol/src/data.ts';
 import { type Change } from './change.ts';
 import type { Node } from './data.ts';
-import { type FetchRequest, type Input, type Operator, type Output } from './operator.ts';
+import { type FetchRequest, type Input, type InputBase, type Operator, type Output } from './operator.ts';
 import type { SourceSchema } from './schema.ts';
 import type { Stream } from './stream.ts';
 export type Bound = {
@@ -20,5 +20,6 @@ export declare class Skip implements Operator {
     setOutput(output: Output): void;
     destroy(): void;
     push(change: Change): Stream<'yield'>;
+    reconcile(_pusher: InputBase): Stream<'yield'>;
 }
 //# sourceMappingURL=skip.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAG5D,OAAO,EAEL,KAAK,MAAM,EAGZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAEhD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,IAAK,YAAW,QAAQ;;IAOnC,YAAY,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAOrC;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAoBhD;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,IAAI,IAAI,CAEd;IAOA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiBrC;CA8DF"}
+{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAG5D,OAAO,EAEL,KAAK,MAAM,EAGZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAEhD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,IAAK,YAAW,QAAQ;;IAOnC,YAAY,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAOrC;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAoBhD;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,IAAI,IAAI,CAEd;IAOA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiBrC;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;CA8DF"}

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

@@ -60,6 +60,9 @@ var Skip = class {
 		}
 		if (shouldBePresent(change[1].row)) yield* this.#output.push(change, this);
 	}
+	*reconcile(_pusher) {
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
+	}
 	#getStart(req) {
 		const boundStart = {
 			row: this.#bound.row,

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

@@ -1 +1 @@
-{"version":3,"file":"skip.js","names":["#input","#bound","#comparator","#getStart","#shouldBePresent","#output"],"sources":["../../../../../zql/src/ivm/skip.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  type AddChange,\n  type Change,\n  type ChildChange,\n  type RemoveChange,\n} from './change.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Bound = {\n  row: Row;\n  exclusive: boolean;\n};\n\n/**\n * Skip sets the start position for the pipeline. No rows before the bound will\n * be output.\n */\nexport class Skip implements Operator {\n  readonly #input: Input;\n  readonly #bound: Bound;\n  readonly #comparator: Comparator;\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, bound: Bound) {\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Skip requires sorted input');\n    this.#input = input;\n    this.#bound = bound;\n    this.#comparator = input.getSchema().compareRows;\n    input.setOutput(this);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const start = this.#getStart(req);\n    if (start === 'empty') {\n      return;\n    }\n    const nodes = this.#input.fetch({...req, start});\n    if (!req.reverse) {\n      yield* nodes;\n      return;\n    }\n    for (const node of nodes) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (!this.#shouldBePresent(node.row)) {\n        return;\n      }\n      yield node;\n    }\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  #shouldBePresent(row: Row): boolean {\n    const cmp = this.#comparator(this.#bound.row, row);\n    return cmp < 0 || (cmp === 0 && !this.#bound.exclusive);\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const shouldBePresent = (row: Row) => this.#shouldBePresent(row);\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* maybeSplitAndPushEditChange(\n        change,\n        shouldBePresent,\n        this.#output,\n        this,\n      );\n      return;\n    }\n\n    change satisfies AddChange | RemoveChange | ChildChange;\n\n    if (shouldBePresent(change[ChangeIndex.NODE].row)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  #getStart(req: FetchRequest): Start | undefined | 'empty' {\n    const boundStart = {\n      row: this.#bound.row,\n      basis: this.#bound.exclusive ? 'after' : 'at',\n    } as const;\n\n    if (!req.start) {\n      if (req.reverse) {\n        return undefined;\n      }\n      return boundStart;\n    }\n\n    const cmp = this.#comparator(this.#bound.row, req.start.row);\n\n    if (!req.reverse) {\n      // The skip bound is after the requested bound. The requested bound cannot\n      // be relevant because even if it was basis: 'after', the skip bound is\n      // itself after the requested bound. Return the skip bound.\n      if (cmp > 0) {\n        return boundStart;\n      }\n\n      // The skip bound and requested bound are equal. If either is exclusive,\n      // return that bound with exclusive. Otherwise, return the skip bound.\n      if (cmp === 0) {\n        if (this.#bound.exclusive || req.start.basis === 'after') {\n          return {\n            row: this.#bound.row,\n            basis: 'after',\n          };\n        }\n        return boundStart;\n      }\n\n      return req.start;\n    }\n\n    req.reverse satisfies true;\n\n    // bound is after the start, but request is for reverse so results\n    // must be empty\n    if (cmp > 0) {\n      return 'empty';\n    }\n\n    if (cmp === 0) {\n      // if both are inclusive, the result can be the single row at bound\n      // return it as start\n      if (!this.#bound.exclusive && req.start.basis === 'at') {\n        return boundStart;\n      }\n      // otherwise the results must be empty, one or both are exclusive\n      // in opposite directions\n      return 'empty';\n    }\n\n    // bound is before the start, return start\n    return req.start;\n  }\n}\n"],"mappings":";;;;;;;;AAgCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,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,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":["#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"}

package/out/zql/src/ivm/take-gate.d.ts

@@ -0,0 +1,57 @@
+import type { Row } from '../../../zero-protocol/src/data.ts';
+import type { Change } from './change.ts';
+import { type Constraint } from './constraint.ts';
+import type { Comparator, Node } from './data.ts';
+import { type FetchRequest, type Input, type InputBase, type Operator, type Output } from './operator.ts';
+import type { SourceSchema } from './schema.ts';
+import type { Stream } from './stream.ts';
+export interface TakeBoundProvider {
+    getBound(constraint?: Constraint): Row | undefined;
+}
+/**
+ * The bound that a TakeGate caps one parent fetch of a join's child push at.
+ * `undefined` means the fetch is not capped.
+ */
+export type ParentFetchBound = {
+    readonly constraint: Constraint;
+    readonly bound: Row | undefined;
+};
+/**
+ * Reads the bounds for the parent fetches of a child push before the join
+ * starts them. TakeGate reads its bound once, when a fetch starts, so the set
+ * of parents that get the push stays fixed even when Take moves its bound
+ * during the push. Split-push overlays must use these bounds, not the bound
+ * Take reports later in the push.
+ */
+export declare function readParentFetchBounds(boundProvider: TakeBoundProvider, constraints: readonly Constraint[]): ParentFetchBound[];
+/**
+ * Returns true if one of the parent fetches of the push yields `row`: `row`
+ * matches the fetch's constraint and is not after the fetch's bound.
+ */
+export declare function isInParentFetch(bounds: readonly ParentFetchBound[], row: Row, compareRows: Comparator): boolean;
+/**
+ * TakeGate bounds upstream parent fetches using the active bound from a
+ * downstream Take operator.
+ *
+ * When a child table changes, joins fetch matching parent rows. Without
+ * TakeGate, this fetch scans all matching parent rows (which may be thousands)
+ * even if downstream Take only needs a few. TakeGate intercepts this fetch and
+ * stops the upstream stream once rows exceed Take's bound.
+ */
+export declare class TakeGate implements Operator, TakeBoundProvider {
+    #private;
+    constructor(input: Input);
+    open(): void;
+    close(): void;
+    isOpen(): boolean;
+    setBoundProvider(provider: TakeBoundProvider): void;
+    getBoundProvider(): TakeBoundProvider | undefined;
+    getBound(constraint?: Constraint): Row | undefined;
+    getSchema(): SourceSchema;
+    setOutput(output: Output): void;
+    destroy(): void;
+    push(change: Change, _pusher: InputBase): Stream<'yield'>;
+    reconcile(_pusher: InputBase): Stream<'yield'>;
+    fetch(req: FetchRequest): Stream<Node | 'yield'>;
+}
+//# sourceMappingURL=take-gate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-gate.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAuB,KAAK,UAAU,EAAC,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAC,UAAU,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAAC;CACpD;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,iBAAiB,EAChC,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,gBAAgB,EAAE,CAKpB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,UAAU,GACtB,OAAO,CAOT;AAED;;;;;;;;GAQG;AACH,qBAAa,QAAS,YAAW,QAAQ,EAAE,iBAAiB;;IAO1D,YAAY,KAAK,EAAE,KAAK,EAMvB;IAED,IAAI,IAAI,IAAI,CAEX;IAED,KAAK,IAAI,IAAI,CAGZ;IAED,MAAM,IAAI,OAAO,CAEhB;IAED,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAElD;IAED,gBAAgB,IAAI,iBAAiB,GAAG,SAAS,CAEhD;IAED,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAKjD;IAED,SAAS,IAAI,YAAY,CAExB;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,IAAI,IAAI,CAEd;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAEzD;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAsBhD;CACF"}

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

@@ -0,0 +1,106 @@
+import { assert } from "../../../shared/src/asserts.js";
+import { throwOutput } from "./operator.js";
+import { constraintMatchesRow } from "./constraint.js";
+//#region ../zql/src/ivm/take-gate.ts
+/**
+* Reads the bounds for the parent fetches of a child push before the join
+* starts them. TakeGate reads its bound once, when a fetch starts, so the set
+* of parents that get the push stays fixed even when Take moves its bound
+* during the push. Split-push overlays must use these bounds, not the bound
+* Take reports later in the push.
+*/
+function readParentFetchBounds(boundProvider, constraints) {
+	return constraints.map((constraint) => ({
+		constraint,
+		bound: boundProvider.getBound(constraint)
+	}));
+}
+/**
+* Returns true if one of the parent fetches of the push yields `row`: `row`
+* matches the fetch's constraint and is not after the fetch's bound.
+*/
+function isInParentFetch(bounds, row, compareRows) {
+	for (const { constraint, bound } of bounds) if (constraintMatchesRow(constraint, row)) return bound === void 0 || compareRows(row, bound) <= 0;
+	return false;
+}
+/**
+* TakeGate bounds upstream parent fetches using the active bound from a
+* downstream Take operator.
+*
+* When a child table changes, joins fetch matching parent rows. Without
+* TakeGate, this fetch scans all matching parent rows (which may be thousands)
+* even if downstream Take only needs a few. TakeGate intercepts this fetch and
+* stops the upstream stream once rows exceed Take's bound.
+*/
+var TakeGate = class {
+	#input;
+	#comparator;
+	#boundProvider;
+	#output = throwOutput;
+	#openDepth = 0;
+	constructor(input) {
+		const { sort, compareRows } = input.getSchema();
+		assert(sort !== void 0, "TakeGate requires sorted input");
+		this.#input = input;
+		this.#comparator = compareRows;
+		input.setOutput(this);
+	}
+	open() {
+		this.#openDepth++;
+	}
+	close() {
+		assert(this.#openDepth > 0, "TakeGate.close called without matching open");
+		this.#openDepth--;
+	}
+	isOpen() {
+		return this.#openDepth > 0;
+	}
+	setBoundProvider(provider) {
+		this.#boundProvider = provider;
+	}
+	getBoundProvider() {
+		return this.#boundProvider;
+	}
+	getBound(constraint) {
+		if (this.#openDepth > 0) return;
+		return this.#boundProvider?.getBound(constraint);
+	}
+	getSchema() {
+		return this.#input.getSchema();
+	}
+	setOutput(output) {
+		this.#output = output;
+	}
+	destroy() {
+		this.#input.destroy();
+	}
+	*push(change, _pusher) {
+		yield* this.#output.push(change, this);
+	}
+	*reconcile(_pusher) {
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
+	}
+	*fetch(req) {
+		if (this.#openDepth > 0 || req.reverse) {
+			yield* this.#input.fetch(req);
+			return;
+		}
+		const bound = this.#boundProvider?.getBound(req.constraint);
+		if (!bound) {
+			yield* this.#input.fetch(req);
+			return;
+		}
+		for (const node of this.#input.fetch(req)) {
+			if (node === "yield") {
+				yield "yield";
+				continue;
+			}
+			if (this.#comparator(node.row, bound) > 0) return;
+			yield node;
+		}
+	}
+};
+//#endregion
+export { TakeGate, isInParentFetch, readParentFetchBounds };
+
+//# sourceMappingURL=take-gate.js.map

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

@@ -0,0 +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"}

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

@@ -1,10 +1,12 @@
+import type { Row } from '../../../zero-protocol/src/data.ts';
 import type { PrimaryKey } from '../../../zero-protocol/src/primary-key.ts';
 import { type Change } from './change.ts';
 import type { Constraint } from './constraint.ts';
 import { type Comparator, type Node } from './data.ts';
-import { type FetchRequest, type Input, type Operator, type Output, type Storage } from './operator.ts';
+import { type FetchRequest, type Input, type InputBase, type Operator, type Output, type Storage } from './operator.ts';
 import type { SourceSchema } from './schema.ts';
 import { type Stream } from './stream.ts';
+import type { TakeBoundProvider, TakeGate } from './take-gate.ts';
 export type PartitionKey = PrimaryKey;
 /**
  * The Take operator is for implementing limit queries. It takes the first n
@@ -17,15 +19,19 @@ export type PartitionKey = PrimaryKey;
  * Maintains the invariant that its output size is always <= limit, even
  * mid processing of a push.
  */
-export declare class Take implements Operator {
+export declare class Take implements Operator, TakeBoundProvider {
     #private;
+    setTakeGate(gate: TakeGate): void;
     constructor(input: Input, storage: Storage, limit: number, partitionKey?: PartitionKey);
     setOutput(output: Output): void;
     getSchema(): SourceSchema;
+    getBound(constraint?: Constraint): Row | undefined;
     fetch(req: FetchRequest): Stream<Node | 'yield'>;
     push(change: Change): Stream<'yield'>;
     destroy(): void;
+    reconcile(_pusher?: InputBase): Stream<'yield'>;
 }
 export declare function constraintMatchesPartitionKey(constraint: Constraint | undefined, partitionKey: PartitionKey | undefined): boolean;
+export declare function constraintContainsPartitionKey(constraint: Constraint | undefined, partitionKey: PartitionKey | undefined): boolean;
 export declare function makePartitionKeyComparator(partitionKey: PartitionKey): Comparator;
 //# sourceMappingURL=take.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAI1E,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAiBxC,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,QAAQ;;IAWnC,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;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CA+DhD;IA2FA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAuLrC;IAmRD,OAAO,IAAI,IAAI,CAEd;CACF;AAmBD,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,OAAO,CAaT;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,GACzB,UAAU,CAUZ"}
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take.ts"],"names":[],"mappings":"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"}