@rocicorp/zero 1.12.0-canary.2 → 1.12.0-canary.4

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

@@ -1 +1 @@
-{"version":3,"file":"memory-source.js","names":["#tableName","#columns","#primaryKey","#primaryIndexSort","#indexes","#connections","#getPrimaryIndex","#fetch","#disconnect","#getSchema","#fetchMulti","#getOrCreateIndex","#overlay","#writeChange","#pushEpoch"],"sources":["../../../../../zql/src/ivm/memory-source.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {BTreeSet} from '../../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport {once, toSorted} from '../../../shared/src/iterables.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  Condition,\n  Ordering,\n  OrderPart,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-types/src/schema-value.ts';\nimport type {DebugDelegate} from '../builder/debug-delegate.ts';\nimport {\n  createPredicate,\n  transformFilters,\n  type NoSubqueryCondition,\n} from '../builder/filter.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {makeAddChange, makeEditChange, makeRemoveChange} from './change.ts';\nimport {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  primaryKeyConstraintFromFilters,\n  type Constraint,\n} from './constraint.ts';\nimport {\n  compareValues,\n  makeComparator,\n  valuesEqual,\n  type Comparator,\n  type Node,\n} from './data.ts';\nimport {filterPush} from './filter-push.ts';\nimport {\n  skipYields,\n  type FetchRequest,\n  type Input,\n  type MultiConstraint,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {SourceChangeIndex} from './source-change-index.ts';\nimport type {\n  Source,\n  SourceChange,\n  SourceChangeAdd,\n  SourceChangeEdit,\n  SourceChangeRemove,\n  SourceInput,\n} from './source.ts';\nimport {makeSourceChangeAdd, makeSourceChangeRemove} from './source.ts';\nimport {consume, type Stream} from './stream.ts';\n\nexport type Overlay = {\n  epoch: number;\n  change: SourceChange;\n};\n\nexport type Overlays = {\n  add: Row | undefined;\n  remove: Row | undefined;\n};\n\ntype Index = {\n  comparator: Comparator;\n  data: BTreeSet<Row>;\n};\n\nexport type Connection = {\n  input: Input;\n  output: Output | undefined;\n  sort?: Ordering | undefined;\n  splitEditKeys: Set<string> | undefined;\n  compareRows: Comparator;\n  filters:\n    | {\n        condition: NoSubqueryCondition;\n        predicate: (row: Row) => boolean;\n      }\n    | undefined;\n  readonly debug?: DebugDelegate | undefined;\n  lastPushedEpoch: number;\n};\n\n/**\n * A `MemorySource` is a source that provides data to the pipeline from an\n * in-memory data source.\n *\n * This data is kept in sorted order as downstream pipelines will always expect\n * the data they receive from `pull` to be in sorted order.\n */\nexport class MemorySource implements Source {\n  readonly #tableName: string;\n  readonly #columns: Record<string, SchemaValue>;\n  readonly #primaryKey: PrimaryKey;\n  readonly #primaryIndexSort: Ordering;\n  readonly #indexes: Map<string, Index> = new Map();\n  readonly #connections: Connection[] = [];\n\n  #overlay: Overlay | undefined;\n  #pushEpoch = 0;\n\n  constructor(\n    tableName: string,\n    columns: Record<string, SchemaValue>,\n    primaryKey: PrimaryKey,\n    primaryIndexData?: BTreeSet<Row>,\n  ) {\n    this.#tableName = tableName;\n    this.#columns = columns;\n    this.#primaryKey = primaryKey;\n    this.#primaryIndexSort = primaryKey.map(k => [k, 'asc']);\n    const comparator = makeBoundComparator(this.#primaryIndexSort);\n    this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {\n      comparator,\n      data: primaryIndexData ?? new BTreeSet<Row>(comparator),\n    });\n  }\n\n  get tableSchema() {\n    return {\n      name: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n    };\n  }\n\n  fork() {\n    const primaryIndex = this.#getPrimaryIndex();\n    return new MemorySource(\n      this.#tableName,\n      this.#columns,\n      this.#primaryKey,\n      primaryIndex.data.clone(),\n    );\n  }\n\n  get data(): BTreeSet<Row> {\n    return this.#getPrimaryIndex().data;\n  }\n\n  #getSchema(connection: Connection, unordered: boolean): SourceSchema {\n    return {\n      tableName: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n      sort: unordered ? undefined : connection.sort,\n      system: 'client',\n      relationships: {},\n      isHidden: false,\n      compareRows: connection.compareRows,\n    };\n  }\n\n  connect(\n    sort: Ordering | undefined,\n    filters?: Condition,\n    splitEditKeys?: Set<string>,\n  ): SourceInput {\n    const transformedFilters = transformFilters(filters);\n    const unordered = sort === undefined;\n    const internalSort = sort ?? this.#primaryIndexSort;\n\n    const input: SourceInput = {\n      getSchema: () => schema,\n      fetch: req => this.#fetch(req, connection),\n      setOutput: output => {\n        connection.output = output;\n      },\n      destroy: () => {\n        this.#disconnect(input);\n      },\n      fullyAppliedFilters: !transformedFilters.conditionsRemoved,\n    };\n\n    const connection: Connection = {\n      input,\n      output: undefined,\n      sort: internalSort,\n      splitEditKeys,\n      compareRows: makeComparator(internalSort),\n      filters: transformedFilters.filters\n        ? {\n            condition: transformedFilters.filters,\n            predicate: createPredicate(transformedFilters.filters),\n          }\n        : undefined,\n      lastPushedEpoch: 0,\n    };\n    const schema = this.#getSchema(connection, unordered);\n    if (!unordered) {\n      assertOrderingIncludesPK(internalSort, this.#primaryKey);\n    }\n    this.#connections.push(connection);\n    return input;\n  }\n\n  #disconnect(input: Input): void {\n    const idx = this.#connections.findIndex(c => c.input === input);\n    assert(idx !== -1, 'Connection not found');\n    this.#connections.splice(idx, 1);\n\n    // Indexes deliberately hold no reference back to the connections that use\n    // them. They used to, to support deleting an index once its last user went\n    // away. That deletion is gone (see below) but the `usedBy` set outlived it,\n    // so an index kept every `Connection` — and through its `input` and\n    // `output`, the whole torn-down pipeline — reachable for as long as the\n    // source lived.\n    //\n    // TODO: We used to delete unused indexes here. But in common cases like\n    // navigating into issue detail pages it caused a ton of constantly\n    // building and destroying indexes.\n    //\n    // Perhaps some intelligent LRU or something is needed here but for now,\n    // the opposite extreme of keeping all indexes for the lifetime of the\n    // page seems better.\n  }\n\n  #getPrimaryIndex(): Index {\n    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));\n    assert(index, 'Primary index not found');\n    return index;\n  }\n\n  #getOrCreateIndex(sort: Ordering): Index {\n    const key = JSON.stringify(sort);\n    const index = this.#indexes.get(key);\n    // Future optimization could use existing index if it's the same just sorted\n    // in reverse of needed.\n    if (index) {\n      return index;\n    }\n\n    const comparator = makeBoundComparator(sort);\n\n    // When creating these synchronously becomes a problem, a few options:\n    // 1. Allow users to specify needed indexes up front\n    // 2. Create indexes in a different thread asynchronously (this would require\n    // modifying the BTree to be able to be passed over structured-clone, or using\n    // a different library.)\n    // 3. We could even theoretically do (2) on multiple threads and then merge the\n    // results!\n    const rows = toSorted(this.#getPrimaryIndex().data, comparator);\n    const data = BTreeSet.fromSorted(comparator, rows);\n\n    const newIndex = {comparator, data};\n    this.#indexes.set(key, newIndex);\n    return newIndex;\n  }\n\n  // For unit testing that we correctly clean up indexes.\n  getIndexKeys(): string[] {\n    return [...this.#indexes.keys()];\n  }\n\n  *#fetch(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // multiConstraints is handled by driving sub-fetches off the first\n    // entry's values and post-filtering matches against any remaining\n    // entries. TableSource implements multi-IN natively via SQL `AND` of\n    // `IN` clauses; the in-memory path is correct but not specially\n    // optimized — it pays the index-seek cost per primary value, then\n    // walks each result against the rest.\n    if (\n      req.multiConstraints &&\n      req.multiConstraints.some(mc => mc.length > 0)\n    ) {\n      yield* this.#fetchMulti(req, conn);\n      return;\n    }\n    const requestedSort = must(conn.sort);\n    const {compareRows} = conn;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const connectionComparator: Comparator = req.reverse\n      ? (r1, r2) => compareRows(r2, r1)\n      : compareRows;\n\n    const reqFilter = req.filter;\n    const connFilterCondition = conn.filters?.condition;\n    const mergedFilterCondition: NoSubqueryCondition | undefined =\n      connFilterCondition && reqFilter\n        ? {type: 'and', conditions: [connFilterCondition, reqFilter]}\n        : (connFilterCondition ?? reqFilter);\n    const mergedFilterPredicate = mergePredicates(\n      conn.filters?.predicate,\n      reqFilter,\n    );\n\n    const pkConstraint = primaryKeyConstraintFromFilters(\n      mergedFilterCondition,\n      this.#primaryKey,\n    );\n    // The primary key constraint will be more limiting than the constraint\n    // so swap out to that if it exists.\n    const fetchOrPkConstraint = pkConstraint ?? req.constraint;\n\n    // If there is a constraint, we need an index sorted by it first.\n    const indexSort: OrderPart[] = [];\n    if (fetchOrPkConstraint) {\n      for (const key of Object.keys(fetchOrPkConstraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n\n    // For the special case of constraining by PK, we don't need to worry about\n    // any requested sort since there can only be one result. Otherwise we also\n    // need the index sorted by the requested sort.\n    if (\n      this.#primaryKey.length > 1 ||\n      !fetchOrPkConstraint ||\n      !constraintMatchesPrimaryKey(fetchOrPkConstraint, this.#primaryKey)\n    ) {\n      indexSort.push(...requestedSort);\n    }\n\n    const index = this.#getOrCreateIndex(indexSort);\n    const {data, comparator: compare} = index;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const indexComparator: Comparator = req.reverse\n      ? (r1, r2) => compare(r2, r1)\n      : compare;\n\n    const startAt = req.start?.row;\n\n    // If there is a constraint, we want to start our scan at the first row that\n    // matches the constraint. But because the next OrderPart can be `desc`,\n    // it's not true that {[constraintKey]: constraintValue} is the first\n    // matching row. Because in that case, the other fields will all be\n    // `undefined`, and in Zero `undefined` is always less than any other value.\n    // So if the second OrderPart is descending then `undefined` values will\n    // actually be the *last* row. We need a way to stay \"start at the first row\n    // with this constraint value\". RowBound with the corresponding compareBound\n    // comparator accomplishes this. The right thing is probably to teach the\n    // btree library to support this concept.\n    let scanStart: RowBound | undefined;\n\n    if (fetchOrPkConstraint) {\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(fetchOrPkConstraint, key)) {\n          scanStart[key] = fetchOrPkConstraint[key];\n        } else {\n          if (req.reverse) {\n            scanStart[key] = dir === 'asc' ? maxValue : minValue;\n          } else {\n            scanStart[key] = dir === 'asc' ? minValue : maxValue;\n          }\n        }\n      }\n    } else {\n      scanStart = startAt;\n    }\n\n    const rowsIterable = generateRows(data, scanStart, req.reverse);\n\n    // Fast path: no overlay to apply, no `start`, and no connection filters.\n    // This is the common shape for join child-lookups, plain scans, and source\n    // fetches that sit beneath a downstream `Filter` operator. In that case the\n    // whole generator stack (generateWithOverlay → generateWithStart →\n    // skipYields → generateWithConstraint) reduces to: walk rows from\n    // `scanStart`, wrap each as a Node, and stop once the constraint no longer\n    // matches (rows are sorted by the constraint key first, so matches are\n    // contiguous). Collapsing the five chained generators into one loop removes\n    // a large amount of per-row generator-resume overhead on the hottest path.\n    const overlayActive =\n      this.#overlay && conn.lastPushedEpoch >= this.#overlay.epoch;\n    if (!overlayActive && !req.start && !conn.filters && !req.filter) {\n      const {constraint} = req;\n      for (const row of rowsIterable) {\n        if (constraint && !constraintMatchesRow(constraint, row)) {\n          break;\n        }\n        yield {row, relationships: {}};\n      }\n      return;\n    }\n\n    const withOverlay = generateWithOverlay(\n      startAt,\n      pkConstraint ? once(rowsIterable) : rowsIterable,\n      // use `req.constraint` here and not `fetchOrPkConstraint` since `fetchOrPkConstraint` could be the\n      // primary key constraint. The primary key constraint comes from filters and is acting as a filter\n      // rather than as the fetch constraint.\n      req.constraint,\n      this.#overlay,\n      conn.lastPushedEpoch,\n      // Use indexComparator, generateWithOverlayInner has a subtle dependency\n      // on this.  Since generateWithConstraint is done after\n      // generateWithOverlay, the generator consumed by generateWithOverlayInner\n      // does not end when the constraint stops matching and so the final\n      // check to yield an add overlay if not yet yielded is not reached.\n      // However, using the indexComparator the add overlay will be less than\n      // the first row that does not match the constraint, and so any\n      // not yet yielded add overlay will be yielded when the first row\n      // not matching the constraint is reached.\n      indexComparator,\n      // `startAt` is `req.start.row`, a bound in the connection's sort order,\n      // so it must be compared in that order -- not `indexComparator`, which\n      // with a constraint leads with the constraint keys. The two agree only\n      // when the overlay row and `startAt` share those key values; they do not\n      // for `#fetchMulti`'s per-value sub-fetches, which pin one primary key\n      // while still carrying the caller's connection-sort `start`. Comparing\n      // there by the constraint key dropped the in-flight overlay and served\n      // pre-push data. Same distinction #4926 drew for `generateWithStart`.\n      connectionComparator,\n      mergedFilterPredicate,\n    );\n\n    const withConstraint = generateWithConstraint(\n      skipYields(\n        generateWithStart(withOverlay, req.start, connectionComparator),\n      ),\n      // we use `req.constraint` and not `fetchOrPkConstraint` here because we need to\n      // AND the constraint with what could have been the primary key constraint\n      req.constraint,\n    );\n\n    yield* mergedFilterPredicate\n      ? generateWithFilter(withConstraint, mergedFilterPredicate)\n      : withConstraint;\n  }\n\n  *#fetchMulti(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // Caller (`#fetch`) guards entry on `req.multiConstraints.some(mc =>\n    // mc.length > 0)`, so `multis` is guaranteed non-empty after the\n    // empty-entry filter. Per the MultiConstraint contract (operator.ts),\n    // entries are non-empty, share key shape, are unique, and are\n    // key-compatible with `req.constraint`.\n    const multis = must(req.multiConstraints).filter(mc => mc.length > 0);\n    const primary = multis[0];\n    const rest = multis.slice(1);\n    const baseConstraint = req.constraint;\n\n    // Drive sub-fetches off `primary`. Within each sub-fetch the source\n    // can use its index for `primary`; we then post-filter rows by\n    // checking they also match every entry in `rest`. Per the\n    // MultiConstraint contract (see operator.ts), entries are unique and\n    // key-compatible with `baseConstraint`, so we don't dedupe or check\n    // compatibility here.\n    const subStreams: Stream<Node | 'yield'>[] = primary.map(c => {\n      const merged: Constraint = baseConstraint ? {...baseConstraint, ...c} : c;\n      return this.#fetch(\n        {...req, constraint: merged, multiConstraints: undefined},\n        conn,\n      );\n    });\n    const merged = mergeSortedStreams(\n      subStreams,\n      req.reverse\n        ? (a, b) => conn.compareRows(b.row, a.row)\n        : (a, b) => conn.compareRows(a.row, b.row),\n    );\n\n    if (rest.length === 0) {\n      yield* merged;\n      return;\n    }\n\n    for (const node of merged) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      let matchesAll = true;\n      for (const mc of rest) {\n        let any = false;\n        for (const c of mc) {\n          if (constraintMatchesRow(c, node.row)) {\n            any = true;\n            break;\n          }\n        }\n        if (!any) {\n          matchesAll = false;\n          break;\n        }\n      }\n      if (matchesAll) yield node;\n    }\n  }\n\n  /**\n   * Pushes an add for each of `rows`.\n   *\n   * When the source holds no rows and nothing is connected to it (loading the\n   * replica at startup) there is no output to notify and no secondary index to\n   * keep in step, so the primary index is built bottom-up in O(N) (plus a sort\n   * when `rows` are not already in primary key order) rather than doing one\n   * tree insert, and one trip through the push machinery, per row.\n   *\n   * `rows` may be sorted in place. Rows must have distinct primary keys.\n   */\n  pushAdds(rows: Row[]): void {\n    const index = this.#getPrimaryIndex();\n    const canBulkLoad =\n      this.#connections.length === 0 &&\n      this.#indexes.size === 1 &&\n      index.data.size === 0;\n    if (!canBulkLoad) {\n      for (const row of rows) {\n        consume(this.push(makeSourceChangeAdd(row)));\n      }\n      return;\n    }\n    const {comparator} = index;\n    // The check is not redundant with the sort. V8's TimSort is O(N) on sorted\n    // input but Hermes' sort is not adaptive: always sorting doubled the load\n    // time of an already ordered 180k row replica on Android (343ms -> 672ms).\n    if (!isAscending(rows, comparator)) {\n      rows.sort(comparator);\n    }\n    index.data = BTreeSet.fromSorted(comparator, rows);\n  }\n\n  *push(change: SourceChange): Stream<'yield'> {\n    for (const result of this.genPush(change)) {\n      if (result === 'yield') {\n        yield result;\n      }\n    }\n  }\n\n  genPush(change: SourceChange) {\n    const primaryIndex = this.#getPrimaryIndex();\n    const {data} = primaryIndex;\n    const exists = (row: Row) => data.has(row);\n    const setOverlay = (o: Overlay | undefined) => (this.#overlay = o);\n    const writeChange = (c: SourceChange) => this.#writeChange(c);\n    return genPushAndWriteWithSplitEdit(\n      this.#connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      () => ++this.#pushEpoch,\n    );\n  }\n\n  #writeChange(change: SourceChange) {\n    for (const {data} of this.#indexes.values()) {\n      switch (change[SourceChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          const added = data.add(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            added,\n            'MemorySource: add must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.REMOVE: {\n          const removed = data.delete(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: remove must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.EDIT: {\n          // TODO: We could see if the PK (form the index tree's perspective)\n          // changed and if not we could use set.\n          // We cannot just do `set` with the new value since the `oldRow` might\n          // not map to the same entry as the new `row` in the index btree.\n          const removed = data.delete(change[SourceChangeIndex.OLD_ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: edit remove must succeed since row existence was already checked',\n          );\n          data.add(change[SourceChangeIndex.ROW]);\n          break;\n        }\n        default:\n          unreachable(change);\n      }\n    }\n  }\n}\n\nfunction mergePredicates(\n  connPredicate: ((row: Row) => boolean) | undefined,\n  reqFilter: NoSubqueryCondition | undefined,\n): ((row: Row) => boolean) | undefined {\n  if (!reqFilter) {\n    return connPredicate;\n  }\n  const reqPredicate = createPredicate(reqFilter);\n  if (!connPredicate) {\n    return reqPredicate;\n  }\n  return row => connPredicate(row) && reqPredicate(row);\n}\n\nfunction* generateWithConstraint(\n  it: Stream<Node>,\n  constraint: Constraint | undefined,\n) {\n  for (const node of it) {\n    if (constraint && !constraintMatchesRow(constraint, node.row)) {\n      break;\n    }\n    yield node;\n  }\n}\n\nfunction* generateWithFilter(it: Stream<Node>, filter: (row: Row) => boolean) {\n  for (const node of it) {\n    if (filter(node.row)) {\n      yield node;\n    }\n  }\n}\n\nexport function* genPushAndWriteWithSplitEdit(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: ((row: Row) => boolean) | undefined,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  getNextEpoch: () => number,\n) {\n  let shouldSplitEdit = false;\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT) {\n    for (const {splitEditKeys} of connections) {\n      if (splitEditKeys) {\n        for (const key of splitEditKeys) {\n          if (\n            !valuesEqual(\n              change[SourceChangeIndex.ROW][key],\n              change[SourceChangeIndex.OLD_ROW][key],\n            )\n          ) {\n            shouldSplitEdit = true;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT && shouldSplitEdit) {\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeRemove(change[SourceChangeIndex.OLD_ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeAdd(change[SourceChangeIndex.ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  } else {\n    yield* genPushAndWrite(\n      connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  }\n}\n\nfunction* genPushAndWrite(\n  connections: readonly Connection[],\n  change: SourceChangeAdd | SourceChangeRemove | SourceChangeEdit,\n  exists: ((row: Row) => boolean) | undefined,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  pushEpoch: number,\n) {\n  for (const x of genPush(connections, change, exists, setOverlay, pushEpoch)) {\n    yield x;\n  }\n  writeChange(change);\n}\n\nfunction* genPush(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: ((row: Row) => boolean) | undefined,\n  setOverlay: (o: Overlay | undefined) => void,\n  pushEpoch: number,\n) {\n  if (exists) {\n    switch (change[SourceChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        assert(\n          !exists(change[SourceChangeIndex.ROW]),\n          () => `Row already exists ${stringify(change)}`,\n        );\n        break;\n      case ChangeType.REMOVE:\n        assert(\n          exists(change[SourceChangeIndex.ROW]),\n          () => `Row not found ${stringify(change)}`,\n        );\n        break;\n      case ChangeType.EDIT:\n        assert(\n          exists(change[SourceChangeIndex.OLD_ROW]),\n          () => `Row not found ${stringify(change)}`,\n        );\n        break;\n      default:\n        unreachable(change);\n    }\n  }\n\n  setOverlay({epoch: pushEpoch, change});\n  try {\n    for (const conn of connections) {\n      const {output, filters, input} = conn;\n      if (output) {\n        conn.lastPushedEpoch = pushEpoch;\n        const outputChange: Change =\n          change[SourceChangeIndex.TYPE] === ChangeType.EDIT\n            ? makeEditChange(\n                {row: change[SourceChangeIndex.ROW], relationships: {}},\n                {row: change[SourceChangeIndex.OLD_ROW], relationships: {}},\n              )\n            : change[SourceChangeIndex.TYPE] === ChangeType.ADD\n              ? makeAddChange({\n                  row: change[SourceChangeIndex.ROW],\n                  relationships: {},\n                })\n              : makeRemoveChange({\n                  row: change[SourceChangeIndex.ROW],\n                  relationships: {},\n                });\n        yield* filterPush(outputChange, output, input, filters?.predicate);\n        yield undefined;\n      }\n    }\n\n    for (const conn of connections) {\n      const {output, input} = conn;\n      if (output?.reconcile) {\n        yield* output.reconcile(input);\n        yield undefined;\n      }\n    }\n  } finally {\n    setOverlay(undefined);\n  }\n}\n\nexport function* generateWithStart(\n  nodes: Iterable<Node | 'yield'>,\n  start: Start | undefined,\n  compare: (r1: Row, r2: Row) => number,\n): Stream<Node | 'yield'> {\n  if (!start) {\n    yield* nodes;\n    return;\n  }\n  let started = false;\n  for (const node of nodes) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!started) {\n      if (start.basis === 'at') {\n        if (compare(node.row, start.row) >= 0) {\n          started = true;\n        }\n      } else if (start.basis === 'after') {\n        if (compare(node.row, start.row) > 0) {\n          started = true;\n        }\n      }\n    }\n    if (started) {\n      yield node;\n    }\n  }\n}\n\n/**\n * Takes an iterator and overlay.\n * Splices the overlay into the iterator at the correct position.\n *\n * @param startAt - if there is a lower bound to the stream. If the lower bound of the stream\n * is above the overlay, the overlay will be skipped.\n * @param rows - the stream into which the overlay should be spliced\n * @param constraint - constraint that was applied to the rowIterator and should\n * also be applied to the overlay.\n * @param overlay - the overlay values to splice in\n * @param compare - the comparator to use to find the position for the overlay.\n * Must order rows the same way `rows` is ordered. For `MemorySource` that is\n * *index* order, which leads with the constraint keys.\n * @param startAtCompare - the comparator for `startAt`, which is a bound in the\n * *connection's* sort order. Only the same as `compare` when the stream's order\n * happens to be the connection's -- true for `TableSource` (SQL does the\n * ordering) but not for a constrained `MemorySource` fetch. Conflating the two\n * is what #4926 fixed for `generateWithStart`; this parameter is the same\n * distinction for the overlay's own `startAt` pruning.\n */\nexport function generateWithOverlay(\n  startAt: Row | undefined,\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  compare: Comparator,\n  startAtCompare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[],\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  const overlays = computeOverlays(\n    startAt,\n    constraint,\n    overlayToApply,\n    startAtCompare,\n    filterPredicate,\n    multiConstraints,\n  );\n  return generateWithOverlayInner(rows, overlays, compare);\n}\n\nfunction computeOverlays(\n  startAt: Row | undefined,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  // Only ever used for `overlaysForStartAt`, so this is the *connection*-order\n  // comparator, not the one used to splice the overlay into the row stream.\n  startAtCompare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[],\n): Overlays {\n  let overlays: Overlays = {\n    add: undefined,\n    remove: undefined,\n  };\n  switch (overlay?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlay.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: overlay.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n\n  if (startAt) {\n    overlays = overlaysForStartAt(overlays, startAt, startAtCompare);\n  }\n\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n\n  return overlays;\n}\n\nfunction applyMultiConstraintsToOverlays(\n  overlays: Overlays,\n  multiConstraints: readonly MultiConstraint[] | undefined,\n): Overlays {\n  if (!multiConstraints) return overlays;\n  for (const mc of multiConstraints) {\n    if (mc.length > 0) {\n      overlays = overlaysForMultiConstraint(overlays, mc);\n    }\n  }\n  return overlays;\n}\n\nexport {overlaysForMultiConstraint as overlaysForMultiConstraintForTest};\n\nfunction overlaysForMultiConstraint(\n  {add, remove}: Overlays,\n  multiConstraint: MultiConstraint,\n): Overlays {\n  const matchesAny = (row: Row | undefined) => {\n    if (row === undefined) return false;\n    for (const c of multiConstraint) {\n      if (constraintMatchesRow(c, row)) return true;\n    }\n    return false;\n  };\n  return {\n    add: matchesAny(add) ? add : undefined,\n    remove: matchesAny(remove) ? remove : undefined,\n  };\n}\n\nexport {overlaysForStartAt as overlaysForStartAtForTest};\n\nfunction overlaysForStartAt(\n  {add, remove}: Overlays,\n  startAt: Row,\n  compare: Comparator,\n): Overlays {\n  const undefinedIfBeforeStartAt = (row: Row | undefined) =>\n    row === undefined || compare(row, startAt) < 0 ? undefined : row;\n  return {\n    add: undefinedIfBeforeStartAt(add),\n    remove: undefinedIfBeforeStartAt(remove),\n  };\n}\n\nexport {overlaysForConstraint as overlaysForConstraintForTest};\n\nfunction overlaysForConstraint(\n  {add, remove}: Overlays,\n  constraint: Constraint,\n): Overlays {\n  const undefinedIfDoesntMatchConstraint = (row: Row | undefined) =>\n    row === undefined || !constraintMatchesRow(constraint, row)\n      ? undefined\n      : row;\n\n  return {\n    add: undefinedIfDoesntMatchConstraint(add),\n    remove: undefinedIfDoesntMatchConstraint(remove),\n  };\n}\n\nfunction overlaysForFilterPredicate(\n  {add, remove}: Overlays,\n  filterPredicate: (row: Row) => boolean | undefined,\n): Overlays {\n  const undefinedIfDoesntMatchFilter = (row: Row | undefined) =>\n    row === undefined || !filterPredicate(row) ? undefined : row;\n\n  return {\n    add: undefinedIfDoesntMatchFilter(add),\n    remove: undefinedIfDoesntMatchFilter(remove),\n  };\n}\n\nexport function* generateWithOverlayInner(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  compare: (r1: Row, r2: Row) => number,\n) {\n  let addOverlayYielded = false;\n  let removeOverlaySkipped = false;\n  for (const row of rowIterator) {\n    if (!addOverlayYielded && overlays.add) {\n      const cmp = compare(overlays.add, row);\n      if (cmp < 0) {\n        addOverlayYielded = true;\n        yield {row: overlays.add, relationships: {}};\n      }\n    }\n\n    if (!removeOverlaySkipped && overlays.remove) {\n      const cmp = compare(overlays.remove, row);\n      if (cmp === 0) {\n        removeOverlaySkipped = true;\n        continue;\n      }\n    }\n    yield {row, relationships: {}};\n  }\n\n  if (!addOverlayYielded && overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n}\n\n/**\n * Like {@link generateWithOverlay} but for unordered streams.\n * No `startAt` or comparator needed. Injects remove/old-edit rows eagerly\n * at the start, and suppresses add/new-edit rows inline by PK match.\n */\nexport function generateWithOverlayUnordered(\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  primaryKey: PrimaryKey,\n  filterPredicate?: (row: Row) => boolean,\n  multiConstraints?: readonly MultiConstraint[],\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  let overlays: Overlays = {add: undefined, remove: undefined};\n  switch (overlayToApply?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlayToApply.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: overlayToApply.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n  return generateWithOverlayInnerUnordered(rows, overlays, primaryKey);\n}\n\nexport function* generateWithOverlayInnerUnordered(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  primaryKey: PrimaryKey,\n) {\n  // Eager inject: yield the add overlay at the start (row not yet in storage)\n  if (overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n  // Stream with inline suppress: skip the remove overlay (row still in storage)\n  let removeSkipped = false;\n  for (const row of rowIterator) {\n    if (\n      !removeSkipped &&\n      overlays.remove &&\n      rowMatchesPK(overlays.remove, row, primaryKey)\n    ) {\n      removeSkipped = true;\n      continue;\n    }\n    yield {row, relationships: {}};\n  }\n}\n\nfunction rowMatchesPK(a: Row, b: Row, primaryKey: PrimaryKey): boolean {\n  for (const key of primaryKey) {\n    if (!valuesEqual(a[key], b[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * A location to begin scanning an index from. Can either be a specific value\n * or the min or max possible value for the type. This is used to start a scan\n * at the beginning of the rows matching a constraint.\n */\nexport type Bound = Value | MinValue | MaxValue;\nexport type RowBound = Record<string, Bound>;\nexport const minValue = Symbol('min-value');\ntype MinValue = typeof minValue;\nexport const maxValue = Symbol('max-value');\ntype MaxValue = typeof maxValue;\n\nfunction isAscending(rows: Row[], comparator: Comparator): boolean {\n  for (let i = 1; i < rows.length; i++) {\n    if (comparator(rows[i - 1], rows[i]) > 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makeBoundComparator(sort: Ordering): Comparator {\n  // Pre-extract the first two keys/directions to avoid per-call array access.\n  // All paths share one function literal (single SFI) so the BTree comparator call site\n  // stays monomorphic across indexes with different sort orderings, preventing V8 IC deopt.\n  // Even a 2-SFI split (e.g. separate len=1 path) creates a polymorphic IC that\n  // measurably regresses performance, so we keep a single return body.\n  const len = sort.length;\n  const k0 = sort[0][0];\n  const a0 = sort[0][1] === 'asc';\n  const k1 = len > 1 ? sort[1][0] : '';\n  const a1 = len > 1 ? sort[1][1] === 'asc' : true;\n\n  return (a: RowBound, b: RowBound) => {\n    const c0 = a0 ? compareBounds(a[k0], b[k0]) : compareBounds(b[k0], a[k0]);\n    if (len === 1 || c0 !== 0) return c0;\n    const c1 = a1 ? compareBounds(a[k1], b[k1]) : compareBounds(b[k1], a[k1]);\n    if (len === 2 || c1 !== 0) return c1;\n    // Hot! Do not use destructuring\n    for (let i = 2; i < len; i++) {\n      const cmp = compareBounds(a[sort[i][0]], b[sort[i][0]]);\n      if (cmp !== 0) return sort[i][1] === 'asc' ? cmp : -cmp;\n    }\n    return 0;\n  };\n}\n\nfunction compareBounds(a: Bound, b: Bound): number {\n  if (a === b) {\n    return 0;\n  }\n  // Use typeof to guard the Symbol sentinel checks first. This gives V8 a\n  // clear type discriminant so the common non-symbol path compiles as a\n  // specialised numeric/string fast-path without a Smi deopt when the\n  // minValue/maxValue sentinel symbols appear.\n  if (typeof a === 'symbol') {\n    return a === minValue ? -1 : 1;\n  }\n  if (typeof b === 'symbol') {\n    return b === minValue ? 1 : -1;\n  }\n  return compareValues(a, b);\n}\n\nexport function generateRows(\n  data: BTreeSet<Row>,\n  scanStart: RowBound | undefined,\n  reverse: boolean | undefined,\n) {\n  return reverse\n    ? data.valuesFromReversed(scanStart as Row | undefined)\n    : data.valuesFrom(scanStart as Row | undefined);\n}\n\nexport function stringify(change: SourceChange) {\n  return JSON.stringify(change, (_, v) =>\n    typeof v === 'bigint' ? v.toString() : v,\n  );\n}\n\n/**\n * N-way merge of pre-sorted Node streams. Each input stream must yield\n * Nodes in `compare` order (and may interleave 'yield' values, which are\n * forwarded as-is). The merged stream yields Nodes in `compare` order.\n *\n * Implemented as a binary min-heap keyed by `compare(entry.row, ...)`, so\n * each emit costs O(log K) (K = number of streams) rather than the O(K)\n * a linear-scan-of-heads merge would. Matters when FlippedJoin chunks a\n * large `multiConstraints` IN-list into hundreds of sub-fetches.\n *\n * If the merged stream is closed early (e.g. downstream `Take` `break`s\n * after hitting its limit, prompting JS to call `.return()` on this\n * generator), the `finally` block propagates `.return()` to each\n * non-exhausted sub-iterator so the underlying sources (SQLite cursors,\n * etc.) can run their cleanup. Without this, mid-merge early-termination\n * leaves cursors open, causing later writes on the same connection to\n * fail with \"database connection is busy executing a query\".\n */\nexport function* mergeSortedStreams(\n  streams: readonly Stream<Node | 'yield'>[],\n  compare: (a: Node, b: Node) => number,\n): Stream<Node | 'yield'> {\n  const iterators: Iterator<Node | 'yield'>[] = streams.map(s =>\n    s[Symbol.iterator](),\n  );\n  // True while iterators[i] hasn't yet returned `done`. The finally\n  // block uses this to skip already-exhausted streams when propagating\n  // `.return()`.\n  const active = Array.from({length: iterators.length}).fill(true) as boolean[];\n\n  // Min-heap of entries; `idx` tells us which stream to refill from\n  // after the entry's row is emitted.\n  type Entry = {row: Node; idx: number};\n  const heap: Entry[] = [];\n\n  const siftUp = (start: number) => {\n    let i = start;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (compare(heap[i].row, heap[p].row) >= 0) return;\n      const t = heap[i];\n      heap[i] = heap[p];\n      heap[p] = t;\n      i = p;\n    }\n  };\n\n  const siftDown = (start: number) => {\n    let i = start;\n    const n = heap.length;\n    while (true) {\n      const l = (i << 1) + 1;\n      const r = l + 1;\n      let smallest = i;\n      if (l < n && compare(heap[l].row, heap[smallest].row) < 0) smallest = l;\n      if (r < n && compare(heap[r].row, heap[smallest].row) < 0) smallest = r;\n      if (smallest === i) return;\n      const t = heap[i];\n      heap[i] = heap[smallest];\n      heap[smallest] = t;\n      i = smallest;\n    }\n  };\n\n  // Pull the next Node from iterator `idx`, forwarding any 'yield's.\n  // Returns the Node, or `undefined` once the stream is exhausted.\n  const pullNext = function* (\n    idx: number,\n  ): IterableIterator<'yield', Node | undefined, undefined> {\n    while (true) {\n      const r = iterators[idx].next();\n      if (r.done) {\n        active[idx] = false;\n        return undefined;\n      }\n      if (r.value === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      return r.value;\n    }\n  };\n\n  try {\n    // Prime: push the first row of each non-empty stream onto the heap.\n    for (let i = 0; i < iterators.length; i++) {\n      const row = yield* pullNext(i);\n      if (row !== undefined) {\n        heap.push({row, idx: i});\n        siftUp(heap.length - 1);\n      }\n    }\n\n    while (heap.length > 0) {\n      // Root is the global min across all active streams.\n      const top = heap[0];\n      yield top.row;\n      const next = yield* pullNext(top.idx);\n      if (next !== undefined) {\n        // Refill root in place (top === heap[0]) and sift down. The\n        // already-yielded `top.row` value is captured by the yield, so\n        // mutating it here doesn't affect what was emitted.\n        top.row = next;\n        siftDown(0);\n      } else {\n        // Stream exhausted. Move tail to root and shrink. Pop returns\n        // the last entry; if the heap had only one entry it was the\n        // root we just yielded, so we just leave the heap empty.\n        const last = must(heap.pop());\n        if (heap.length > 0) {\n          heap[0] = last;\n          siftDown(0);\n        }\n      }\n    }\n  } finally {\n    // Close any iterators that aren't already exhausted so their\n    // `finally` blocks (which release cursors / cached statements) run.\n    for (let i = 0; i < iterators.length; i++) {\n      if (active[i]) {\n        iterators[i].return?.();\n      }\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"memory-source.js","names":[],"sources":["../../../../../zql/src/ivm/memory-source.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {BTreeSet} from '../../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport {once, toSorted} from '../../../shared/src/iterables.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  Condition,\n  Ordering,\n  OrderPart,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-types/src/schema-value.ts';\nimport type {DebugDelegate} from '../builder/debug-delegate.ts';\nimport {\n  createPredicate,\n  transformFilters,\n  type NoSubqueryCondition,\n} from '../builder/filter.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {makeAddChange, makeEditChange, makeRemoveChange} from './change.ts';\nimport {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  primaryKeyConstraintFromFilters,\n  type Constraint,\n} from './constraint.ts';\nimport {\n  compareValues,\n  makeComparator,\n  valuesEqual,\n  type Comparator,\n  type Node,\n} from './data.ts';\nimport {filterPush} from './filter-push.ts';\nimport {\n  skipYields,\n  type FetchRequest,\n  type Input,\n  type MultiConstraint,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {SourceChangeIndex} from './source-change-index.ts';\nimport type {\n  Source,\n  SourceChange,\n  SourceChangeAdd,\n  SourceChangeEdit,\n  SourceChangeRemove,\n  SourceInput,\n} from './source.ts';\nimport {makeSourceChangeAdd, makeSourceChangeRemove} from './source.ts';\nimport {consume, type Stream} from './stream.ts';\n\nexport type Overlay = {\n  epoch: number;\n  change: SourceChange;\n};\n\nexport type Overlays = {\n  add: Row | undefined;\n  remove: Row | undefined;\n};\n\ntype Index = {\n  comparator: Comparator;\n  data: BTreeSet<Row>;\n};\n\nexport type Connection = {\n  input: Input;\n  output: Output | undefined;\n  sort?: Ordering | undefined;\n  splitEditKeys: Set<string> | undefined;\n  compareRows: Comparator;\n  filters:\n    | {\n        condition: NoSubqueryCondition;\n        predicate: (row: Row) => boolean;\n      }\n    | undefined;\n  readonly debug?: DebugDelegate | undefined;\n  lastPushedEpoch: number;\n};\n\n/**\n * A `MemorySource` is a source that provides data to the pipeline from an\n * in-memory data source.\n *\n * This data is kept in sorted order as downstream pipelines will always expect\n * the data they receive from `pull` to be in sorted order.\n */\nexport class MemorySource implements Source {\n  readonly #tableName: string;\n  readonly #columns: Record<string, SchemaValue>;\n  readonly #primaryKey: PrimaryKey;\n  readonly #primaryIndexSort: Ordering;\n  readonly #indexes: Map<string, Index> = new Map();\n  readonly #connections: Connection[] = [];\n\n  #overlay: Overlay | undefined;\n  #pushEpoch = 0;\n\n  constructor(\n    tableName: string,\n    columns: Record<string, SchemaValue>,\n    primaryKey: PrimaryKey,\n    primaryIndexData?: BTreeSet<Row>,\n  ) {\n    this.#tableName = tableName;\n    this.#columns = columns;\n    this.#primaryKey = primaryKey;\n    this.#primaryIndexSort = primaryKey.map(k => [k, 'asc']);\n    const comparator = makeBoundComparator(this.#primaryIndexSort);\n    this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {\n      comparator,\n      data: primaryIndexData ?? new BTreeSet<Row>(comparator),\n    });\n  }\n\n  get tableSchema() {\n    return {\n      name: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n    };\n  }\n\n  fork() {\n    const primaryIndex = this.#getPrimaryIndex();\n    return new MemorySource(\n      this.#tableName,\n      this.#columns,\n      this.#primaryKey,\n      primaryIndex.data.clone(),\n    );\n  }\n\n  get data(): BTreeSet<Row> {\n    return this.#getPrimaryIndex().data;\n  }\n\n  #getSchema(connection: Connection, unordered: boolean): SourceSchema {\n    return {\n      tableName: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n      sort: unordered ? undefined : connection.sort,\n      system: 'client',\n      relationships: {},\n      isHidden: false,\n      compareRows: connection.compareRows,\n    };\n  }\n\n  connect(\n    sort: Ordering | undefined,\n    filters?: Condition,\n    splitEditKeys?: Set<string>,\n  ): SourceInput {\n    const transformedFilters = transformFilters(filters);\n    const unordered = sort === undefined;\n    const internalSort = sort ?? this.#primaryIndexSort;\n\n    const input: SourceInput = {\n      getSchema: () => schema,\n      fetch: req => this.#fetch(req, connection),\n      setOutput: output => {\n        connection.output = output;\n      },\n      destroy: () => {\n        this.#disconnect(input);\n      },\n      fullyAppliedFilters: !transformedFilters.conditionsRemoved,\n    };\n\n    const connection: Connection = {\n      input,\n      output: undefined,\n      sort: internalSort,\n      splitEditKeys,\n      compareRows: makeComparator(internalSort),\n      filters: transformedFilters.filters\n        ? {\n            condition: transformedFilters.filters,\n            predicate: createPredicate(transformedFilters.filters),\n          }\n        : undefined,\n      lastPushedEpoch: 0,\n    };\n    const schema = this.#getSchema(connection, unordered);\n    if (!unordered) {\n      assertOrderingIncludesPK(internalSort, this.#primaryKey);\n    }\n    this.#connections.push(connection);\n    return input;\n  }\n\n  #disconnect(input: Input): void {\n    const idx = this.#connections.findIndex(c => c.input === input);\n    assert(idx !== -1, 'Connection not found');\n    this.#connections.splice(idx, 1);\n\n    // Indexes deliberately hold no reference back to the connections that use\n    // them. They used to, to support deleting an index once its last user went\n    // away. That deletion is gone (see below) but the `usedBy` set outlived it,\n    // so an index kept every `Connection` — and through its `input` and\n    // `output`, the whole torn-down pipeline — reachable for as long as the\n    // source lived.\n    //\n    // TODO: We used to delete unused indexes here. But in common cases like\n    // navigating into issue detail pages it caused a ton of constantly\n    // building and destroying indexes.\n    //\n    // Perhaps some intelligent LRU or something is needed here but for now,\n    // the opposite extreme of keeping all indexes for the lifetime of the\n    // page seems better.\n  }\n\n  #getPrimaryIndex(): Index {\n    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));\n    assert(index, 'Primary index not found');\n    return index;\n  }\n\n  #getOrCreateIndex(sort: Ordering): Index {\n    const key = JSON.stringify(sort);\n    const index = this.#indexes.get(key);\n    // Future optimization could use existing index if it's the same just sorted\n    // in reverse of needed.\n    if (index) {\n      return index;\n    }\n\n    const comparator = makeBoundComparator(sort);\n\n    // When creating these synchronously becomes a problem, a few options:\n    // 1. Allow users to specify needed indexes up front\n    // 2. Create indexes in a different thread asynchronously (this would require\n    // modifying the BTree to be able to be passed over structured-clone, or using\n    // a different library.)\n    // 3. We could even theoretically do (2) on multiple threads and then merge the\n    // results!\n    const rows = toSorted(this.#getPrimaryIndex().data, comparator);\n    const data = BTreeSet.fromSorted(comparator, rows);\n\n    const newIndex = {comparator, data};\n    this.#indexes.set(key, newIndex);\n    return newIndex;\n  }\n\n  // For unit testing that we correctly clean up indexes.\n  getIndexKeys(): string[] {\n    return [...this.#indexes.keys()];\n  }\n\n  *#fetch(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // multiConstraints is handled by driving sub-fetches off the first\n    // entry's values and post-filtering matches against any remaining\n    // entries. TableSource implements multi-IN natively via SQL `AND` of\n    // `IN` clauses; the in-memory path is correct but not specially\n    // optimized — it pays the index-seek cost per primary value, then\n    // walks each result against the rest.\n    if (\n      req.multiConstraints &&\n      req.multiConstraints.some(mc => mc.length > 0)\n    ) {\n      yield* this.#fetchMulti(req, conn);\n      return;\n    }\n    const requestedSort = must(conn.sort);\n    const {compareRows} = conn;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const connectionComparator: Comparator = req.reverse\n      ? (r1, r2) => compareRows(r2, r1)\n      : compareRows;\n\n    const reqFilter = req.filter;\n    const connFilterCondition = conn.filters?.condition;\n    const mergedFilterCondition: NoSubqueryCondition | undefined =\n      connFilterCondition && reqFilter\n        ? {type: 'and', conditions: [connFilterCondition, reqFilter]}\n        : (connFilterCondition ?? reqFilter);\n    const mergedFilterPredicate = mergePredicates(\n      conn.filters?.predicate,\n      reqFilter,\n    );\n\n    const pkConstraint = primaryKeyConstraintFromFilters(\n      mergedFilterCondition,\n      this.#primaryKey,\n    );\n    // The primary key constraint will be more limiting than the constraint\n    // so swap out to that if it exists.\n    const fetchOrPkConstraint = pkConstraint ?? req.constraint;\n\n    // If there is a constraint, we need an index sorted by it first.\n    const indexSort: OrderPart[] = [];\n    if (fetchOrPkConstraint) {\n      for (const key of Object.keys(fetchOrPkConstraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n\n    // For the special case of constraining by PK, we don't need to worry about\n    // any requested sort since there can only be one result. Otherwise we also\n    // need the index sorted by the requested sort.\n    if (\n      this.#primaryKey.length > 1 ||\n      !fetchOrPkConstraint ||\n      !constraintMatchesPrimaryKey(fetchOrPkConstraint, this.#primaryKey)\n    ) {\n      indexSort.push(...requestedSort);\n    }\n\n    const index = this.#getOrCreateIndex(indexSort);\n    const {data, comparator: compare} = index;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const indexComparator: Comparator = req.reverse\n      ? (r1, r2) => compare(r2, r1)\n      : compare;\n\n    const startAt = req.start?.row;\n\n    // If there is a constraint, we want to start our scan at the first row that\n    // matches the constraint. But because the next OrderPart can be `desc`,\n    // it's not true that {[constraintKey]: constraintValue} is the first\n    // matching row. Because in that case, the other fields will all be\n    // `undefined`, and in Zero `undefined` is always less than any other value.\n    // So if the second OrderPart is descending then `undefined` values will\n    // actually be the *last* row. We need a way to stay \"start at the first row\n    // with this constraint value\". RowBound with the corresponding compareBound\n    // comparator accomplishes this. The right thing is probably to teach the\n    // btree library to support this concept.\n    let scanStart: RowBound | undefined;\n\n    if (fetchOrPkConstraint) {\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(fetchOrPkConstraint, key)) {\n          scanStart[key] = fetchOrPkConstraint[key];\n        } else {\n          if (req.reverse) {\n            scanStart[key] = dir === 'asc' ? maxValue : minValue;\n          } else {\n            scanStart[key] = dir === 'asc' ? minValue : maxValue;\n          }\n        }\n      }\n    } else {\n      scanStart = startAt;\n    }\n\n    const rowsIterable = generateRows(data, scanStart, req.reverse);\n\n    // Fast path: no overlay to apply, no `start`, and no connection filters.\n    // This is the common shape for join child-lookups, plain scans, and source\n    // fetches that sit beneath a downstream `Filter` operator. In that case the\n    // whole generator stack (generateWithOverlay → generateWithStart →\n    // skipYields → generateWithConstraint) reduces to: walk rows from\n    // `scanStart`, wrap each as a Node, and stop once the constraint no longer\n    // matches (rows are sorted by the constraint key first, so matches are\n    // contiguous). Collapsing the five chained generators into one loop removes\n    // a large amount of per-row generator-resume overhead on the hottest path.\n    const overlayActive =\n      this.#overlay && conn.lastPushedEpoch >= this.#overlay.epoch;\n    if (!overlayActive && !req.start && !conn.filters && !req.filter) {\n      const {constraint} = req;\n      for (const row of rowsIterable) {\n        if (constraint && !constraintMatchesRow(constraint, row)) {\n          break;\n        }\n        yield {row, relationships: {}};\n      }\n      return;\n    }\n\n    const withOverlay = generateWithOverlay(\n      startAt,\n      pkConstraint ? once(rowsIterable) : rowsIterable,\n      // use `req.constraint` here and not `fetchOrPkConstraint` since `fetchOrPkConstraint` could be the\n      // primary key constraint. The primary key constraint comes from filters and is acting as a filter\n      // rather than as the fetch constraint.\n      req.constraint,\n      this.#overlay,\n      conn.lastPushedEpoch,\n      // Use indexComparator, generateWithOverlayInner has a subtle dependency\n      // on this.  Since generateWithConstraint is done after\n      // generateWithOverlay, the generator consumed by generateWithOverlayInner\n      // does not end when the constraint stops matching and so the final\n      // check to yield an add overlay if not yet yielded is not reached.\n      // However, using the indexComparator the add overlay will be less than\n      // the first row that does not match the constraint, and so any\n      // not yet yielded add overlay will be yielded when the first row\n      // not matching the constraint is reached.\n      indexComparator,\n      // `startAt` is `req.start.row`, a bound in the connection's sort order,\n      // so it must be compared in that order -- not `indexComparator`, which\n      // with a constraint leads with the constraint keys. The two agree only\n      // when the overlay row and `startAt` share those key values; they do not\n      // for `#fetchMulti`'s per-value sub-fetches, which pin one primary key\n      // while still carrying the caller's connection-sort `start`. Comparing\n      // there by the constraint key dropped the in-flight overlay and served\n      // pre-push data. Same distinction #4926 drew for `generateWithStart`.\n      connectionComparator,\n      mergedFilterPredicate,\n    );\n\n    const withConstraint = generateWithConstraint(\n      skipYields(\n        generateWithStart(withOverlay, req.start, connectionComparator),\n      ),\n      // we use `req.constraint` and not `fetchOrPkConstraint` here because we need to\n      // AND the constraint with what could have been the primary key constraint\n      req.constraint,\n    );\n\n    yield* mergedFilterPredicate\n      ? generateWithFilter(withConstraint, mergedFilterPredicate)\n      : withConstraint;\n  }\n\n  *#fetchMulti(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // Caller (`#fetch`) guards entry on `req.multiConstraints.some(mc =>\n    // mc.length > 0)`, so `multis` is guaranteed non-empty after the\n    // empty-entry filter. Per the MultiConstraint contract (operator.ts),\n    // entries are non-empty, share key shape, are unique, and are\n    // key-compatible with `req.constraint`.\n    const multis = must(req.multiConstraints).filter(mc => mc.length > 0);\n    const primary = multis[0];\n    const rest = multis.slice(1);\n    const baseConstraint = req.constraint;\n\n    // Drive sub-fetches off `primary`. Within each sub-fetch the source\n    // can use its index for `primary`; we then post-filter rows by\n    // checking they also match every entry in `rest`. Per the\n    // MultiConstraint contract (see operator.ts), entries are unique and\n    // key-compatible with `baseConstraint`, so we don't dedupe or check\n    // compatibility here.\n    const subStreams: Stream<Node | 'yield'>[] = primary.map(c => {\n      const merged: Constraint = baseConstraint ? {...baseConstraint, ...c} : c;\n      return this.#fetch(\n        {...req, constraint: merged, multiConstraints: undefined},\n        conn,\n      );\n    });\n    const merged = mergeSortedStreams(\n      subStreams,\n      req.reverse\n        ? (a, b) => conn.compareRows(b.row, a.row)\n        : (a, b) => conn.compareRows(a.row, b.row),\n    );\n\n    if (rest.length === 0) {\n      yield* merged;\n      return;\n    }\n\n    for (const node of merged) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      let matchesAll = true;\n      for (const mc of rest) {\n        let any = false;\n        for (const c of mc) {\n          if (constraintMatchesRow(c, node.row)) {\n            any = true;\n            break;\n          }\n        }\n        if (!any) {\n          matchesAll = false;\n          break;\n        }\n      }\n      if (matchesAll) yield node;\n    }\n  }\n\n  /**\n   * Pushes an add for each of `rows`.\n   *\n   * When the source holds no rows and nothing is connected to it (loading the\n   * replica at startup) there is no output to notify and no secondary index to\n   * keep in step, so the primary index is built bottom-up in O(N) (plus a sort\n   * when `rows` are not already in primary key order) rather than doing one\n   * tree insert, and one trip through the push machinery, per row.\n   *\n   * `rows` may be sorted in place. Rows must have distinct primary keys.\n   */\n  pushAdds(rows: Row[]): void {\n    const index = this.#getPrimaryIndex();\n    const canBulkLoad =\n      this.#connections.length === 0 &&\n      this.#indexes.size === 1 &&\n      index.data.size === 0;\n    if (!canBulkLoad) {\n      for (const row of rows) {\n        consume(this.push(makeSourceChangeAdd(row)));\n      }\n      return;\n    }\n    const {comparator} = index;\n    // The check is not redundant with the sort. V8's TimSort is O(N) on sorted\n    // input but Hermes' sort is not adaptive: always sorting doubled the load\n    // time of an already ordered 180k row replica on Android (343ms -> 672ms).\n    if (!isAscending(rows, comparator)) {\n      rows.sort(comparator);\n    }\n    index.data = BTreeSet.fromSorted(comparator, rows);\n  }\n\n  *push(change: SourceChange): Stream<'yield'> {\n    for (const result of this.genPush(change)) {\n      if (result === 'yield') {\n        yield result;\n      }\n    }\n  }\n\n  genPush(change: SourceChange) {\n    const primaryIndex = this.#getPrimaryIndex();\n    const {data} = primaryIndex;\n    const exists = (row: Row) => data.has(row);\n    const setOverlay = (o: Overlay | undefined) => (this.#overlay = o);\n    const writeChange = (c: SourceChange) => this.#writeChange(c);\n    return genPushAndWriteWithSplitEdit(\n      this.#connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      () => ++this.#pushEpoch,\n    );\n  }\n\n  #writeChange(change: SourceChange) {\n    for (const {data} of this.#indexes.values()) {\n      switch (change[SourceChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          const added = data.add(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            added,\n            'MemorySource: add must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.REMOVE: {\n          const removed = data.delete(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: remove must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.EDIT: {\n          // TODO: We could see if the PK (form the index tree's perspective)\n          // changed and if not we could use set.\n          // We cannot just do `set` with the new value since the `oldRow` might\n          // not map to the same entry as the new `row` in the index btree.\n          const removed = data.delete(change[SourceChangeIndex.OLD_ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: edit remove must succeed since row existence was already checked',\n          );\n          data.add(change[SourceChangeIndex.ROW]);\n          break;\n        }\n        default:\n          unreachable(change);\n      }\n    }\n  }\n}\n\nfunction mergePredicates(\n  connPredicate: ((row: Row) => boolean) | undefined,\n  reqFilter: NoSubqueryCondition | undefined,\n): ((row: Row) => boolean) | undefined {\n  if (!reqFilter) {\n    return connPredicate;\n  }\n  const reqPredicate = createPredicate(reqFilter);\n  if (!connPredicate) {\n    return reqPredicate;\n  }\n  return row => connPredicate(row) && reqPredicate(row);\n}\n\nfunction* generateWithConstraint(\n  it: Stream<Node>,\n  constraint: Constraint | undefined,\n) {\n  for (const node of it) {\n    if (constraint && !constraintMatchesRow(constraint, node.row)) {\n      break;\n    }\n    yield node;\n  }\n}\n\nfunction* generateWithFilter(it: Stream<Node>, filter: (row: Row) => boolean) {\n  for (const node of it) {\n    if (filter(node.row)) {\n      yield node;\n    }\n  }\n}\n\nexport function* genPushAndWriteWithSplitEdit(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: ((row: Row) => boolean) | undefined,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  getNextEpoch: () => number,\n) {\n  let shouldSplitEdit = false;\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT) {\n    for (const {splitEditKeys} of connections) {\n      if (splitEditKeys) {\n        for (const key of splitEditKeys) {\n          if (\n            !valuesEqual(\n              change[SourceChangeIndex.ROW][key],\n              change[SourceChangeIndex.OLD_ROW][key],\n            )\n          ) {\n            shouldSplitEdit = true;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT && shouldSplitEdit) {\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeRemove(change[SourceChangeIndex.OLD_ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeAdd(change[SourceChangeIndex.ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  } else {\n    yield* genPushAndWrite(\n      connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  }\n}\n\nfunction* genPushAndWrite(\n  connections: readonly Connection[],\n  change: SourceChangeAdd | SourceChangeRemove | SourceChangeEdit,\n  exists: ((row: Row) => boolean) | undefined,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  pushEpoch: number,\n) {\n  for (const x of genPush(connections, change, exists, setOverlay, pushEpoch)) {\n    yield x;\n  }\n  writeChange(change);\n}\n\nfunction* genPush(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: ((row: Row) => boolean) | undefined,\n  setOverlay: (o: Overlay | undefined) => void,\n  pushEpoch: number,\n) {\n  if (exists) {\n    switch (change[SourceChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        assert(\n          !exists(change[SourceChangeIndex.ROW]),\n          () => `Row already exists ${stringify(change)}`,\n        );\n        break;\n      case ChangeType.REMOVE:\n        assert(\n          exists(change[SourceChangeIndex.ROW]),\n          () => `Row not found ${stringify(change)}`,\n        );\n        break;\n      case ChangeType.EDIT:\n        assert(\n          exists(change[SourceChangeIndex.OLD_ROW]),\n          () => `Row not found ${stringify(change)}`,\n        );\n        break;\n      default:\n        unreachable(change);\n    }\n  }\n\n  setOverlay({epoch: pushEpoch, change});\n  try {\n    for (const conn of connections) {\n      const {output, filters, input} = conn;\n      if (output) {\n        conn.lastPushedEpoch = pushEpoch;\n        const outputChange: Change =\n          change[SourceChangeIndex.TYPE] === ChangeType.EDIT\n            ? makeEditChange(\n                {row: change[SourceChangeIndex.ROW], relationships: {}},\n                {row: change[SourceChangeIndex.OLD_ROW], relationships: {}},\n              )\n            : change[SourceChangeIndex.TYPE] === ChangeType.ADD\n              ? makeAddChange({\n                  row: change[SourceChangeIndex.ROW],\n                  relationships: {},\n                })\n              : makeRemoveChange({\n                  row: change[SourceChangeIndex.ROW],\n                  relationships: {},\n                });\n        yield* filterPush(outputChange, output, input, filters?.predicate);\n        yield undefined;\n      }\n    }\n\n    for (const conn of connections) {\n      const {output, input} = conn;\n      if (output?.reconcile) {\n        yield* output.reconcile(input);\n        yield undefined;\n      }\n    }\n  } finally {\n    setOverlay(undefined);\n  }\n}\n\nexport function* generateWithStart(\n  nodes: Iterable<Node | 'yield'>,\n  start: Start | undefined,\n  compare: (r1: Row, r2: Row) => number,\n): Stream<Node | 'yield'> {\n  if (!start) {\n    yield* nodes;\n    return;\n  }\n  let started = false;\n  for (const node of nodes) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!started) {\n      if (start.basis === 'at') {\n        if (compare(node.row, start.row) >= 0) {\n          started = true;\n        }\n      } else if (start.basis === 'after') {\n        if (compare(node.row, start.row) > 0) {\n          started = true;\n        }\n      }\n    }\n    if (started) {\n      yield node;\n    }\n  }\n}\n\n/**\n * Takes an iterator and overlay.\n * Splices the overlay into the iterator at the correct position.\n *\n * @param startAt - if there is a lower bound to the stream. If the lower bound of the stream\n * is above the overlay, the overlay will be skipped.\n * @param rows - the stream into which the overlay should be spliced\n * @param constraint - constraint that was applied to the rowIterator and should\n * also be applied to the overlay.\n * @param overlay - the overlay values to splice in\n * @param compare - the comparator to use to find the position for the overlay.\n * Must order rows the same way `rows` is ordered. For `MemorySource` that is\n * *index* order, which leads with the constraint keys.\n * @param startAtCompare - the comparator for `startAt`, which is a bound in the\n * *connection's* sort order. Only the same as `compare` when the stream's order\n * happens to be the connection's -- true for `TableSource` (SQL does the\n * ordering) but not for a constrained `MemorySource` fetch. Conflating the two\n * is what #4926 fixed for `generateWithStart`; this parameter is the same\n * distinction for the overlay's own `startAt` pruning.\n */\nexport function generateWithOverlay(\n  startAt: Row | undefined,\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  compare: Comparator,\n  startAtCompare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[],\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  const overlays = computeOverlays(\n    startAt,\n    constraint,\n    overlayToApply,\n    startAtCompare,\n    filterPredicate,\n    multiConstraints,\n  );\n  return generateWithOverlayInner(rows, overlays, compare);\n}\n\nfunction computeOverlays(\n  startAt: Row | undefined,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  // Only ever used for `overlaysForStartAt`, so this is the *connection*-order\n  // comparator, not the one used to splice the overlay into the row stream.\n  startAtCompare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[],\n): Overlays {\n  let overlays: Overlays = {\n    add: undefined,\n    remove: undefined,\n  };\n  switch (overlay?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlay.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: overlay.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n\n  if (startAt) {\n    overlays = overlaysForStartAt(overlays, startAt, startAtCompare);\n  }\n\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n\n  return overlays;\n}\n\nfunction applyMultiConstraintsToOverlays(\n  overlays: Overlays,\n  multiConstraints: readonly MultiConstraint[] | undefined,\n): Overlays {\n  if (!multiConstraints) return overlays;\n  for (const mc of multiConstraints) {\n    if (mc.length > 0) {\n      overlays = overlaysForMultiConstraint(overlays, mc);\n    }\n  }\n  return overlays;\n}\n\nexport {overlaysForMultiConstraint as overlaysForMultiConstraintForTest};\n\nfunction overlaysForMultiConstraint(\n  {add, remove}: Overlays,\n  multiConstraint: MultiConstraint,\n): Overlays {\n  const matchesAny = (row: Row | undefined) => {\n    if (row === undefined) return false;\n    for (const c of multiConstraint) {\n      if (constraintMatchesRow(c, row)) return true;\n    }\n    return false;\n  };\n  return {\n    add: matchesAny(add) ? add : undefined,\n    remove: matchesAny(remove) ? remove : undefined,\n  };\n}\n\nexport {overlaysForStartAt as overlaysForStartAtForTest};\n\nfunction overlaysForStartAt(\n  {add, remove}: Overlays,\n  startAt: Row,\n  compare: Comparator,\n): Overlays {\n  const undefinedIfBeforeStartAt = (row: Row | undefined) =>\n    row === undefined || compare(row, startAt) < 0 ? undefined : row;\n  return {\n    add: undefinedIfBeforeStartAt(add),\n    remove: undefinedIfBeforeStartAt(remove),\n  };\n}\n\nexport {overlaysForConstraint as overlaysForConstraintForTest};\n\nfunction overlaysForConstraint(\n  {add, remove}: Overlays,\n  constraint: Constraint,\n): Overlays {\n  const undefinedIfDoesntMatchConstraint = (row: Row | undefined) =>\n    row === undefined || !constraintMatchesRow(constraint, row)\n      ? undefined\n      : row;\n\n  return {\n    add: undefinedIfDoesntMatchConstraint(add),\n    remove: undefinedIfDoesntMatchConstraint(remove),\n  };\n}\n\nfunction overlaysForFilterPredicate(\n  {add, remove}: Overlays,\n  filterPredicate: (row: Row) => boolean | undefined,\n): Overlays {\n  const undefinedIfDoesntMatchFilter = (row: Row | undefined) =>\n    row === undefined || !filterPredicate(row) ? undefined : row;\n\n  return {\n    add: undefinedIfDoesntMatchFilter(add),\n    remove: undefinedIfDoesntMatchFilter(remove),\n  };\n}\n\nexport function* generateWithOverlayInner(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  compare: (r1: Row, r2: Row) => number,\n) {\n  let addOverlayYielded = false;\n  let removeOverlaySkipped = false;\n  for (const row of rowIterator) {\n    if (!addOverlayYielded && overlays.add) {\n      const cmp = compare(overlays.add, row);\n      if (cmp < 0) {\n        addOverlayYielded = true;\n        yield {row: overlays.add, relationships: {}};\n      }\n    }\n\n    if (!removeOverlaySkipped && overlays.remove) {\n      const cmp = compare(overlays.remove, row);\n      if (cmp === 0) {\n        removeOverlaySkipped = true;\n        continue;\n      }\n    }\n    yield {row, relationships: {}};\n  }\n\n  if (!addOverlayYielded && overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n}\n\n/**\n * Like {@link generateWithOverlay} but for unordered streams.\n * No `startAt` or comparator needed. Injects remove/old-edit rows eagerly\n * at the start, and suppresses add/new-edit rows inline by PK match.\n */\nexport function generateWithOverlayUnordered(\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  primaryKey: PrimaryKey,\n  filterPredicate?: (row: Row) => boolean,\n  multiConstraints?: readonly MultiConstraint[],\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  let overlays: Overlays = {add: undefined, remove: undefined};\n  switch (overlayToApply?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlayToApply.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: overlayToApply.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n  return generateWithOverlayInnerUnordered(rows, overlays, primaryKey);\n}\n\nexport function* generateWithOverlayInnerUnordered(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  primaryKey: PrimaryKey,\n) {\n  // Eager inject: yield the add overlay at the start (row not yet in storage)\n  if (overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n  // Stream with inline suppress: skip the remove overlay (row still in storage)\n  let removeSkipped = false;\n  for (const row of rowIterator) {\n    if (\n      !removeSkipped &&\n      overlays.remove &&\n      rowMatchesPK(overlays.remove, row, primaryKey)\n    ) {\n      removeSkipped = true;\n      continue;\n    }\n    yield {row, relationships: {}};\n  }\n}\n\nfunction rowMatchesPK(a: Row, b: Row, primaryKey: PrimaryKey): boolean {\n  for (const key of primaryKey) {\n    if (!valuesEqual(a[key], b[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * A location to begin scanning an index from. Can either be a specific value\n * or the min or max possible value for the type. This is used to start a scan\n * at the beginning of the rows matching a constraint.\n */\nexport type Bound = Value | MinValue | MaxValue;\nexport type RowBound = Record<string, Bound>;\nexport const minValue = Symbol('min-value');\ntype MinValue = typeof minValue;\nexport const maxValue = Symbol('max-value');\ntype MaxValue = typeof maxValue;\n\nfunction isAscending(rows: Row[], comparator: Comparator): boolean {\n  for (let i = 1; i < rows.length; i++) {\n    if (comparator(rows[i - 1], rows[i]) > 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makeBoundComparator(sort: Ordering): Comparator {\n  // Pre-extract the first two keys/directions to avoid per-call array access.\n  // All paths share one function literal (single SFI) so the BTree comparator call site\n  // stays monomorphic across indexes with different sort orderings, preventing V8 IC deopt.\n  // Even a 2-SFI split (e.g. separate len=1 path) creates a polymorphic IC that\n  // measurably regresses performance, so we keep a single return body.\n  const len = sort.length;\n  const k0 = sort[0][0];\n  const a0 = sort[0][1] === 'asc';\n  const k1 = len > 1 ? sort[1][0] : '';\n  const a1 = len > 1 ? sort[1][1] === 'asc' : true;\n\n  return (a: RowBound, b: RowBound) => {\n    const c0 = a0 ? compareBounds(a[k0], b[k0]) : compareBounds(b[k0], a[k0]);\n    if (len === 1 || c0 !== 0) return c0;\n    const c1 = a1 ? compareBounds(a[k1], b[k1]) : compareBounds(b[k1], a[k1]);\n    if (len === 2 || c1 !== 0) return c1;\n    // Hot! Do not use destructuring\n    for (let i = 2; i < len; i++) {\n      const cmp = compareBounds(a[sort[i][0]], b[sort[i][0]]);\n      if (cmp !== 0) return sort[i][1] === 'asc' ? cmp : -cmp;\n    }\n    return 0;\n  };\n}\n\nfunction compareBounds(a: Bound, b: Bound): number {\n  if (a === b) {\n    return 0;\n  }\n  // Use typeof to guard the Symbol sentinel checks first. This gives V8 a\n  // clear type discriminant so the common non-symbol path compiles as a\n  // specialised numeric/string fast-path without a Smi deopt when the\n  // minValue/maxValue sentinel symbols appear.\n  if (typeof a === 'symbol') {\n    return a === minValue ? -1 : 1;\n  }\n  if (typeof b === 'symbol') {\n    return b === minValue ? 1 : -1;\n  }\n  return compareValues(a, b);\n}\n\nexport function generateRows(\n  data: BTreeSet<Row>,\n  scanStart: RowBound | undefined,\n  reverse: boolean | undefined,\n) {\n  return reverse\n    ? data.valuesFromReversed(scanStart as Row | undefined)\n    : data.valuesFrom(scanStart as Row | undefined);\n}\n\nexport function stringify(change: SourceChange) {\n  return JSON.stringify(change, (_, v) =>\n    typeof v === 'bigint' ? v.toString() : v,\n  );\n}\n\n/**\n * N-way merge of pre-sorted Node streams. Each input stream must yield\n * Nodes in `compare` order (and may interleave 'yield' values, which are\n * forwarded as-is). The merged stream yields Nodes in `compare` order.\n *\n * Implemented as a binary min-heap keyed by `compare(entry.row, ...)`, so\n * each emit costs O(log K) (K = number of streams) rather than the O(K)\n * a linear-scan-of-heads merge would. Matters when FlippedJoin chunks a\n * large `multiConstraints` IN-list into hundreds of sub-fetches.\n *\n * If the merged stream is closed early (e.g. downstream `Take` `break`s\n * after hitting its limit, prompting JS to call `.return()` on this\n * generator), the `finally` block propagates `.return()` to each\n * non-exhausted sub-iterator so the underlying sources (SQLite cursors,\n * etc.) can run their cleanup. Without this, mid-merge early-termination\n * leaves cursors open, causing later writes on the same connection to\n * fail with \"database connection is busy executing a query\".\n */\nexport function* mergeSortedStreams(\n  streams: readonly Stream<Node | 'yield'>[],\n  compare: (a: Node, b: Node) => number,\n): Stream<Node | 'yield'> {\n  const iterators: Iterator<Node | 'yield'>[] = streams.map(s =>\n    s[Symbol.iterator](),\n  );\n  // True while iterators[i] hasn't yet returned `done`. The finally\n  // block uses this to skip already-exhausted streams when propagating\n  // `.return()`.\n  const active = Array.from({length: iterators.length}).fill(true) as boolean[];\n\n  // Min-heap of entries; `idx` tells us which stream to refill from\n  // after the entry's row is emitted.\n  type Entry = {row: Node; idx: number};\n  const heap: Entry[] = [];\n\n  const siftUp = (start: number) => {\n    let i = start;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (compare(heap[i].row, heap[p].row) >= 0) return;\n      const t = heap[i];\n      heap[i] = heap[p];\n      heap[p] = t;\n      i = p;\n    }\n  };\n\n  const siftDown = (start: number) => {\n    let i = start;\n    const n = heap.length;\n    while (true) {\n      const l = (i << 1) + 1;\n      const r = l + 1;\n      let smallest = i;\n      if (l < n && compare(heap[l].row, heap[smallest].row) < 0) smallest = l;\n      if (r < n && compare(heap[r].row, heap[smallest].row) < 0) smallest = r;\n      if (smallest === i) return;\n      const t = heap[i];\n      heap[i] = heap[smallest];\n      heap[smallest] = t;\n      i = smallest;\n    }\n  };\n\n  // Pull the next Node from iterator `idx`, forwarding any 'yield's.\n  // Returns the Node, or `undefined` once the stream is exhausted.\n  const pullNext = function* (\n    idx: number,\n  ): IterableIterator<'yield', Node | undefined, undefined> {\n    while (true) {\n      const r = iterators[idx].next();\n      if (r.done) {\n        active[idx] = false;\n        return undefined;\n      }\n      if (r.value === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      return r.value;\n    }\n  };\n\n  try {\n    // Prime: push the first row of each non-empty stream onto the heap.\n    for (let i = 0; i < iterators.length; i++) {\n      const row = yield* pullNext(i);\n      if (row !== undefined) {\n        heap.push({row, idx: i});\n        siftUp(heap.length - 1);\n      }\n    }\n\n    while (heap.length > 0) {\n      // Root is the global min across all active streams.\n      const top = heap[0];\n      yield top.row;\n      const next = yield* pullNext(top.idx);\n      if (next !== undefined) {\n        // Refill root in place (top === heap[0]) and sift down. The\n        // already-yielded `top.row` value is captured by the yield, so\n        // mutating it here doesn't affect what was emitted.\n        top.row = next;\n        siftDown(0);\n      } else {\n        // Stream exhausted. Move tail to root and shrink. Pop returns\n        // the last entry; if the heap had only one entry it was the\n        // root we just yielded, so we just leave the heap empty.\n        const last = must(heap.pop());\n        if (heap.length > 0) {\n          heap[0] = last;\n          siftDown(0);\n        }\n      }\n    }\n  } finally {\n    // Close any iterators that aren't already exhausted so their\n    // `finally` blocks (which release cursors / cached statements) run.\n    for (let i = 0; i < iterators.length; i++) {\n      if (active[i]) {\n        iterators[i].return?.();\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/memory-storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory-storage.js","names":["#data"],"sources":["../../../../../zql/src/ivm/memory-storage.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {BTreeSet} from '../../../shared/src/btree-set.ts';\nimport type {JSONValue} from '../../../shared/src/json.ts';\nimport type {Storage} from './operator.ts';\nimport type {Stream} from './stream.ts';\n\ntype Entry = [key: string, value: JSONValue];\n\nfunction comparator(a: Entry, b: Entry): number {\n  return compareUTF8(a[0], b[0]);\n}\n\n/**\n * MemoryStorage is a simple in-memory implementation of `Storage` for use\n * on the client and in tests.\n */\nexport class MemoryStorage implements Storage {\n  #data: BTreeSet<Entry> = new BTreeSet(comparator);\n\n  set(key: string, value: JSONValue) {\n    this.#data.add([key, value]);\n  }\n\n  get(key: string, def?: JSONValue): JSONValue | undefined {\n    const r = this.#data.get([key, null]);\n    if (r !== undefined) {\n      return r[1];\n    }\n    return def;\n  }\n\n  del(key: string) {\n    this.#data.delete([key, null]);\n  }\n\n  *scan(options?: {prefix: string}): Stream<[string, JSONValue]> {\n    for (const entry of this.#data.valuesFrom(\n      options && [options.prefix, null],\n    )) {\n      if (options && !entry[0].startsWith(options.prefix)) {\n        return;\n      }\n      yield entry;\n    }\n  }\n\n  destroy() {\n    // Nothing to release: the entries are garbage collected along with the\n    // operator that owns this storage.\n  }\n\n  cloneData(): Record<string, JSONValue> {\n    return structuredClone(Object.fromEntries(this.#data.values()));\n  }\n}\n"],"mappings":";;;AAQA,SAAS,WAAW,GAAU,GAAkB;CAC9C,OAAO,YAAY,EAAE,IAAI,EAAE,EAAE;AAC/B;;;;;AAMA,IAAa,gBAAb,MAA8C;CAC5C,QAAyB,IAAI,SAAS,UAAU;CAEhD,IAAI,KAAa,OAAkB;EACjC,KAAKA,MAAM,IAAI,CAAC,KAAK,KAAK,CAAC;CAC7B;CAEA,IAAI,KAAa,KAAwC;EACvD,MAAM,IAAI,KAAKA,MAAM,IAAI,CAAC,KAAK,IAAI,CAAC;EACpC,IAAI,MAAM,KAAA,GACR,OAAO,EAAE;EAEX,OAAO;CACT;CAEA,IAAI,KAAa;EACf,KAAKA,MAAM,OAAO,CAAC,KAAK,IAAI,CAAC;CAC/B;CAEA,CAAC,KAAK,SAAyD;EAC7D,KAAK,MAAM,SAAS,KAAKA,MAAM,WAC7B,WAAW,CAAC,QAAQ,QAAQ,IAAI,CAClC,GAAG;GACD,IAAI,WAAW,CAAC,MAAM,GAAG,WAAW,QAAQ,MAAM,GAChD;GAEF,MAAM;EACR;CACF;CAEA,UAAU,CAGV;CAEA,YAAuC;EACrC,OAAO,gBAAgB,OAAO,YAAY,KAAKA,MAAM,OAAO,CAAC,CAAC;CAChE;AACF"}
+{"version":3,"file":"memory-storage.js","names":[],"sources":["../../../../../zql/src/ivm/memory-storage.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {BTreeSet} from '../../../shared/src/btree-set.ts';\nimport type {JSONValue} from '../../../shared/src/json.ts';\nimport type {Storage} from './operator.ts';\nimport type {Stream} from './stream.ts';\n\ntype Entry = [key: string, value: JSONValue];\n\nfunction comparator(a: Entry, b: Entry): number {\n  return compareUTF8(a[0], b[0]);\n}\n\n/**\n * MemoryStorage is a simple in-memory implementation of `Storage` for use\n * on the client and in tests.\n */\nexport class MemoryStorage implements Storage {\n  #data: BTreeSet<Entry> = new BTreeSet(comparator);\n\n  set(key: string, value: JSONValue) {\n    this.#data.add([key, value]);\n  }\n\n  get(key: string, def?: JSONValue): JSONValue | undefined {\n    const r = this.#data.get([key, null]);\n    if (r !== undefined) {\n      return r[1];\n    }\n    return def;\n  }\n\n  del(key: string) {\n    this.#data.delete([key, null]);\n  }\n\n  *scan(options?: {prefix: string}): Stream<[string, JSONValue]> {\n    for (const entry of this.#data.valuesFrom(\n      options && [options.prefix, null],\n    )) {\n      if (options && !entry[0].startsWith(options.prefix)) {\n        return;\n      }\n      yield entry;\n    }\n  }\n\n  destroy() {\n    // Nothing to release: the entries are garbage collected along with the\n    // operator that owns this storage.\n  }\n\n  cloneData(): Record<string, JSONValue> {\n    return structuredClone(Object.fromEntries(this.#data.values()));\n  }\n}\n"],"mappings":";;;AAQA,SAAS,WAAW,GAAU,GAAkB;CAC9C,OAAO,YAAY,EAAE,IAAI,EAAE,EAAE;AAC/B;;;;;AAMA,IAAa,gBAAb,MAA8C;CAC5C,QAAyB,IAAI,SAAS,UAAU;CAEhD,IAAI,KAAa,OAAkB;EACjC,KAAK,MAAM,IAAI,CAAC,KAAK,KAAK,CAAC;CAC7B;CAEA,IAAI,KAAa,KAAwC;EACvD,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC,KAAK,IAAI,CAAC;EACpC,IAAI,MAAM,KAAA,GACR,OAAO,EAAE;EAEX,OAAO;CACT;CAEA,IAAI,KAAa;EACf,KAAK,MAAM,OAAO,CAAC,KAAK,IAAI,CAAC;CAC/B;CAEA,CAAC,KAAK,SAAyD;EAC7D,KAAK,MAAM,SAAS,KAAK,MAAM,WAC7B,WAAW,CAAC,QAAQ,QAAQ,IAAI,CAClC,GAAG;GACD,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC,WAAW,QAAQ,MAAM,GAChD;GAEF,MAAM;EACR;CACF;CAEA,UAAU,CAGV;CAEA,YAAuC;EACrC,OAAO,gBAAgB,OAAO,YAAY,KAAK,MAAM,OAAO,CAAC,CAAC;CAChE;AACF"}

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

@@ -1,4 +1,4 @@
-import "./skip-yields.js";
+import { skipYields } from "./skip-yields.js";
 //#region ../zql/src/ivm/operator.ts
 /**
 * An implementation of Output that throws if pushed to. It is used as the
@@ -13,6 +13,6 @@ var throwOutput = {
 	}
 };
 //#endregion
-export { throwOutput };
+export { skipYields, throwOutput };
 
 //# sourceMappingURL=operator.js.map

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

@@ -161,7 +161,6 @@ function* pushCollapsed(candidatesToPush, output, pusher, fanOutChangeType, merg
 			yield* output.push(addEmptyRelationships(must(addChange ?? removeChange)), pusher);
 			return;
 		}
-		default:
 	}
 }
 /**

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":"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"}

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/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.js

@@ -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;
@@ -441,6 +439,6 @@ function makePartitionKeyComparator(partitionKey) {
 	};
 }
 //#endregion
-export { Take, constraintMatchesPartitionKey, makePartitionKeyComparator };
+export { Take, constraintContainsPartitionKey, constraintMatchesPartitionKey, makePartitionKeyComparator };
 
 //# sourceMappingURL=take.js.map