@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.10

package/out/packages/zql/src/ivm/maybe-split-and-push-edit-change.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe-split-and-push-edit-change.js","names":[],"sources":["../../../../../../zql/src/ivm/maybe-split-and-push-edit-change.ts"],"sourcesContent":["import type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {makeAddChange, makeRemoveChange, type EditChange} from './change.ts';\nimport type {InputBase, Output} from './operator.ts';\n\n/**\n * This takes an {@linkcode EditChange} and a predicate that determines if a row\n * should be present based on the row's data. It then splits the change and\n * pushes the appropriate changes to the output based on the predicate.\n */\nexport function* maybeSplitAndPushEditChange(\n  change: EditChange,\n  predicate: (row: Row) => boolean,\n  output: Output,\n  pusher: InputBase,\n) {\n  const oldWasPresent = predicate(change[ChangeIndex.OLD_NODE].row);\n  const newIsPresent = predicate(change[ChangeIndex.NODE].row);\n\n  if (oldWasPresent && newIsPresent) {\n    yield* output.push(change, pusher);\n  } else if (oldWasPresent && !newIsPresent) {\n    yield* output.push(makeRemoveChange(change[ChangeIndex.OLD_NODE]), pusher);\n  } else if (!oldWasPresent && newIsPresent) {\n    yield* output.push(makeAddChange(change[ChangeIndex.NODE]), pusher);\n  }\n}\n"],"mappings":";;;;;;;AAUA,UAAiB,4BACf,QACA,WACA,QACA,QACA;CACA,MAAM,gBAAgB,UAAU,OAAO,GAAsB,GAAG;CAChE,MAAM,eAAe,UAAU,OAAO,GAAkB,GAAG;CAE3D,IAAI,iBAAiB,cACnB,OAAO,OAAO,KAAK,QAAQ,MAAM;MAC5B,IAAI,iBAAiB,CAAC,cAC3B,OAAO,OAAO,KAAK,iBAAiB,OAAO,EAAqB,GAAG,MAAM;MACpE,IAAI,CAAC,iBAAiB,cAC3B,OAAO,OAAO,KAAK,cAAc,OAAO,EAAiB,GAAG,MAAM;AAEtE"}

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

@@ -0,0 +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 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  usedBy: Set<Connection>;\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      usedBy: new Set(),\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    // 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, usedBy: Connection): 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      index.usedBy.add(usedBy);\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, usedBy: new Set([usedBy])};\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 pkConstraint = primaryKeyConstraintFromFilters(\n      conn.filters?.condition,\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, conn);\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    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      conn.filters?.predicate,\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* conn.filters\n      ? generateWithFilter(withConstraint, conn.filters.predicate)\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  *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    yield* 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* 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,\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,\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,\n  setOverlay: (o: Overlay | undefined) => void,\n  pushEpoch: number,\n) {\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  for (const conn of connections) {\n    const {output, filters, input} = conn;\n    if (output) {\n      conn.lastPushedEpoch = pushEpoch;\n      setOverlay({epoch: pushEpoch, change});\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  setOverlay(undefined);\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 */\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  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\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    compare,\n    filterPredicate,\n    multiConstraints,\n  );\n  yield* generateWithOverlayInner(rows, overlays, compare);\n}\n\nfunction computeOverlays(\n  startAt: Row | undefined,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  compare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\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, compare);\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[] | undefined,\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  yield* 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 */\ntype Bound = Value | MinValue | MaxValue;\ntype RowBound = Record<string, Bound>;\nconst minValue = Symbol('min-value');\ntype MinValue = typeof minValue;\nconst maxValue = Symbol('max-value');\ntype MaxValue = typeof maxValue;\n\nfunction 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\nfunction* generateRows(\n  data: BTreeSet<Row>,\n  scanStart: RowBound | undefined,\n  reverse: boolean | undefined,\n) {\n  yield* data[reverse ? 'valuesFromReversed' : 'valuesFrom'](\n    scanStart as Row | undefined,\n  );\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: boolean[] = new Array(iterators.length).fill(true);\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  ): Generator<'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/packages/zql/src/ivm/memory-storage.js.map

@@ -0,0 +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  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,YAAuC;EACrC,OAAO,gBAAgB,OAAO,YAAY,KAAKA,MAAM,OAAO,CAAC,CAAC;CAChE;AACF"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"operator.js","names":[],"sources":["../../../../../../zql/src/ivm/operator.ts"],"sourcesContent":["import type {JSONValue} from '../../../shared/src/json.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {Change} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport {skipYields} from './skip-yields.ts';\n\n/**\n * Input to an operator.\n */\nexport interface InputBase {\n  /** The schema of the data this input returns. */\n  getSchema(): SourceSchema;\n\n  /**\n   * Completely destroy the input. Destroying an input\n   * causes it to call destroy on its upstreams, fully\n   * cleaning up a pipeline.\n   */\n  destroy(): void;\n}\n\nexport interface Input extends InputBase {\n  /** Tell the input where to send its output. */\n  setOutput(output: Output): void;\n\n  /**\n   * Fetch data. May modify the data in place.\n   * Returns nodes sorted in order of `SourceSchema.compareRows`.\n   *\n   * The stream may contain 'yield' to yield control to the caller for purposes\n   * of responsiveness.\n   *\n   * Contract:\n   * - During fetch: If an input yields 'yield', 'yield' must be yielded to the\n   * caller of fetch immediately.\n   * - During push: If a fetch to an input consumed by the push logic yields\n   * 'yield', it must be yielded to the caller of push immediately.\n   */\n  fetch(req: FetchRequest): Stream<Node | 'yield'>;\n}\n\n/**\n * A single multi-row IN clause: a non-empty list of Constraints all\n * sharing the same column shape. Sources treat it as\n * `(col_a, col_b, …) IN VALUES (…)`.\n *\n * Caller invariants (sources rely on these — they are not re-checked):\n * - **Unique entries.** TableSource gets set semantics for free from SQL\n *   `IN`; MemorySource fans sub-fetches out per entry, so duplicates\n *   would yield the same row N times. FlippedJoin groups by canonical\n *   parent-key (`flipped-join.ts:#fetchBatched`) before emitting.\n * - **Key-compatible with `req.constraint`.** Entries that contradict\n *   `constraint` should be dropped upstream. FlippedJoin filters\n *   incompatible children via `constraintsAreCompatible` before adding\n *   them to a batch.\n */\nexport type MultiConstraint = readonly Constraint[];\n\nexport type FetchRequest = {\n  readonly constraint?: Constraint | undefined;\n\n  /**\n   * List of multi-row IN clauses, all ANDed together (and ANDed with\n   * `constraint` if both are provided). Each entry is a `MultiConstraint`\n   * over its own set of columns.\n   *\n   * Used by FlippedJoin to push child→parent fetches into a single\n   * batched statement, and to AND together constraints contributed by\n   * chained FlippedJoins (e.g. `assigneeID IN (…) AND creatorID IN (…)`).\n   */\n  readonly multiConstraints?: readonly MultiConstraint[] | undefined;\n\n  /** If supplied, `start.row` must have previously been output by fetch or push. */\n  readonly start?: Start | undefined;\n\n  /** Whether to fetch in reverse order of the SourceSchema's sort. */\n  readonly reverse?: boolean | undefined;\n};\n\nexport type Start = {\n  readonly row: Row;\n  readonly basis: 'at' | 'after';\n};\n\n/**\n * An output for an operator. Typically another Operator but can also be\n * the code running the pipeline.\n */\nexport interface Output {\n  /**\n   * Push incremental changes to data previously received with fetch().\n   * Consumers must apply all pushed changes or incremental result will\n   * be incorrect.\n   * Callers must maintain some invariants for correct operation:\n   * - Only add rows which do not already exist (by deep equality).\n   * - Only remove rows which do exist (by deep equality).\n   * Implmentation can yield 'yield' to yield control to the caller for purposes\n   * of responsiveness.\n   * Yield contract:\n   * - During a push: If a push call to an output yields 'yield', it must be\n   * yielded to the caller of push immediately.\n   */\n  push(change: Change, pusher: InputBase): Stream<'yield'>;\n}\n\n/**\n * An implementation of Output that throws if pushed to. It is used as the\n * initial value for for an operator's output before it is set.\n */\nexport const throwOutput: Output = {\n  push(_change: Change): Stream<'yield'> {\n    throw new Error('Output not set');\n  },\n};\n\n/**\n * Operators are arranged into pipelines.\n * They are stateful.\n * Each operator is an input to the next operator in the chain and an output\n * to the previous.\n */\nexport interface Operator extends Input, Output {}\n\n/**\n * Operators get access to storage that they can store their internal\n * state in.\n */\nexport interface Storage {\n  set(key: string, value: JSONValue): void;\n  get(key: string, def?: JSONValue): JSONValue | undefined;\n  /**\n   * If options is not specified, defaults to scanning all entries.\n   */\n  scan(options?: {prefix: string}): Stream<[string, JSONValue]>;\n  del(key: string): void;\n}\n"],"mappings":";;;;;;AAiHA,IAAa,cAAsB,EACjC,KAAK,SAAkC;CACrC,MAAM,IAAI,MAAM,gBAAgB;AAClC,EACF"}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip.js","names":["#input","#bound","#comparator","#getStart","#shouldBePresent","#output"],"sources":["../../../../../../zql/src/ivm/skip.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  type AddChange,\n  type Change,\n  type ChildChange,\n  type RemoveChange,\n} from './change.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Bound = {\n  row: Row;\n  exclusive: boolean;\n};\n\n/**\n * Skip sets the start position for the pipeline. No rows before the bound will\n * be output.\n */\nexport class Skip implements Operator {\n  readonly #input: Input;\n  readonly #bound: Bound;\n  readonly #comparator: Comparator;\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, bound: Bound) {\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Skip requires sorted input');\n    this.#input = input;\n    this.#bound = bound;\n    this.#comparator = input.getSchema().compareRows;\n    input.setOutput(this);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const start = this.#getStart(req);\n    if (start === 'empty') {\n      return;\n    }\n    const nodes = this.#input.fetch({...req, start});\n    if (!req.reverse) {\n      yield* nodes;\n      return;\n    }\n    for (const node of nodes) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (!this.#shouldBePresent(node.row)) {\n        return;\n      }\n      yield node;\n    }\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  #shouldBePresent(row: Row): boolean {\n    const cmp = this.#comparator(this.#bound.row, row);\n    return cmp < 0 || (cmp === 0 && !this.#bound.exclusive);\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const shouldBePresent = (row: Row) => this.#shouldBePresent(row);\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* maybeSplitAndPushEditChange(\n        change,\n        shouldBePresent,\n        this.#output,\n        this,\n      );\n      return;\n    }\n\n    change satisfies AddChange | RemoveChange | ChildChange;\n\n    if (shouldBePresent(change[ChangeIndex.NODE].row)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  #getStart(req: FetchRequest): Start | undefined | 'empty' {\n    const boundStart = {\n      row: this.#bound.row,\n      basis: this.#bound.exclusive ? 'after' : 'at',\n    } as const;\n\n    if (!req.start) {\n      if (req.reverse) {\n        return undefined;\n      }\n      return boundStart;\n    }\n\n    const cmp = this.#comparator(this.#bound.row, req.start.row);\n\n    if (!req.reverse) {\n      // The skip bound is after the requested bound. The requested bound cannot\n      // be relevant because even if it was basis: 'after', the skip bound is\n      // itself after the requested bound. Return the skip bound.\n      if (cmp > 0) {\n        return boundStart;\n      }\n\n      // The skip bound and requested bound are equal. If either is exclusive,\n      // return that bound with exclusive. Otherwise, return the skip bound.\n      if (cmp === 0) {\n        if (this.#bound.exclusive || req.start.basis === 'after') {\n          return {\n            row: this.#bound.row,\n            basis: 'after',\n          };\n        }\n        return boundStart;\n      }\n\n      return req.start;\n    }\n\n    req.reverse satisfies true;\n\n    // bound is after the start, but request is for reverse so results\n    // must be empty\n    if (cmp > 0) {\n      return 'empty';\n    }\n\n    if (cmp === 0) {\n      // if both are inclusive, the result can be the single row at bound\n      // return it as start\n      if (!this.#bound.exclusive && req.start.basis === 'at') {\n        return boundStart;\n      }\n      // otherwise the results must be empty, one or both are exclusive\n      // in opposite directions\n      return 'empty';\n    }\n\n    // bound is before the start, return start\n    return req.start;\n  }\n}\n"],"mappings":";;;;;;;;AAgCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,UAAU;EAC/B,OAAO,SAAS,KAAA,GAAW,4BAA4B;EACvD,KAAKA,SAAS;EACd,KAAKC,SAAS;EACd,KAAKC,cAAc,MAAM,UAAU,EAAE;EACrC,MAAM,UAAU,IAAI;CACtB;CAEA,YAA0B;EACxB,OAAO,KAAKF,OAAO,UAAU;CAC/B;CAEA,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,KAAKG,UAAU,GAAG;EAChC,IAAI,UAAU,SACZ;EAEF,MAAM,QAAQ,KAAKH,OAAO,MAAM;GAAC,GAAG;GAAK;EAAK,CAAC;EAC/C,IAAI,CAAC,IAAI,SAAS;GAChB,OAAO;GACP;EACF;EACA,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,CAAC,KAAKI,iBAAiB,KAAK,GAAG,GACjC;GAEF,MAAM;EACR;CACF;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;CACjB;CAEA,UAAgB;EACd,KAAKL,OAAO,QAAQ;CACtB;CAEA,iBAAiB,KAAmB;EAClC,MAAM,MAAM,KAAKE,YAAY,KAAKD,OAAO,KAAK,GAAG;EACjD,OAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,KAAKA,OAAO;CAC/C;CAEA,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,KAAKG,iBAAiB,GAAG;EAC/D,IAAI,OAAO,OAAsB,GAAiB;GAChD,OAAO,4BACL,QACA,iBACA,KAAKC,SACL,IACF;GACA;EACF;EAIA,IAAI,gBAAgB,OAAO,GAAkB,GAAG,GAC9C,OAAO,KAAKA,QAAQ,KAAK,QAAQ,IAAI;CAEzC;CAEA,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,KAAKJ,OAAO;GACjB,OAAO,KAAKA,OAAO,YAAY,UAAU;EAC3C;EAEA,IAAI,CAAC,IAAI,OAAO;GACd,IAAI,IAAI,SACN;GAEF,OAAO;EACT;EAEA,MAAM,MAAM,KAAKC,YAAY,KAAKD,OAAO,KAAK,IAAI,MAAM,GAAG;EAE3D,IAAI,CAAC,IAAI,SAAS;GAIhB,IAAI,MAAM,GACR,OAAO;GAKT,IAAI,QAAQ,GAAG;IACb,IAAI,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,SAC/C,OAAO;KACL,KAAK,KAAKA,OAAO;KACjB,OAAO;IACT;IAEF,OAAO;GACT;GAEA,OAAO,IAAI;EACb;EAEA,IAAI;EAIJ,IAAI,MAAM,GACR,OAAO;EAGT,IAAI,QAAQ,GAAG;GAGb,IAAI,CAAC,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,MAChD,OAAO;GAIT,OAAO;EACT;EAGA,OAAO,IAAI;CACb;AACF"}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#output","#initialFetch","#rowHiddenFromFetch","#setTakeState","#pushEditChange","#getStateAndConstraint","#pushWithRowHiddenFromFetch"],"sources":["../../../../../../zql/src/ivm/take.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeRemoveChange,\n  type Change,\n  type EditChange,\n} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {compareValues, type Comparator, type Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\nconst MAX_BOUND_KEY = 'maxBound';\n\ntype TakeState = {\n  size: number;\n  bound: Row | undefined;\n};\n\ninterface TakeStorage {\n  get(key: typeof MAX_BOUND_KEY): Row | undefined;\n  get(key: string): TakeState | undefined;\n  set(key: typeof MAX_BOUND_KEY, value: Row): void;\n  set(key: string, value: TakeState): void;\n  del(key: string): void;\n}\n\nexport type PartitionKey = PrimaryKey;\n\n/**\n * The Take operator is for implementing limit queries. It takes the first n\n * nodes of its input as determined by the input’s comparator. It then keeps\n * a *bound* of the last item it has accepted so that it can evaluate whether\n * new incoming pushes should be accepted or rejected.\n *\n * Take can count rows globally or by unique value of some field.\n *\n * Maintains the invariant that its output size is always <= limit, even\n * mid processing of a push.\n */\nexport class Take implements Operator {\n  readonly #input: Input;\n  readonly #storage: TakeStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  // Fetch overlay needed for some split push cases.\n  #rowHiddenFromFetch: Row | undefined;\n\n  #output: Output = throwOutput;\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Take requires sorted input');\n    assertOrderingIncludesPK(sort, input.getSchema().primaryKey);\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as TakeStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (\n      !this.#partitionKey ||\n      (req.constraint &&\n        constraintMatchesPartitionKey(req.constraint, this.#partitionKey))\n    ) {\n      const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n      const takeState = this.#storage.get(takeStateKey);\n      if (!takeState) {\n        yield* this.#initialFetch(req);\n        return;\n      }\n      if (takeState.bound === undefined) {\n        return;\n      }\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {\n          return;\n        }\n        if (\n          this.#rowHiddenFromFetch &&\n          this.getSchema().compareRows(\n            this.#rowHiddenFromFetch,\n            inputNode.row,\n          ) === 0\n        ) {\n          continue;\n        }\n        yield inputNode;\n      }\n      return;\n    }\n    // There is a partition key, but the fetch is not constrained or constrained\n    // on a different key.  Thus we don't have a single take state to bound by.\n    // This currently only happens with nested sub-queries\n    // e.g. issues include issuelabels include label.  We could remove this\n    // case if we added a translation layer (powered by some state) in join.\n    // Specifically we need joinKeyValue => parent constraint key\n    const maxBound = this.#storage.get(MAX_BOUND_KEY);\n    if (maxBound === undefined) {\n      return;\n    }\n    for (const inputNode of this.#input.fetch(req)) {\n      if (inputNode === 'yield') {\n        yield inputNode;\n        continue;\n      }\n      if (this.getSchema().compareRows(inputNode.row, maxBound) > 0) {\n        return;\n      }\n      const takeStateKey = getTakeStateKey(this.#partitionKey, inputNode.row);\n      const takeState = this.#storage.get(takeStateKey);\n      if (\n        takeState?.bound !== undefined &&\n        this.getSchema().compareRows(takeState.bound, inputNode.row) >= 0\n      ) {\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(req.start === undefined, 'Start should be undefined');\n    assert(!req.reverse, 'Reverse should be false');\n\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(takeStateKey) === undefined,\n      'Take state should be undefined',\n    );\n\n    let size = 0;\n    let bound: Row | undefined;\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        bound = inputNode.row;\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#setTakeState(\n          takeStateKey,\n          size,\n          bound,\n          this.#storage.get(MAX_BOUND_KEY),\n        );\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that takeState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  #getStateAndConstraint(row: Row) {\n    const takeStateKey = getTakeStateKey(this.#partitionKey, row);\n    const takeState = this.#storage.get(takeStateKey);\n    let maxBound: Row | undefined;\n    let constraint: Constraint | undefined;\n    if (takeState) {\n      maxBound = this.#storage.get(MAX_BOUND_KEY);\n      constraint =\n        this.#partitionKey &&\n        Object.fromEntries(\n          this.#partitionKey.map(key => [key, row[key]] as const),\n        );\n    }\n\n    return {takeState, takeStateKey, maxBound, constraint} as\n      | {\n          takeState: undefined;\n          takeStateKey: string;\n          maxBound: undefined;\n          constraint: undefined;\n        }\n      | {\n          takeState: TakeState;\n          takeStateKey: string;\n          maxBound: Row | undefined;\n          constraint: Constraint | undefined;\n        };\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const {takeState, takeStateKey, maxBound, constraint} =\n      this.#getStateAndConstraint(change[ChangeIndex.NODE].row);\n    if (!takeState) {\n      return;\n    }\n\n    const {compareRows} = this.getSchema();\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (takeState.size < this.#limit) {\n        this.#setTakeState(\n          takeStateKey,\n          takeState.size + 1,\n          takeState.bound === undefined ||\n            compareRows(takeState.bound, change[ChangeIndex.NODE].row) < 0\n            ? change[ChangeIndex.NODE].row\n            : takeState.bound,\n          maxBound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // size === limit\n      if (\n        takeState.bound === undefined ||\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) >= 0\n      ) {\n        return;\n      }\n      // added row < bound\n      let beforeBoundNode: Node | undefined;\n      let boundNode: Node | undefined;\n      if (this.#limit === 1) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          boundNode = node;\n          break;\n        }\n      } else {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          } else if (boundNode === undefined) {\n            boundNode = node;\n          } else {\n            beforeBoundNode = node;\n            break;\n          }\n        }\n      }\n      assert(\n        boundNode !== undefined,\n        'Take: boundNode must be found during fetch',\n      );\n      const removeChange = makeRemoveChange(boundNode);\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        beforeBoundNode === undefined ||\n          compareRows(change[ChangeIndex.NODE].row, beforeBoundNode.row) > 0\n          ? change[ChangeIndex.NODE].row\n          : beforeBoundNode.row,\n        maxBound,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        removeChange,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      if (takeState.bound === undefined) {\n        // change is after bound\n        return;\n      }\n      const compToBound = compareRows(\n        change[ChangeIndex.NODE].row,\n        takeState.bound,\n      );\n      if (compToBound > 0) {\n        // change is after bound\n        return;\n      }\n      let beforeBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        beforeBoundNode = node;\n        break;\n      }\n\n      let newBound: {node: Node; push: boolean} | undefined;\n      if (beforeBoundNode) {\n        const push = compareRows(beforeBoundNode.row, takeState.bound) > 0;\n        newBound = {\n          node: beforeBoundNode,\n          push,\n        };\n      }\n      if (!newBound?.push) {\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'at',\n          },\n          constraint,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          const push = compareRows(node.row, takeState.bound) > 0;\n          newBound = {\n            node,\n            push,\n          };\n          if (push) {\n            break;\n          }\n        }\n      }\n\n      if (newBound?.push) {\n        yield* this.#output.push(change, this);\n        this.#setTakeState(\n          takeStateKey,\n          takeState.size,\n          newBound.node.row,\n          maxBound,\n        );\n        yield* this.#output.push(makeAddChange(newBound.node), this);\n        return;\n      }\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size - 1,\n        newBound?.node.row,\n        maxBound,\n      );\n      yield* this.#output.push(change, this);\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      // A 'child' change should be pushed to output if its row\n      // is <= bound.\n      if (\n        takeState.bound &&\n        compareRows(change[ChangeIndex.NODE].row, takeState.bound) <= 0\n      ) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n\n    const {takeState, takeStateKey, maxBound, constraint} =\n      this.#getStateAndConstraint(change[ChangeIndex.OLD_NODE].row);\n    if (!takeState) {\n      return;\n    }\n\n    assert(takeState.bound, 'Bound should be set');\n    const {compareRows} = this.getSchema();\n    const oldCmp = compareRows(\n      change[ChangeIndex.OLD_NODE].row,\n      takeState.bound,\n    );\n    const newCmp = compareRows(change[ChangeIndex.NODE].row, takeState.bound);\n\n    const that = this;\n    const replaceBoundAndForwardChange = function* () {\n      that.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        change[ChangeIndex.NODE].row,\n        maxBound,\n      );\n      yield* that.#output.push(change, that);\n    };\n\n    // The bounds row was changed.\n    if (oldCmp === 0) {\n      // The new row is the new bound.\n      if (newCmp === 0) {\n        // no need to update the state since we are keeping the bounds\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      if (newCmp < 0) {\n        if (this.#limit === 1) {\n          yield* replaceBoundAndForwardChange();\n          return;\n        }\n\n        // New row will be in the result but it might not be the bounds any\n        // more. We need to find the row before the bounds to determine the new\n        // bounds.\n\n        let beforeBoundNode: Node | undefined;\n        for (const node of this.#input.fetch({\n          start: {\n            row: takeState.bound,\n            basis: 'after',\n          },\n          constraint,\n          reverse: true,\n        })) {\n          if (node === 'yield') {\n            yield node;\n            continue;\n          }\n          beforeBoundNode = node;\n          break;\n        }\n        assert(\n          beforeBoundNode !== undefined,\n          'Take: beforeBoundNode must be found during fetch',\n        );\n\n        this.#setTakeState(\n          takeStateKey,\n          takeState.size,\n          beforeBoundNode.row,\n          maxBound,\n        );\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n      // Find the first item at the old bounds. This will be the new bounds.\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        newBoundNode = node;\n        break;\n      }\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // The next row is the new row. We can replace the bounds and keep the\n      // edit change.\n      if (compareRows(newBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      // The new row is now outside the bounds, so we need to remove the old\n      // row and add the new bounds row.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        newBoundNode.row,\n        maxBound,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        newBoundNode.row,\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n      );\n      yield* this.#output.push(makeAddChange(newBoundNode), this);\n      return;\n    }\n\n    if (oldCmp > 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new outside of bounds\n      if (newCmp > 0) {\n        return;\n      }\n\n      // old was outside, new is inside. Pushing out the old bounds\n      assert(newCmp < 0, 'New comparison must be less than 0');\n\n      let oldBoundNode: Node | undefined;\n      let newBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'at',\n        },\n        constraint,\n        reverse: true,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        } else if (oldBoundNode === undefined) {\n          oldBoundNode = node;\n        } else {\n          newBoundNode = node;\n          break;\n        }\n      }\n      assert(\n        oldBoundNode !== undefined,\n        'Take: oldBoundNode must be found during fetch',\n      );\n      assert(\n        newBoundNode !== undefined,\n        'Take: newBoundNode must be found during fetch',\n      );\n\n      // Remove before add to maintain invariant that\n      // output size <= limit.\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        newBoundNode.row,\n        maxBound,\n      );\n      yield* this.#pushWithRowHiddenFromFetch(\n        change[ChangeIndex.NODE].row,\n        makeRemoveChange(oldBoundNode),\n      );\n      yield* this.#output.push(makeAddChange(change[ChangeIndex.NODE]), this);\n\n      return;\n    }\n\n    if (oldCmp < 0) {\n      assert(newCmp !== 0, 'Invalid state. Row has duplicate primary key');\n\n      // Both old and new inside of bounds\n      if (newCmp < 0) {\n        yield* this.#output.push(change, this);\n        return;\n      }\n\n      // old was inside, new is larger than old bound\n\n      assert(newCmp > 0, 'New comparison must be greater than 0');\n\n      // at this point we need to find the row after the bound and use that or\n      // the newRow as the new bound.\n      let afterBoundNode: Node | undefined;\n      for (const node of this.#input.fetch({\n        start: {\n          row: takeState.bound,\n          basis: 'after',\n        },\n        constraint,\n      })) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        afterBoundNode = node;\n        break;\n      }\n      assert(\n        afterBoundNode !== undefined,\n        'Take: afterBoundNode must be found during fetch',\n      );\n\n      // The new row is the new bound. Use an edit change.\n      if (compareRows(afterBoundNode.row, change[ChangeIndex.NODE].row) === 0) {\n        yield* replaceBoundAndForwardChange();\n        return;\n      }\n\n      yield* this.#output.push(\n        makeRemoveChange(change[ChangeIndex.OLD_NODE]),\n        this,\n      );\n      this.#setTakeState(\n        takeStateKey,\n        takeState.size,\n        afterBoundNode.row,\n        maxBound,\n      );\n      yield* this.#output.push(makeAddChange(afterBoundNode), this);\n      return;\n    }\n\n    unreachable();\n  }\n\n  *#pushWithRowHiddenFromFetch(row: Row, change: Change) {\n    this.#rowHiddenFromFetch = row;\n    try {\n      yield* this.#output.push(change, this);\n    } finally {\n      this.#rowHiddenFromFetch = undefined;\n    }\n  }\n\n  #setTakeState(\n    takeStateKey: string,\n    size: number,\n    bound: Row | undefined,\n    maxBound: Row | undefined,\n  ) {\n    this.#storage.set(takeStateKey, {\n      size,\n      bound,\n    });\n    if (\n      bound !== undefined &&\n      (maxBound === undefined ||\n        this.getSchema().compareRows(bound, maxBound) > 0)\n    ) {\n      this.#storage.set(MAX_BOUND_KEY, bound);\n    }\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n}\n\nfunction getTakeStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  // The order must be consistent. We always use the order as defined by the\n  // partition key.\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['take', ...partitionValues]);\n}\n\nexport function constraintMatchesPartitionKey(\n  constraint: Constraint | undefined,\n  partitionKey: PartitionKey | undefined,\n): boolean {\n  if (constraint === undefined || partitionKey === undefined) {\n    return constraint === partitionKey;\n  }\n  if (partitionKey.length !== Object.keys(constraint).length) {\n    return false;\n  }\n  for (const key of partitionKey) {\n    if (!hasOwn(constraint, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function makePartitionKeyComparator(\n  partitionKey: PartitionKey,\n): Comparator {\n  return (a, b) => {\n    for (const key of partitionKey) {\n      const cmp = compareValues(a[key], b[key]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return 0;\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,165 @@
+import { assert } from "../../../shared/src/asserts.js";
+import { throwOutput } from "./operator.js";
+import { first } from "./stream.js";
+import { makeAddEmptyRelationships, mergeRelationships, pushAccumulatedChanges } from "./push-accumulated.js";
+//#region ../zql/src/ivm/union-fan-in.ts
+var UnionFanIn = class {
+	#inputs;
+	#schema;
+	#fanOutPushStarted = false;
+	#output = throwOutput;
+	#accumulatedPushes = [];
+	constructor(fanOut, inputs) {
+		this.#inputs = inputs;
+		const fanOutSchema = fanOut.getSchema();
+		fanOut.setFanIn(this);
+		assert(fanOutSchema.sort !== void 0, "UnionFanIn requires sorted input");
+		const schema = {
+			tableName: fanOutSchema.tableName,
+			columns: fanOutSchema.columns,
+			primaryKey: fanOutSchema.primaryKey,
+			relationships: { ...fanOutSchema.relationships },
+			isHidden: fanOutSchema.isHidden,
+			system: fanOutSchema.system,
+			compareRows: fanOutSchema.compareRows,
+			sort: fanOutSchema.sort
+		};
+		const relationshipsFromBranches = /* @__PURE__ */ new Set();
+		for (const input of inputs) {
+			const inputSchema = input.getSchema();
+			assert(schema.tableName === inputSchema.tableName, `Table name mismatch in union fan-in: ${schema.tableName} !== ${inputSchema.tableName}`);
+			assert(schema.primaryKey === inputSchema.primaryKey, `Primary key mismatch in union fan-in`);
+			assert(schema.system === inputSchema.system, `System mismatch in union fan-in: ${schema.system} !== ${inputSchema.system}`);
+			assert(schema.compareRows === inputSchema.compareRows, `compareRows mismatch in union fan-in`);
+			assert(schema.sort === inputSchema.sort, `Sort mismatch in union fan-in`);
+			for (const [relName, relSchema] of Object.entries(inputSchema.relationships)) {
+				if (relName in fanOutSchema.relationships) continue;
+				assert(!relationshipsFromBranches.has(relName), `Relationship ${relName} exists in multiple upstream inputs to union fan-in`);
+				schema.relationships[relName] = relSchema;
+				relationshipsFromBranches.add(relName);
+			}
+			input.setOutput(this);
+		}
+		this.#schema = schema;
+		this.#inputs = inputs;
+	}
+	destroy() {
+		for (const input of this.#inputs) input.destroy();
+	}
+	fetch(req) {
+		const iterables = this.#inputs.map((input) => input.fetch(req));
+		const compareRows = this.#schema.compareRows;
+		return mergeFetches(iterables, req.reverse ? (l, r) => compareRows(r.row, l.row) : (l, r) => compareRows(l.row, r.row));
+	}
+	getSchema() {
+		return this.#schema;
+	}
+	*push(change, pusher) {
+		if (!this.#fanOutPushStarted) yield* this.#pushInternalChange(change, pusher);
+		else this.#accumulatedPushes.push(change);
+	}
+	/**
+	* An internal change means that a change was received inside the fan-out/fan-in sub-graph.
+	*
+	* These changes always come from children of a flip-join as no other push generating operators
+	* currently exist between union-fan-in and union-fan-out. All other pushes
+	* enter into union-fan-out before reaching union-fan-in.
+	*
+	* - normal joins for `exists` come before `union-fan-out`
+	* - joins for `related` come after `union-fan-out`
+	* - take comes after `union-fan-out`
+	*
+	* The algorithm for deciding whether or not to forward a push that came from inside the ufo/ufi sub-graph:
+	* 1. If the change is a `child` change we can forward it. This is because all child branches in the ufo/ufi sub-graph are unique.
+	* 2. If the change is `add` we can forward it iff no `fetches` for the row return any results.
+	*    If another branch has it, the add was already emitted in the past.
+	* 3. If the change is `remove` we can forward it iff no `fetches` for the row return any results.
+	*    If no other branches have the change, the remove can be sent as the value is no longer present.
+	*    If other branches have it, the last branch the processes the remove will send the remove.
+	* 4. Edits will always come through as child changes as flip join will flip them into children.
+	*    An edit that would result in a remove or add will have been split into an add/remove pair rather than being an edit.
+	*/
+	*#pushInternalChange(change, pusher) {
+		if (change[0] === 3) {
+			yield* this.#output.push(change, this);
+			return;
+		}
+		assert(change[0] === 0 || change[0] === 1, () => `UnionFanIn: expected add or remove change type, got ${change[0]}`);
+		let hadMatch = false;
+		for (const input of this.#inputs) {
+			if (input === pusher) {
+				hadMatch = true;
+				continue;
+			}
+			const constraint = {};
+			for (const key of this.#schema.primaryKey) constraint[key] = change[1].row[key];
+			if (first(input.fetch({ constraint })) !== void 0) return;
+		}
+		assert(hadMatch, "Pusher was not one of the inputs to union-fan-in!");
+		yield* this.#output.push(change, this);
+	}
+	fanOutStartedPushing() {
+		assert(this.#fanOutPushStarted === false, "UnionFanIn: fanOutStartedPushing called while already pushing");
+		this.#fanOutPushStarted = true;
+	}
+	*fanOutDonePushing(fanOutChangeType) {
+		assert(this.#fanOutPushStarted, "UnionFanIn: fanOutDonePushing called without fanOutStartedPushing");
+		this.#fanOutPushStarted = false;
+		if (this.#inputs.length === 0) return;
+		if (this.#accumulatedPushes.length === 0) return;
+		yield* pushAccumulatedChanges(this.#accumulatedPushes, this.#output, this, fanOutChangeType, mergeRelationships, makeAddEmptyRelationships(this.#schema));
+	}
+	setOutput(output) {
+		this.#output = output;
+	}
+};
+function* mergeFetches(fetches, comparator) {
+	const iterators = fetches.map((i) => i[Symbol.iterator]());
+	let threw = false;
+	try {
+		const current = [];
+		let lastNodeYielded;
+		for (let i = 0; i < iterators.length; i++) {
+			const iter = iterators[i];
+			let result = iter.next();
+			while (!result.done && result.value === "yield") {
+				yield result.value;
+				result = iter.next();
+			}
+			current[i] = result.done ? null : result.value;
+		}
+		while (current.some((c) => c !== null)) {
+			const min = current.reduce((acc, c, i) => {
+				if (c === null) return acc;
+				if (acc === void 0 || comparator(c, acc[0]) < 0) return [c, i];
+				return acc;
+			}, void 0);
+			assert(min !== void 0, "min is undefined");
+			const [minNode, minIndex] = min;
+			const iter = iterators[minIndex];
+			let result = iter.next();
+			while (!result.done && result.value === "yield") {
+				yield result.value;
+				result = iter.next();
+			}
+			current[minIndex] = result.done ? null : result.value;
+			if (lastNodeYielded !== void 0 && comparator(lastNodeYielded, minNode) === 0) continue;
+			lastNodeYielded = minNode;
+			yield minNode;
+		}
+	} catch (e) {
+		threw = true;
+		for (const iter of iterators) try {
+			iter.throw?.(e);
+		} catch (_cleanupError) {}
+		throw e;
+	} finally {
+		if (!threw) for (const iter of iterators) try {
+			iter.return?.();
+		} catch (_cleanupError) {}
+	}
+}
+//#endregion
+export { UnionFanIn };
+
+//# sourceMappingURL=union-fan-in.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"union-fan-in.js","names":["#inputs","#schema","#fanOutPushStarted","#pushInternalChange","#accumulatedPushes","#output"],"sources":["../../../../../../zql/src/ivm/union-fan-in.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {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 {\n  makeAddEmptyRelationships,\n  mergeRelationships,\n  pushAccumulatedChanges,\n} from './push-accumulated.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {first, type Stream} from './stream.ts';\nimport type {UnionFanOut} from './union-fan-out.ts';\n\nexport class UnionFanIn implements Operator {\n  readonly #inputs: readonly Input[];\n  readonly #schema: SourceSchema;\n  #fanOutPushStarted: boolean = false;\n  #output: Output = throwOutput;\n  #accumulatedPushes: Change[] = [];\n\n  constructor(fanOut: UnionFanOut, inputs: Input[]) {\n    this.#inputs = inputs;\n    const fanOutSchema = fanOut.getSchema();\n    fanOut.setFanIn(this);\n    assert(fanOutSchema.sort !== undefined, 'UnionFanIn requires sorted input');\n\n    const schema: Writable<SourceSchema> = {\n      tableName: fanOutSchema.tableName,\n      columns: fanOutSchema.columns,\n      primaryKey: fanOutSchema.primaryKey,\n      relationships: {\n        ...fanOutSchema.relationships,\n      },\n      isHidden: fanOutSchema.isHidden,\n      system: fanOutSchema.system,\n      compareRows: fanOutSchema.compareRows,\n      sort: fanOutSchema.sort,\n    };\n\n    // now go through inputs and merge relationships\n    const relationshipsFromBranches: Set<string> = new Set();\n    for (const input of inputs) {\n      const inputSchema = input.getSchema();\n      assert(\n        schema.tableName === inputSchema.tableName,\n        `Table name mismatch in union fan-in: ${schema.tableName} !== ${inputSchema.tableName}`,\n      );\n      assert(\n        schema.primaryKey === inputSchema.primaryKey,\n        `Primary key mismatch in union fan-in`,\n      );\n      assert(\n        schema.system === inputSchema.system,\n        `System mismatch in union fan-in: ${schema.system} !== ${inputSchema.system}`,\n      );\n      assert(\n        schema.compareRows === inputSchema.compareRows,\n        `compareRows mismatch in union fan-in`,\n      );\n      assert(schema.sort === inputSchema.sort, `Sort mismatch in union fan-in`);\n\n      for (const [relName, relSchema] of Object.entries(\n        inputSchema.relationships,\n      )) {\n        if (relName in fanOutSchema.relationships) {\n          continue;\n        }\n\n        // All branches will have unique relationship names except for relationships\n        // that come in from `fanOut`.\n        assert(\n          !relationshipsFromBranches.has(relName),\n          `Relationship ${relName} exists in multiple upstream inputs to union fan-in`,\n        );\n        schema.relationships[relName] = relSchema;\n        relationshipsFromBranches.add(relName);\n      }\n\n      input.setOutput(this);\n    }\n\n    this.#schema = schema;\n    this.#inputs = inputs;\n  }\n\n  destroy(): void {\n    for (const input of this.#inputs) {\n      input.destroy();\n    }\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const iterables = this.#inputs.map(input => input.fetch(req));\n    const compareRows = this.#schema.compareRows;\n    const compare = req.reverse\n      ? (l: Node, r: Node) => compareRows(r.row, l.row)\n      : (l: Node, r: Node) => compareRows(l.row, r.row);\n    return mergeFetches(iterables, compare);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *push(change: Change, pusher: InputBase): Stream<'yield'> {\n    if (!this.#fanOutPushStarted) {\n      yield* this.#pushInternalChange(change, pusher);\n    } else {\n      this.#accumulatedPushes.push(change);\n    }\n  }\n\n  /**\n   * An internal change means that a change was received inside the fan-out/fan-in sub-graph.\n   *\n   * These changes always come from children of a flip-join as no other push generating operators\n   * currently exist between union-fan-in and union-fan-out. All other pushes\n   * enter into union-fan-out before reaching union-fan-in.\n   *\n   * - normal joins for `exists` come before `union-fan-out`\n   * - joins for `related` come after `union-fan-out`\n   * - take comes after `union-fan-out`\n   *\n   * The algorithm for deciding whether or not to forward a push that came from inside the ufo/ufi sub-graph:\n   * 1. If the change is a `child` change we can forward it. This is because all child branches in the ufo/ufi sub-graph are unique.\n   * 2. If the change is `add` we can forward it iff no `fetches` for the row return any results.\n   *    If another branch has it, the add was already emitted in the past.\n   * 3. If the change is `remove` we can forward it iff no `fetches` for the row return any results.\n   *    If no other branches have the change, the remove can be sent as the value is no longer present.\n   *    If other branches have it, the last branch the processes the remove will send the remove.\n   * 4. Edits will always come through as child changes as flip join will flip them into children.\n   *    An edit that would result in a remove or add will have been split into an add/remove pair rather than being an edit.\n   */\n  *#pushInternalChange(change: Change, pusher: InputBase): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      yield* this.#output.push(change, this);\n      return;\n    }\n\n    assert(\n      change[ChangeIndex.TYPE] === ChangeType.ADD ||\n        change[ChangeIndex.TYPE] === ChangeType.REMOVE,\n      () =>\n        `UnionFanIn: expected add or remove change type, got ${change[ChangeIndex.TYPE]}`,\n    );\n\n    let hadMatch = false;\n    for (const input of this.#inputs) {\n      if (input === pusher) {\n        hadMatch = true;\n        continue;\n      }\n\n      const constraint: Writable<Constraint> = {};\n      for (const key of this.#schema.primaryKey) {\n        constraint[key] = change[ChangeIndex.NODE].row[key];\n      }\n      const fetchResult = input.fetch({\n        constraint,\n      });\n\n      if (first(fetchResult) !== undefined) {\n        // Another branch has the row, so the add/remove is not needed.\n        return;\n      }\n    }\n\n    assert(hadMatch, 'Pusher was not one of the inputs to union-fan-in!');\n\n    // No other branches have the row, so we can push the change.\n    yield* this.#output.push(change, this);\n  }\n\n  fanOutStartedPushing() {\n    assert(\n      this.#fanOutPushStarted === false,\n      'UnionFanIn: fanOutStartedPushing called while already pushing',\n    );\n    this.#fanOutPushStarted = true;\n  }\n\n  *fanOutDonePushing(fanOutChangeType: ChangeType): Stream<'yield'> {\n    assert(\n      this.#fanOutPushStarted,\n      'UnionFanIn: fanOutDonePushing called without fanOutStartedPushing',\n    );\n    this.#fanOutPushStarted = false;\n    if (this.#inputs.length === 0) {\n      return;\n    }\n\n    if (this.#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    yield* pushAccumulatedChanges(\n      this.#accumulatedPushes,\n      this.#output,\n      this,\n      fanOutChangeType,\n      mergeRelationships,\n      makeAddEmptyRelationships(this.#schema),\n    );\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n}\n\nexport function* mergeFetches(\n  fetches: Iterable<Node | 'yield'>[],\n  comparator: (l: Node, r: Node) => number,\n): IterableIterator<Node | 'yield'> {\n  const iterators = fetches.map(i => i[Symbol.iterator]());\n  let threw = false;\n  try {\n    const current: (Node | null)[] = [];\n    let lastNodeYielded: Node | undefined;\n    for (let i = 0; i < iterators.length; i++) {\n      const iter = iterators[i];\n      let result = iter.next();\n      // yield yields when initializing\n      while (!result.done && result.value === 'yield') {\n        yield result.value;\n        result = iter.next();\n      }\n      current[i] = result.done ? null : (result.value as Node);\n    }\n    while (current.some(c => c !== null)) {\n      const min = current.reduce(\n        (acc: [Node, number] | undefined, c, i): [Node, number] | undefined => {\n          if (c === null) {\n            return acc;\n          }\n          if (acc === undefined || comparator(c, acc[0]) < 0) {\n            return [c, i];\n          }\n          return acc;\n        },\n        undefined,\n      );\n\n      assert(min !== undefined, 'min is undefined');\n      const [minNode, minIndex] = min;\n      const iter = iterators[minIndex];\n      let result = iter.next();\n      while (!result.done && result.value === 'yield') {\n        yield result.value;\n        result = iter.next();\n      }\n      current[minIndex] = result.done ? null : (result.value as Node);\n      if (\n        lastNodeYielded !== undefined &&\n        comparator(lastNodeYielded, minNode) === 0\n      ) {\n        continue;\n      }\n      lastNodeYielded = minNode;\n      yield minNode;\n    }\n  } catch (e) {\n    threw = true;\n    for (const iter of iterators) {\n      try {\n        iter.throw?.(e);\n      } catch (_cleanupError) {\n        // error in the iter.throw cleanup,\n        // catch so other iterators are cleaned up\n      }\n    }\n    throw e;\n  } finally {\n    if (!threw) {\n      for (const iter of iterators) {\n        try {\n          iter.return?.();\n        } catch (_cleanupError) {\n          // error in the iter.return cleanup,\n          // catch so other iterators are cleaned up\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;;;AAwBA,IAAa,aAAb,MAA4C;CAC1C;CACA;CACA,qBAA8B;CAC9B,UAAkB;CAClB,qBAA+B,CAAC;CAEhC,YAAY,QAAqB,QAAiB;EAChD,KAAKA,UAAU;EACf,MAAM,eAAe,OAAO,UAAU;EACtC,OAAO,SAAS,IAAI;EACpB,OAAO,aAAa,SAAS,KAAA,GAAW,kCAAkC;EAE1E,MAAM,SAAiC;GACrC,WAAW,aAAa;GACxB,SAAS,aAAa;GACtB,YAAY,aAAa;GACzB,eAAe,EACb,GAAG,aAAa,cAClB;GACA,UAAU,aAAa;GACvB,QAAQ,aAAa;GACrB,aAAa,aAAa;GAC1B,MAAM,aAAa;EACrB;EAGA,MAAM,4CAAyC,IAAI,IAAI;EACvD,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,cAAc,MAAM,UAAU;GACpC,OACE,OAAO,cAAc,YAAY,WACjC,wCAAwC,OAAO,UAAU,OAAO,YAAY,WAC9E;GACA,OACE,OAAO,eAAe,YAAY,YAClC,sCACF;GACA,OACE,OAAO,WAAW,YAAY,QAC9B,oCAAoC,OAAO,OAAO,OAAO,YAAY,QACvE;GACA,OACE,OAAO,gBAAgB,YAAY,aACnC,sCACF;GACA,OAAO,OAAO,SAAS,YAAY,MAAM,+BAA+B;GAExE,KAAK,MAAM,CAAC,SAAS,cAAc,OAAO,QACxC,YAAY,aACd,GAAG;IACD,IAAI,WAAW,aAAa,eAC1B;IAKF,OACE,CAAC,0BAA0B,IAAI,OAAO,GACtC,gBAAgB,QAAQ,oDAC1B;IACA,OAAO,cAAc,WAAW;IAChC,0BAA0B,IAAI,OAAO;GACvC;GAEA,MAAM,UAAU,IAAI;EACtB;EAEA,KAAKC,UAAU;EACf,KAAKD,UAAU;CACjB;CAEA,UAAgB;EACd,KAAK,MAAM,SAAS,KAAKA,SACvB,MAAM,QAAQ;CAElB;CAEA,MAAM,KAA2C;EAC/C,MAAM,YAAY,KAAKA,QAAQ,KAAI,UAAS,MAAM,MAAM,GAAG,CAAC;EAC5D,MAAM,cAAc,KAAKC,QAAQ;EAIjC,OAAO,aAAa,WAHJ,IAAI,WACf,GAAS,MAAY,YAAY,EAAE,KAAK,EAAE,GAAG,KAC7C,GAAS,MAAY,YAAY,EAAE,KAAK,EAAE,GAAG,CACZ;CACxC;CAEA,YAA0B;EACxB,OAAO,KAAKA;CACd;CAEA,CAAC,KAAK,QAAgB,QAAoC;EACxD,IAAI,CAAC,KAAKC,oBACR,OAAO,KAAKC,oBAAoB,QAAQ,MAAM;OAE9C,KAAKC,mBAAmB,KAAK,MAAM;CAEvC;;;;;;;;;;;;;;;;;;;;;;CAuBA,CAACD,oBAAoB,QAAgB,QAAoC;EACvE,IAAI,OAAO,OAAsB,GAAkB;GACjD,OAAO,KAAKE,QAAQ,KAAK,QAAQ,IAAI;GACrC;EACF;EAEA,OACE,OAAO,OAAsB,KAC3B,OAAO,OAAsB,SAE7B,uDAAuD,OAAO,IAClE;EAEA,IAAI,WAAW;EACf,KAAK,MAAM,SAAS,KAAKL,SAAS;GAChC,IAAI,UAAU,QAAQ;IACpB,WAAW;IACX;GACF;GAEA,MAAM,aAAmC,CAAC;GAC1C,KAAK,MAAM,OAAO,KAAKC,QAAQ,YAC7B,WAAW,OAAO,OAAO,GAAkB,IAAI;GAMjD,IAAI,MAJgB,MAAM,MAAM,EAC9B,WACF,CAEU,CAAW,MAAM,KAAA,GAEzB;EAEJ;EAEA,OAAO,UAAU,mDAAmD;EAGpE,OAAO,KAAKI,QAAQ,KAAK,QAAQ,IAAI;CACvC;CAEA,uBAAuB;EACrB,OACE,KAAKH,uBAAuB,OAC5B,+DACF;EACA,KAAKA,qBAAqB;CAC5B;CAEA,CAAC,kBAAkB,kBAA+C;EAChE,OACE,KAAKA,oBACL,mEACF;EACA,KAAKA,qBAAqB;EAC1B,IAAI,KAAKF,QAAQ,WAAW,GAC1B;EAGF,IAAI,KAAKI,mBAAmB,WAAW,GAGrC;EAGF,OAAO,uBACL,KAAKA,oBACL,KAAKC,SACL,MACA,kBACA,oBACA,0BAA0B,KAAKJ,OAAO,CACxC;CACF;CAEA,UAAU,QAAsB;EAC9B,KAAKI,UAAU;CACjB;AACF;AAEA,UAAiB,aACf,SACA,YACkC;CAClC,MAAM,YAAY,QAAQ,KAAI,MAAK,EAAE,OAAO,UAAU,CAAC;CACvD,IAAI,QAAQ;CACZ,IAAI;EACF,MAAM,UAA2B,CAAC;EAClC,IAAI;EACJ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,OAAO,UAAU;GACvB,IAAI,SAAS,KAAK,KAAK;GAEvB,OAAO,CAAC,OAAO,QAAQ,OAAO,UAAU,SAAS;IAC/C,MAAM,OAAO;IACb,SAAS,KAAK,KAAK;GACrB;GACA,QAAQ,KAAK,OAAO,OAAO,OAAQ,OAAO;EAC5C;EACA,OAAO,QAAQ,MAAK,MAAK,MAAM,IAAI,GAAG;GACpC,MAAM,MAAM,QAAQ,QACjB,KAAiC,GAAG,MAAkC;IACrE,IAAI,MAAM,MACR,OAAO;IAET,IAAI,QAAQ,KAAA,KAAa,WAAW,GAAG,IAAI,EAAE,IAAI,GAC/C,OAAO,CAAC,GAAG,CAAC;IAEd,OAAO;GACT,GACA,KAAA,CACF;GAEA,OAAO,QAAQ,KAAA,GAAW,kBAAkB;GAC5C,MAAM,CAAC,SAAS,YAAY;GAC5B,MAAM,OAAO,UAAU;GACvB,IAAI,SAAS,KAAK,KAAK;GACvB,OAAO,CAAC,OAAO,QAAQ,OAAO,UAAU,SAAS;IAC/C,MAAM,OAAO;IACb,SAAS,KAAK,KAAK;GACrB;GACA,QAAQ,YAAY,OAAO,OAAO,OAAQ,OAAO;GACjD,IACE,oBAAoB,KAAA,KACpB,WAAW,iBAAiB,OAAO,MAAM,GAEzC;GAEF,kBAAkB;GAClB,MAAM;EACR;CACF,SAAS,GAAG;EACV,QAAQ;EACR,KAAK,MAAM,QAAQ,WACjB,IAAI;GACF,KAAK,QAAQ,CAAC;EAChB,SAAS,eAAe,CAGxB;EAEF,MAAM;CACR,UAAU;EACR,IAAI,CAAC,OACH,KAAK,MAAM,QAAQ,WACjB,IAAI;GACF,KAAK,SAAS;EAChB,SAAS,eAAe,CAGxB;CAGN;AACF"}

package/out/packages/zql/src/ivm/union-fan-out.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-fan-out.js","names":["#input","#outputs","#unionFanIn","#destroyCount"],"sources":["../../../../../../zql/src/ivm/union-fan-out.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport type {Change} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {FetchRequest, Input, Operator, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\nimport type {UnionFanIn} from './union-fan-in.ts';\n\nexport class UnionFanOut implements Operator {\n  #destroyCount: number = 0;\n  #unionFanIn?: UnionFanIn;\n  readonly #input: Input;\n  readonly #outputs: Output[] = [];\n\n  constructor(input: Input) {\n    this.#input = input;\n    input.setOutput(this);\n  }\n\n  setFanIn(fanIn: UnionFanIn) {\n    assert(!this.#unionFanIn, 'FanIn already set for this FanOut');\n    this.#unionFanIn = fanIn;\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    must(this.#unionFanIn).fanOutStartedPushing();\n    for (const output of this.#outputs) {\n      yield* output.push(change, this);\n    }\n    yield* must(this.#unionFanIn).fanOutDonePushing(change[ChangeIndex.TYPE]);\n  }\n\n  setOutput(output: Output): void {\n    this.#outputs.push(output);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input.fetch(req);\n  }\n\n  destroy(): void {\n    if (this.#destroyCount < this.#outputs.length) {\n      ++this.#destroyCount;\n      if (this.#destroyCount === this.#outputs.length) {\n        this.#input.destroy();\n      }\n    } else {\n      throw new Error('FanOut already destroyed once for each output');\n    }\n  }\n}\n"],"mappings":";;;AAUA,IAAa,cAAb,MAA6C;CAC3C,gBAAwB;CACxB;CACA;CACA,WAA8B,CAAC;CAE/B,YAAY,OAAc;EACxB,KAAKA,SAAS;EACd,MAAM,UAAU,IAAI;CACtB;CAEA,SAAS,OAAmB;EAC1B,OAAO,CAAC,KAAKE,aAAa,mCAAmC;EAC7D,KAAKA,cAAc;CACrB;CAEA,CAAC,KAAK,QAAiC;EACrC,KAAK,KAAKA,WAAW,EAAE,qBAAqB;EAC5C,KAAK,MAAM,UAAU,KAAKD,UACxB,OAAO,OAAO,KAAK,QAAQ,IAAI;EAEjC,OAAO,KAAK,KAAKC,WAAW,EAAE,kBAAkB,OAAO,EAAiB;CAC1E;CAEA,UAAU,QAAsB;EAC9B,KAAKD,SAAS,KAAK,MAAM;CAC3B;CAEA,YAA0B;EACxB,OAAO,KAAKD,OAAO,UAAU;CAC/B;CAEA,MAAM,KAA2C;EAC/C,OAAO,KAAKA,OAAO,MAAM,GAAG;CAC9B;CAEA,UAAgB;EACd,IAAI,KAAKG,gBAAgB,KAAKF,SAAS,QAAQ;GAC7C,EAAE,KAAKE;GACP,IAAI,KAAKA,kBAAkB,KAAKF,SAAS,QACvC,KAAKD,OAAO,QAAQ;EAExB,OACE,MAAM,IAAI,MAAM,+CAA+C;CAEnE;AACF"}

package/out/packages/zql/src/ivm/view-apply-change.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-apply-change.js","names":[],"sources":["../../../../../../zql/src/ivm/view-apply-change.ts"],"sourcesContent":["import {\n  assert,\n  assertArray,\n  assertNumber,\n  unreachable,\n} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {type Comparator, type Node} from './data.ts';\nimport {skipYields} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Entry, Format} from './view.ts';\n\nexport const refCountSymbol = Symbol('rc');\nexport const idSymbol = Symbol('id');\n\ntype MetaEntry = Writable<Entry> & {\n  [refCountSymbol]: number;\n  [idSymbol]?: string | undefined;\n};\ntype MetaEntryList = MetaEntry[];\n\n/**\n * `applyChange` does not consume the `relationships` of `ChildChange#node`,\n * `EditChange#node` and `EditChange#oldNode`.  The `ViewChange` type\n * documents and enforces this via the type system.\n */\nexport type ViewChange =\n  | AddViewChange\n  | RemoveViewChange\n  | ChildViewChange\n  | EditViewChange;\n\nexport type RowOnlyNode = {row: Row};\n\nexport type AddViewChange = {\n  type: 'add';\n  node: Node;\n};\n\nexport type RemoveViewChange = {\n  type: 'remove';\n  node: Node;\n};\n\ntype ChildViewChange = {\n  type: 'child';\n  node: RowOnlyNode;\n  child: {\n    relationshipName: string;\n    change: ViewChange;\n  };\n};\n\ntype EditViewChange = {\n  type: 'edit';\n  node: RowOnlyNode;\n  oldNode: RowOnlyNode;\n};\n\n/**\n * This is a subset of WeakMap but restricted to what we need.\n * @deprecated Not used anymore. This will be removed in the future.\n */\nexport interface RefCountMap {\n  get(entry: Entry): number | undefined;\n  set(entry: Entry, refCount: number): void;\n  delete(entry: Entry): boolean;\n}\n\nexport function applyChange(\n  parentEntry: Entry,\n  change: ViewChange,\n  schema: SourceSchema,\n  relationship: string,\n  format: Format,\n  withIDs = false,\n): void {\n  if (schema.isHidden) {\n    switch (change.type) {\n      case 'add':\n      case 'remove':\n        for (const [relationship, children] of Object.entries(\n          change.node.relationships,\n        )) {\n          const childSchema = must(schema.relationships[relationship]);\n          for (const node of skipYields(children())) {\n            applyChange(\n              parentEntry,\n              {type: change.type, node},\n              childSchema,\n              relationship,\n              format,\n              withIDs,\n            );\n          }\n        }\n        return;\n      case 'edit':\n        // If hidden at this level it means that the hidden row was changed. If\n        // the row was changed in such a way that it would change the\n        // relationships then the edit would have been split into remove and\n        // add.\n        return;\n      case 'child': {\n        const childSchema = must(\n          schema.relationships[change.child.relationshipName],\n        );\n        applyChange(\n          parentEntry,\n          change.child.change,\n          childSchema,\n          relationship,\n          format,\n          withIDs,\n        );\n        return;\n      }\n      default:\n        unreachable(change);\n    }\n  }\n\n  const {singular, relationships: childFormats} = format;\n  switch (change.type) {\n    case 'add': {\n      let newEntry: MetaEntry | undefined;\n\n      if (singular) {\n        const oldEntry = parentEntry[relationship] as MetaEntry | undefined;\n        if (oldEntry !== undefined) {\n          assert(\n            schema.compareRows(oldEntry, change.node.row) === 0,\n            `Singular relationship '${relationship}' should not have multiple rows. You may need to declare this relationship with the \\`many\\` helper instead of the \\`one\\` helper in your schema.`,\n          );\n          // adding same again.\n          oldEntry[refCountSymbol]++;\n        } else {\n          newEntry = makeNewMetaEntry(change.node.row, schema, withIDs, 1);\n\n          (parentEntry as Writable<Entry>)[relationship] = newEntry;\n        }\n      } else {\n        newEntry = addToView(\n          change.node.row,\n          getChildEntryList(parentEntry, relationship),\n          schema,\n          withIDs,\n        );\n      }\n\n      if (newEntry) {\n        for (const [relationship, children] of Object.entries(\n          change.node.relationships,\n        )) {\n          // TODO: Is there a flag to make TypeScript complain that dictionary access might be undefined?\n          const childSchema = must(schema.relationships[relationship]);\n          const childFormat = childFormats[relationship];\n          if (childFormat === undefined) {\n            continue;\n          }\n\n          const newView = childFormat.singular\n            ? undefined\n            : ([] as MetaEntryList);\n          newEntry[relationship] = newView;\n\n          for (const node of skipYields(children())) {\n            applyChange(\n              newEntry,\n              {type: 'add', node},\n              childSchema,\n              relationship,\n              childFormat,\n              withIDs,\n            );\n          }\n        }\n      }\n      break;\n    }\n    case 'remove': {\n      if (singular) {\n        const oldEntry = parentEntry[relationship] as MetaEntry | undefined;\n        assert(oldEntry !== undefined, 'node does not exist');\n        const rc = oldEntry[refCountSymbol];\n        if (rc === 1) {\n          (parentEntry as Writable<Entry>)[relationship] = undefined;\n        }\n        oldEntry[refCountSymbol]--;\n      } else {\n        removeAndUpdateRefCount(\n          getChildEntryList(parentEntry, relationship),\n          change.node.row,\n          schema.compareRows,\n        );\n      }\n      break;\n    }\n    case 'child': {\n      let existing: MetaEntry;\n      if (singular) {\n        existing = getSingularEntry(parentEntry, relationship);\n      } else {\n        const view = getChildEntryList(parentEntry, relationship);\n        const bsResult = binarySearch(\n          view,\n          change.node.row,\n          schema.compareRows,\n        );\n        assert(bsResult >= 0, 'node does not exist');\n        existing = view[bsResult];\n      }\n\n      const childSchema = must(\n        schema.relationships[change.child.relationshipName],\n      );\n      const childFormat = format.relationships[change.child.relationshipName];\n      if (childFormat !== undefined) {\n        applyChange(\n          existing,\n          change.child.change,\n          childSchema,\n          change.child.relationshipName,\n          childFormat,\n          withIDs,\n        );\n      }\n      break;\n    }\n    case 'edit': {\n      if (singular) {\n        const existing = parentEntry[relationship];\n        assertMetaEntry(existing);\n        applyEdit(existing, change, schema, withIDs);\n      } else {\n        const view = getChildEntryList(parentEntry, relationship);\n        // The position of the row in the list may have changed due to the edit.\n        if (schema.compareRows(change.oldNode.row, change.node.row) !== 0) {\n          const oldBsResult = binarySearch(\n            view,\n            change.oldNode.row,\n            schema.compareRows,\n          );\n          assert(oldBsResult >= 0, 'old node does not exist');\n          const oldPos = oldBsResult;\n          const oldEntry = view[oldPos];\n          const newBsResult = binarySearch(\n            view,\n            change.node.row,\n            schema.compareRows,\n          );\n          const found = newBsResult >= 0;\n          const pos = found ? newBsResult : ~newBsResult;\n          // A special case:\n          // when refCount is 1 (so the row is being moved\n          // without leaving a placeholder behind), and the new pos is\n          // the same as the old, or directly after the old (so after the remove\n          // of the old it would be in the same pos):\n          // the row does not need to be moved, it can just be edited in place.\n          if (\n            oldEntry[refCountSymbol] === 1 &&\n            (pos === oldPos || pos - 1 === oldPos)\n          ) {\n            applyEdit(oldEntry, change, schema, withIDs);\n          } else {\n            // Move the row.  If the row has > 1 ref count, an edit should\n            // be received for each ref count.  On the first edit, the original\n            // row is moved, the edit is applied to it and its ref count is set\n            // to 1.  A shallow copy of the row is left at the old pos for\n            // processing of the remaining edit, and the copy's ref count\n            // is decremented.  As each edit is received the ref count of the\n            // copy is decrement, and the ref count of the row at the new\n            // position is incremented.  When the copy's ref count goes to 0,\n            // it is removed.\n            oldEntry[refCountSymbol]--;\n            let adjustedPos = pos;\n            if (oldEntry[refCountSymbol] === 0) {\n              view.splice(oldPos, 1);\n              adjustedPos = oldPos < pos ? pos - 1 : pos;\n            }\n\n            let entryToEdit;\n            if (found) {\n              entryToEdit = view[adjustedPos];\n            } else {\n              view.splice(adjustedPos, 0, oldEntry);\n              entryToEdit = oldEntry;\n              if (oldEntry[refCountSymbol] > 0) {\n                const oldEntryCopy = {...oldEntry};\n                view[oldPos] = oldEntryCopy;\n              }\n            }\n            entryToEdit[refCountSymbol]++;\n            applyEdit(entryToEdit, change, schema, withIDs);\n          }\n        } else {\n          // Position could not have changed, so simply edit in place.\n          const bsResult = binarySearch(\n            view,\n            change.oldNode.row,\n            schema.compareRows,\n          );\n          assert(bsResult >= 0, 'node does not exist');\n          applyEdit(view[bsResult], change, schema, withIDs);\n        }\n      }\n\n      break;\n    }\n    default:\n      unreachable(change);\n  }\n}\n\nfunction applyEdit(\n  existing: MetaEntry,\n  change: EditViewChange,\n  schema: SourceSchema,\n  withIDs: boolean,\n) {\n  Object.assign(existing, change.node.row);\n  if (withIDs) {\n    existing[idSymbol] = makeID(change.node.row, schema);\n  }\n}\n\nfunction addToView(\n  row: Row,\n  view: MetaEntryList,\n  schema: SourceSchema,\n  withIDs: boolean,\n): MetaEntry | undefined {\n  const bsResult = binarySearch(view, row, schema.compareRows);\n\n  if (bsResult >= 0) {\n    view[bsResult][refCountSymbol]++;\n    return undefined;\n  }\n  const pos = ~bsResult;\n  const newEntry = makeNewMetaEntry(row, schema, withIDs, 1);\n  view.splice(pos, 0, newEntry);\n  return newEntry;\n}\n\nfunction removeAndUpdateRefCount(\n  view: MetaEntryList,\n  row: Row,\n  compareRows: Comparator,\n): MetaEntry {\n  const bsResult = binarySearch(view, row, compareRows);\n  assert(bsResult >= 0, 'node does not exist');\n  const oldEntry = view[bsResult];\n  const rc = oldEntry[refCountSymbol];\n  if (rc === 1) {\n    view.splice(bsResult, 1);\n  }\n  oldEntry[refCountSymbol]--;\n\n  return oldEntry;\n}\n\n/**\n * Binary search a sorted view.\n *\n * Returns the index of `target` if found (a non-negative integer), or\n * `~insertionIndex` if not found (always negative, following Java's\n * `Arrays.binarySearch` convention). To get the insertion index when\n * not found use the bitwise NOT: `~result`.\n *\n * This avoids allocating a `{pos, found}` result object on every call.\n */\nfunction binarySearch(\n  view: MetaEntryList,\n  target: Row,\n  comparator: Comparator,\n): number {\n  let low = 0;\n  let high = view.length - 1;\n  while (low <= high) {\n    const mid = (low + high) >>> 1;\n    const comparison = comparator(view[mid] as Row, target as Row);\n    if (comparison < 0) {\n      low = mid + 1;\n    } else if (comparison > 0) {\n      high = mid - 1;\n    } else {\n      return mid; // found\n    }\n  }\n  return ~low; // not found; use ~result to get insertion index\n}\n\nfunction getChildEntryList(\n  parentEntry: Entry,\n  relationship: string,\n): MetaEntryList {\n  const view = parentEntry[relationship];\n  assertArray(view);\n  return view as MetaEntryList;\n}\n\nfunction assertMetaEntry(v: unknown): asserts v is MetaEntry {\n  assertNumber((v as Partial<MetaEntry>)[refCountSymbol]);\n}\n\nfunction getSingularEntry(parentEntry: Entry, relationship: string): MetaEntry {\n  const e = parentEntry[relationship];\n  assertNumber((e as Partial<MetaEntry>)[refCountSymbol]);\n  return e as MetaEntry;\n}\n\nfunction makeNewMetaEntry(\n  row: Row,\n  schema: SourceSchema,\n  withIDs: boolean,\n  rc: number,\n): MetaEntry {\n  if (withIDs) {\n    return {...row, [refCountSymbol]: rc, [idSymbol]: makeID(row, schema)};\n  }\n  return {...row, [refCountSymbol]: rc};\n}\nfunction makeID(row: Row, schema: SourceSchema) {\n  // optimization for case of non-compound primary key\n  if (schema.primaryKey.length === 1) {\n    return JSON.stringify(row[schema.primaryKey[0]]);\n  }\n  return JSON.stringify(schema.primaryKey.map(k => row[k]));\n}\n"],"mappings":"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"}

package/out/packages/zql/src/mutate/crud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.js","names":[],"sources":["../../../../../../zql/src/mutate/crud.ts"],"sourcesContent":["import type {Expand} from '../../../shared/src/expand.ts';\nimport {recordProxy} from '../../../shared/src/record-proxy.ts';\nimport type {SchemaValueToTSType} from '../../../zero-types/src/schema-value.ts';\nimport type {Schema, TableSchema} from '../../../zero-types/src/schema.ts';\nimport type {MutateCRUD} from './custom.ts';\n\nexport type SchemaCRUD<S extends Schema> = {\n  [Table in keyof S['tables']]: TableCRUD<S['tables'][Table]>;\n};\n\nexport type TransactionMutate<S extends Schema> = SchemaCRUD<S>;\n\nexport type TableCRUD<S extends TableSchema> = {\n  /**\n   * Writes a row if a row with the same primary key doesn't already exist.\n   * Non-primary-key fields that are 'optional' can be omitted or set to\n   * `undefined`. Such fields will be assigned the value `null` optimistically\n   * and then the default value as defined by the server.\n   */\n  insert: (value: InsertValue<S>) => Promise<void>;\n\n  /**\n   * Writes a row unconditionally, overwriting any existing row with the same\n   * primary key. Non-primary-key fields that are 'optional' can be omitted or\n   * set to `undefined`. Such fields will be assigned the value `null`\n   * optimistically and then the default value as defined by the server.\n   */\n  upsert: (value: UpsertValue<S>) => Promise<void>;\n\n  /**\n   * Updates a row with the same primary key. If no such row exists, this\n   * function does nothing. All non-primary-key fields can be omitted or set to\n   * `undefined`. Such fields will be left unchanged from previous value.\n   */\n  update: (value: UpdateValue<S>) => Promise<void>;\n\n  /**\n   * Deletes the row with the specified primary key. If no such row exists, this\n   * function does nothing.\n   */\n  delete: (id: DeleteID<S>) => Promise<void>;\n};\n\nexport type CRUDKind = keyof TableCRUD<TableSchema>;\n\nexport const CRUD_KINDS = ['insert', 'upsert', 'update', 'delete'] as const;\n\nexport type DeleteID<S extends TableSchema> = Expand<PrimaryKeyFields<S>>;\n\ntype PrimaryKeyFields<S extends TableSchema> = {\n  [K in Extract<\n    S['primaryKey'][number],\n    keyof S['columns']\n  >]: SchemaValueToTSType<S['columns'][K]>;\n};\n\nexport type InsertValue<S extends TableSchema> = Expand<\n  PrimaryKeyFields<S> & {\n    [K in keyof S['columns'] as S['columns'][K] extends {optional: true}\n      ? K\n      : never]?: SchemaValueToTSType<S['columns'][K]> | undefined;\n  } & {\n    [K in keyof S['columns'] as S['columns'][K] extends {optional: true}\n      ? never\n      : K]: SchemaValueToTSType<S['columns'][K]>;\n  }\n>;\n\nexport type UpsertValue<S extends TableSchema> = InsertValue<S>;\n\nexport type UpdateValue<S extends TableSchema> = Expand<\n  PrimaryKeyFields<S> & {\n    [K in keyof S['columns']]?:\n      | SchemaValueToTSType<S['columns'][K]>\n      | undefined;\n  }\n>;\n\n/**\n * This is the type of the generated mutate.<name>.<verb> function.\n */\nexport type TableMutator<TS extends TableSchema> = {\n  /**\n   * Writes a row if a row with the same primary key doesn't already exist.\n   * Non-primary-key fields that are 'optional' can be omitted or set to\n   * `undefined`. Such fields will be assigned the value `null` optimistically\n   * and then the default value as defined by the server.\n   */\n  insert: (value: InsertValue<TS>) => Promise<void>;\n\n  /**\n   * Writes a row unconditionally, overwriting any existing row with the same\n   * primary key. Non-primary-key fields that are 'optional' can be omitted or\n   * set to `undefined`. Such fields will be assigned the value `null`\n   * optimistically and then the default value as defined by the server.\n   */\n  upsert: (value: UpsertValue<TS>) => Promise<void>;\n\n  /**\n   * Updates a row with the same primary key. If no such row exists, this\n   * function does nothing. All non-primary-key fields can be omitted or set to\n   * `undefined`. Such fields will be left unchanged from previous value.\n   */\n  update: (value: UpdateValue<TS>) => Promise<void>;\n\n  /**\n   * Deletes the row with the specified primary key. If no such row exists, this\n   * function does nothing.\n   */\n  delete: (id: DeleteID<TS>) => Promise<void>;\n};\n\n/**\n * A function that executes a CRUD operation.\n * Client and server provide different implementations.\n */\nexport type CRUDExecutor = (\n  table: string,\n  kind: CRUDKind,\n  args: unknown,\n) => Promise<void>;\n\n/**\n * Creates a MutateCRUD function from a schema and executor.\n * This is the shared implementation used by both client and server.\n *\n * @param schema - The Zero schema\n * @param executor - A function that executes CRUD operations\n * @returns A MutateCRUD function that can be called with CRUDMutateRequest objects\n */\nexport function makeCRUDMutate<\n  TSchema extends Schema,\n  TAddSchemaCRUD extends boolean,\n>(\n  schema: TSchema,\n  addSchemaCRUD: TAddSchemaCRUD,\n  executor: CRUDExecutor,\n): MutateCRUD<TSchema, TAddSchemaCRUD> {\n  // Create a callable function that accepts CRUDMutateRequest\n  const mutate = (request: AnyCRUDMutateRequest) => {\n    const {table, kind, args} = request;\n    return executor(table, kind, args);\n  };\n\n  // Only add table properties when enableLegacyMutators is true\n  if (addSchemaCRUD) {\n    // Add table names as keys so the proxy can discover them\n    for (const tableName of Object.keys(schema.tables)) {\n      (mutate as unknown as Record<string, undefined>)[tableName] = undefined;\n    }\n\n    // Wrap in proxy that lazily creates and caches table CRUD objects\n    return recordProxy(\n      mutate as unknown as Record<string, undefined>,\n      (_value, tableName) => makeTableCRUD(tableName, executor),\n    ) as unknown as MutateCRUD<TSchema, TAddSchemaCRUD>;\n  }\n\n  return mutate as MutateCRUD<TSchema, TAddSchemaCRUD>;\n}\n\nexport function makeTransactionMutate<TSchema extends Schema>(\n  schema: TSchema,\n  executor: CRUDExecutor,\n): TransactionMutate<TSchema> {\n  const target: Record<string, undefined> = {};\n  for (const tableName of Object.keys(schema.tables)) {\n    target[tableName] = undefined;\n  }\n\n  return recordProxy(target, (_value, tableName) =>\n    makeTableCRUD(tableName, executor),\n  ) as SchemaCRUD<TSchema>;\n}\n\n/**\n * Creates a TableCRUD object that delegates to the executor.\n */\nfunction makeTableCRUD(\n  tableName: string,\n  executor: CRUDExecutor,\n): TableCRUD<TableSchema> {\n  return Object.fromEntries(\n    CRUD_KINDS.map(kind => [\n      kind,\n      (value: unknown) => executor(tableName, kind, value),\n    ]),\n  ) as TableCRUD<TableSchema>;\n}\n\nexport type CRUDMutator<\n  TSchema extends Schema,\n  TTable extends keyof TSchema['tables'] & string,\n  TKind extends keyof TableMutator<TSchema['tables'][TTable]>,\n  TArgs extends Parameters<TableMutator<TSchema['tables'][TTable]>[TKind]>[0],\n> = {\n  (args: TArgs): CRUDMutateRequest<TSchema, TTable, TKind, TArgs>;\n\n  /**\n   * Type-only phantom property to surface mutator types in a covariant position.\n   */\n  ['~']: Expand<CRUDMutatorTypes<TSchema, TTable, TKind, TArgs>>;\n};\n\nexport type CRUDMutatorTypes<\n  TSchema extends Schema,\n  TTable extends keyof TSchema['tables'] & string,\n  TKind extends keyof TableMutator<TSchema['tables'][TTable]>,\n  TArgs extends Parameters<TableMutator<TSchema['tables'][TTable]>[TKind]>[0],\n> = 'CRUDMutator' & CRUDMutateRequest<TSchema, TTable, TKind, TArgs>;\n\nexport type CRUDMutateRequest<\n  TSchema extends Schema,\n  TTable extends keyof TSchema['tables'],\n  TKind extends keyof TableMutator<TSchema['tables'][TTable]>,\n  TArgs extends Parameters<TableMutator<TSchema['tables'][TTable]>[TKind]>[0],\n> = {\n  readonly schema: TSchema;\n  readonly table: TTable;\n  readonly kind: TKind;\n  readonly args: TArgs;\n};\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyCRUDMutateRequest = CRUDMutateRequest<any, any, CRUDKind, any>;\n"],"mappings":";;AA6CA,IAAa,aAAa;CAAC;CAAU;CAAU;CAAU;AAAQ;;;;;;;;;AAqFjE,SAAgB,eAId,QACA,eACA,UACqC;CAErC,MAAM,UAAU,YAAkC;EAChD,MAAM,EAAC,OAAO,MAAM,SAAQ;EAC5B,OAAO,SAAS,OAAO,MAAM,IAAI;CACnC;CAGA,IAAI,eAAe;EAEjB,KAAK,MAAM,aAAa,OAAO,KAAK,OAAO,MAAM,GAC/C,OAAiD,aAAa,KAAA;EAIhE,OAAO,YACL,SACC,QAAQ,cAAc,cAAc,WAAW,QAAQ,CAC1D;CACF;CAEA,OAAO;AACT;AAEA,SAAgB,sBACd,QACA,UAC4B;CAC5B,MAAM,SAAoC,CAAC;CAC3C,KAAK,MAAM,aAAa,OAAO,KAAK,OAAO,MAAM,GAC/C,OAAO,aAAa,KAAA;CAGtB,OAAO,YAAY,SAAS,QAAQ,cAClC,cAAc,WAAW,QAAQ,CACnC;AACF;;;;AAKA,SAAS,cACP,WACA,UACwB;CACxB,OAAO,OAAO,YACZ,WAAW,KAAI,SAAQ,CACrB,OACC,UAAmB,SAAS,WAAW,MAAM,KAAK,CACrD,CAAC,CACH;AACF"}